docs: phase 4a fix rounds 4 and 5
The phase 4a docs were written before the last two fix rounds landed. They
now describe the code at 8c2b9f1b: a sequence left as it was inside a moving
folder is taken along instead of keeping that folder in place; a held plan on
an offline archive keeps its plan and fails as offline; render filing answers
503 folder_moved; a rebase never moves the rows of the sequence that took the
old folder (with its known limitation); every writer refuses a folder another
sequence holds (SequenceFolders.Holds). Three DECISIONS rows added, six
updated; five fix rounds in STATUS and the request.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 31d479c5f4dd0b7076b39331246815e95895a1fa)
This commit is contained in:
1 parent
8c2b9f1bfe
commit
23403f1c07
6 files changed
+71
-46
No files matched your search
@@ -58,7 +58,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Jobs` | `JobEngine` (one job at a time; reviews the priority queue and makes a lower running job yield, requeued with its checkpoint; no history purge, the housekeeping schedule's clean-up does it), `JobPriorityQueue` (a level per job kind, the claim order, settings round trip), `IJobHandler`, `IJobHandlerProvider`, `JobContext` (progress, checkpoints, follow-up jobs that never interrupt their parent), `JobThroughput`/`JobEta` (rate and bounded time left) |
|
||||
| `Scheduling` | `Scheduler` (one per host: seeds the host's system schedules, claims due runs by compare-and-set, catch-up, clock changes, create/edit/reset/delete/run now as API v1 DTOs), `ScheduleRecurrence` (the in-house `every:`/`daily:`/`weekly:`/`monthly:` form, wall-clock times across DST), `ScheduleActions` (action names, parameters, availability, the archive jobs a run queues), `IScheduleHost` and `SystemSchedule` (what the server and the desktop supply), `ScheduleOutcome`, `ScheduleMapping` (model ↔ DTO) |
|
||||
| `Housekeeping` | `BackupJobHandler`, `CleanupJobHandler`, `ICleanupStep` with the shared steps (`CleanupSteps`: job history, audit log, trash report that never deletes); hosts add their own steps through `ArchiveServiceOptions.CleanupSteps` |
|
||||
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `ArchiveIngest` (uploads and imports, named through `FrameNaming`), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance`, `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, every index row (the frame paths and render paths of the exports inside it, its own unless its file is still at the old place and another sequence's when its file moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed), job handlers |
|
||||
| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `ArchiveIngest` (uploads and imports, named through `FrameNaming`), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance`, `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, with the sequences of the plan an earlier step left as they were inside it (taken along, their title and file names kept), every index row (the frame paths and render paths of the exports inside it, a file or an image-sequence folder, its own unless the export is still at the old place and another sequence's when it moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceFolders` (`Holds`: the folder the index has for a sequence is there and its sidecar names no other sequence; every writer into a sequence's folder asks it), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed), job handlers |
|
||||
| `Processing` | `ProcessingService`, `SequenceAnalyser`, `DeepReports` (a saved deep report while it still describes the frames), `SequenceRender`, `ProjectStore`, `ProjectBundles` (a `.chronos` file for a sequence, and the sequence a file names), `RenderNodeClient`, job handlers |
|
||||
| `Sync` | `SyncService` (sync table of one server: compare, link by content, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, no I/O), `SyncTombstones` (photos either side removed are not offered back, a replaced photo counts as its replacement), `SyncPositions` (the settings' frame positions translated by photo to the frames of the copy they go to), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
|
||||
|
||||
@@ -87,7 +87,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Ui/Visuals` | `DrawingElement` (hover readout, item keyboard and activation) and its charts (`BarChart`, `SeriesChart`, `StackedBar`, `HeatmapStrip`, `TimelineBands`), `Filmstrip`, `PreviewViewport`, `CurveEditor`, `SequenceCard`, `VirtualizingWrapPanel`, `SegmentedControl`, `SplitButton` |
|
||||
| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty; `ArchiveEndpoints`: settings, statistics, scan jobs, Reorganize's dry run and `move` job, with `ReorganizePlanCache`: a dry run's plan, made apart from its request, kept a few minutes while what it reads from the index stays, for the same dry run and its confirmation), API errors, the WebSocket `EventHub` |
|
||||
| `Server/Security` | Accounts, password hashing, tokens, session cookies, login guard, access rules, audit log |
|
||||
| `Server/Storage`, `Server/Jobs` | Archive and processing modules (the archive module's `SequenceChanged` publishes `sequenceChanged` `reorganized`), uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step; `UploadService.ReceiveAgainAsync`: a verified upload whose filing was refused for now goes back to receiving, 503), render store (files a render under the sequence's lease, where the index has the folder then); `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service, monitor and availability |
|
||||
| `Server/Storage`, `Server/Jobs` | Archive and processing modules (the archive module's `SequenceChanged` publishes `sequenceChanged` `reorganized`), uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step; `UploadService.ReceiveAgainAsync`: a verified upload whose filing was refused for now goes back to receiving, 503), render store (files a render under the sequence's lease, where the index has the folder then; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service, monitor and availability |
|
||||
| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time; `reorganize.js` the Reorganize dialog of the Library's selection and of the Archive page's save toast: template switches and fields, a live dry run of `POST /archive/reorganize` one request at a time, Apply that sends the shown plan's fingerprint back) |
|
||||
|
||||
### 2.5 Hosts
|
||||
@@ -115,7 +115,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Backup` | `Housekeeping/BackupJobHandler` (via `ArchiveService.CreateJobHandlers`; an SQLite index file only) | yes | SQLite only |
|
||||
| `Cleanup` | `Housekeeping/CleanupJobHandler` (shared steps, plus the host's from `ArchiveServiceOptions.CleanupSteps`) | yes | yes |
|
||||
| `EmptyTrash` | `Archiving/Jobs/EmptyTrashJobHandler` (erases exactly a confirmed plan's trash entries; refuses a stale fingerprint) | yes | yes |
|
||||
| `Move` | `Archiving/Jobs/MoveJobHandler` (Reorganize, `MoveJobParameters`: the templates, the sequences and the confirmed fingerprint; plans again from the templates, applies the plan only while it is the one confirmed, holds it when paused, cancelled or failed, tells each sequence changed as its step completes) | yes | yes |
|
||||
| `Move` | `Archiving/Jobs/MoveJobHandler` (Reorganize, `MoveJobParameters`: the templates, the sequences and the confirmed fingerprint; plans again from the templates, applies the plan only while it is the one confirmed, holds it when paused, cancelled or failed, keeps it while the archive is offline, tells each sequence changed as its step completes) | yes | yes |
|
||||
| `Adopt` | none: done synchronously (`ArchiveService` actions) | — | — |
|
||||
|
||||
A job engine claims only kinds it has handlers for. Light analysis is queued by the engine (`JobContext` follow-up)
|
||||
@@ -155,11 +155,11 @@ sequence is. The image passes hold the thumbnail lease, which a Reorganize takes
|
||||
the proxy pass a batch at a time (a quarter of the lease wait), reading the folder and sidecar again for each batch. A
|
||||
folder another index moved is found by this index's next scan, which moves the row, its frames and its exports' paths
|
||||
(`ArchiveIndexer.RebaseRendersAsync`; an export, a file or an image-sequence folder, still at the old place keeps its
|
||||
path, unless the old folder is another sequence's now); until then these writers, a render job as it starts and a
|
||||
proxy pass at each batch refuse when they find the folder gone (the server's render filing with a 503 that keeps the
|
||||
upload), and a deep
|
||||
analysis that loses it records nothing. A render whose folder another index moves while it runs is not stopped: its
|
||||
output can land in a folder created again at the old place, where its row keeps finding it.
|
||||
path, unless the old folder is another sequence's now, and an export of the sequence that holds the old folder never
|
||||
follows); until then these writers, a render job as it starts and a proxy pass at each batch refuse when they find the
|
||||
folder gone or holding another sequence (`SequenceFolders.Holds`; the server's render filing with a 503 that keeps the
|
||||
upload), and a deep analysis that loses it records nothing. A render whose folder another index moves while it runs is
|
||||
not stopped: its output can land in a folder created again at the old place, where its row keeps finding it.
|
||||
|
||||
Sync (desktop ↔ server, BRIEF §14.5) reuses the same paths: `SyncService` compares the local index with the server's
|
||||
listing (settings and tags carry version counters), uploads go through the chunked protocol into the server's
|
||||
|
||||
+33
-17
@@ -499,6 +499,11 @@ step being one sequence and the sequences nested in a folder that moves with it:
|
||||
folder of that exact name), and in one transaction the index follows: the sequence's folder
|
||||
and title, its frames' paths and the paths of the exports that moved with the folder. Only
|
||||
then are files renamed; once its folder moved, a step always goes to its end.
|
||||
- A sequence of the plan that an earlier step left as it was inside a folder that moves later
|
||||
(it changed after the plan, or the folder that was to carry it stayed) goes with that folder,
|
||||
under the same leases, keeping its title and file names. Before a held plan resumes, a folder
|
||||
that moves may hold only such sequences and those of the steps still to come; any other
|
||||
refuses the plan, which is then given up.
|
||||
- File renames run under `rename-files.json` in the sequence's `.chronos/`: every file first to
|
||||
a hidden temporary name beside it (`.chronos-rename-<token>-<n>.tmp`), then every file to its
|
||||
new name, so chains and swaps of names never meet a name another file holds and no file is
|
||||
@@ -1028,6 +1033,8 @@ the same (§14.8), through the same engine and job.
|
||||
deleted since named in its log. It changes one step at a time. Pause or cancel stops
|
||||
between two steps and holds the rest for the job's resume or retry; a failed job holds it too
|
||||
(also when the archive's volume went away), and its retry completes it while it still fits.
|
||||
A retry while the archive is still offline fails as offline and keeps the plan: a plan
|
||||
journal it cannot reach is never taken for one completed.
|
||||
An archive open completes a plan an interruption left (a crash, a yield to another job, the
|
||||
program closing), not one its job holds.
|
||||
- What changed after the dry run: a sequence moved or gone, one indexed inside a folder that
|
||||
@@ -1036,10 +1043,11 @@ the same (§14.8), through the same engine and job.
|
||||
steps done stay, and a new dry run is needed. Photos changed since (a sequence still
|
||||
receiving them) refuse nothing: that sequence keeps its file names, and its folder and title
|
||||
change while the templates still give them from its first photo as it is now, otherwise it
|
||||
stays as it was, with any folder around it that was to move with it. A photo in use or a new
|
||||
name taken keeps that sequence's file names (every file back). These sequences are listed in
|
||||
the job's log, and the job fails at the end, after the others changed, saying how many; its
|
||||
retry plans again.
|
||||
stays as it was, and so do the sequences its folder was to carry. A sequence left as it was
|
||||
inside a folder that a later step moves goes with that folder, keeping its title and file
|
||||
names, so the folder around it still moves. A photo in use or a new name taken keeps that
|
||||
sequence's file names (every file back). These sequences are listed in the job's log, and
|
||||
the job fails at the end, after the others changed, saying how many; its retry plans again.
|
||||
- Deleting sequences of the archive is refused while a Reorganize job runs or is paused. The
|
||||
Archive and Library screens read the archive again when it ends; an editor open on a
|
||||
sequence it changed reloads where the sequence is now after that sequence's step.
|
||||
@@ -1342,12 +1350,13 @@ Reorganize (amended 2026-10-26, R7; ManageArchive; §7, §12.5, §14.8):
|
||||
expand.
|
||||
- Writers that file into a sequence's folder take it from the index row read under the
|
||||
sequence's lease, so they write where a Reorganize put it. Completing a render upload or a
|
||||
render node's result that cannot be filed for now (the sequence held past the lease wait, the
|
||||
archive offline or read-only, or the sequence's folder not where the index has it after
|
||||
another program moved it) answers 503 and keeps the upload receiving, to be completed again
|
||||
(`sequence_busy` and `archive_offline` for the first two); the node keeps its job. A proxy
|
||||
upload answers 503 `sequence_busy` while the sequence is held, 404 `frame` when the sequence
|
||||
or its folder is gone.
|
||||
render node's result that cannot be filed for now answers 503 and keeps the upload
|
||||
receiving, to be completed again: `sequence_busy` (the sequence held past the lease wait),
|
||||
`archive_offline` (the archive offline or read-only) or `folder_moved` (the sequence's folder
|
||||
not where the index has it, or holding another sequence, after another program moved them;
|
||||
the server's next scan finds it). The node keeps its job while it retries. A proxy upload
|
||||
answers 503 `sequence_busy` while the sequence is held, 404 `frame` when the sequence or its
|
||||
folder is gone, or the folder is another sequence's.
|
||||
|
||||
Uploads (amended 2026-10-26, R3, R6): `server/info` lists `extensions`, the photo file
|
||||
extensions the archive files (lower case, no dot), which the admin panel's dialog keeps to. A
|
||||
@@ -1463,12 +1472,19 @@ an archive, a Reorganize by one index (or a folder moved by hand) is found by th
|
||||
scan, which moves the sequence's row, its frames and the paths of the exports that moved with
|
||||
the folder (a file or, for an image sequence, a folder; an export written at the old place
|
||||
after the move keeps its path there, and another sequence's export saved inside follows only
|
||||
when it moved with the folder). Until that scan nothing writes into the old place, which would
|
||||
create it again: *Save both* and *Take server* answer that the folder is not where the index
|
||||
has it (try again after the next scan), and so do the editor's saves, a render job as it
|
||||
starts, exports fetched by sync and a proxy pass at each batch; a deep analysis that loses its
|
||||
folder records nothing. A render of the other program whose folder moves while it runs is not
|
||||
stopped.
|
||||
when it moved with the folder). The other program may also have moved another sequence into
|
||||
the old folder (its sidecar names that sequence): the moving sequence's exports then follow to
|
||||
its new folder, and an export of the sequence that took the old folder never follows, so no
|
||||
row names another sequence's file. Until that scan nothing writes into the old place, which
|
||||
would create it again, nor into another sequence that took it: *Save both* and *Take server*
|
||||
answer that the folder is not where the index has it (try again after the next scan), and so
|
||||
do a render job as it starts, exports fetched by sync, a proxy pass, and a thumbnail pass that
|
||||
finds another sequence's sidecar there; the editor's save says the sequence is no longer in
|
||||
the archive, and a deep analysis that loses its folder records nothing. A render of the other
|
||||
program whose folder moves while it runs is not stopped. Known limitation: an export a
|
||||
sequence saved into another sequence's folder (the Export folder picker), before the other
|
||||
program moved that sequence away and the first one into its folder, keeps naming the old
|
||||
path; the file is intact, moved with the other sequence.
|
||||
|
||||
### 14.6 Job engine
|
||||
|
||||
@@ -2191,7 +2207,7 @@ questions asked and the answers; DECISIONS rows give the reasons.
|
||||
| 2026-10-26 | Owner review 2, R11 | §12.8, §14.1, §14.3, §14.8, §14.9, §19.6 | Log settings: file and console levels apart on the server (`CHRONOS_LOG_LEVEL` locks both, `CHRONOS_LOG_CONSOLE_LEVEL` the console), retention, a file size limit with numbered parts, a total size limit, daily or hourly rotation, audit retention and the diagnostics share, in the admin panel's Settings › Logs (applied at once, `lockedBy` naming the variable) and the desktop's Settings › Advanced (from the first log line); the server's files take Debug and Trace when asked; logging never fails a job. |
|
||||
| 2026-10-26 | Owner review 2, R6 | §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8 | The admin panel manages, never edits: a Library page (filters from facets, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete), a sequence's page with a photo viewer, cover, downloads and photo deletion, and the trash view with Restore and Empty; photos deleted into `trash/photos` under journals, a photo never hashed hashed as it goes, tombstones in the sidecar (`removed`) and the index (`frame_removals`, migration 0008) that keep sync and uploads from bringing a deleted photo back unless the user restores it or uploads it again on purpose; trash kinds, restore reasons, and Empty as the `empty-trash` job behind a dry run, a typed confirmation and a fingerprint, never scheduled; the library, trash and bulk endpoints; the panel's files revalidated (`no-cache`, ETag). |
|
||||
| 2026-10-26 | Owner review 2, R3 | §14.3, §14.4, §14.8 | Upload from the admin panel into an existing or a new sequence (file picker, drag and drop, no folders), hashed in the browser by a self-tested in-house SHA-256 in a module worker, the capture time read from Exif, sent in resumable chunks through the upload API and verified by the server; `server/info` lists the photo extensions; hidden dot files are refused for every client. |
|
||||
| 2026-10-26 | Owner review 2, R7 (Reorganize) | §5, §7, §12.2, §12.5, §12.8, §14.3, §14.5, §14.8 | Reorganize on the desktop (Archive manager, Library, the toast of Settings › Archive) and the admin panel (Library, the toast of Archive): folder, file and title templates applied to sequences already filed, behind a dry run that lists each sequence's changes, the photos that keep their names and why (in place outside `originals/`, never hashed, missing) and the sequences that stay whole (unreadable sidecar); applied by the `move` job of exactly the confirmed plan (fingerprint), which holds the rest when paused, cancelled or failed and lets a sequence still receiving photos keep its file names; crash-safe plan and file journals (two-phase renames through hidden temporary names, recovery by the next writer); the index, frames and exports follow a moved folder in one transaction, on this index and at another index's next scan; writers take the folder under the lease and never create a left one again; `POST /api/v1/archive/reorganize` with a kept, bounded plan cache and `sequenceChanged` `reorganized`; Rename… and Move… replaced. |
|
||||
| 2026-10-26 | Owner review 2, R7 (Reorganize) | §5, §7, §12.2, §12.5, §12.8, §14.3, §14.5, §14.8 | Reorganize on the desktop (Archive manager, Library, the toast of Settings › Archive) and the admin panel (Library, the toast of Archive): folder, file and title templates applied to sequences already filed, behind a dry run that lists each sequence's changes, the photos that keep their names and why (in place outside `originals/`, never hashed, missing) and the sequences that stay whole (unreadable sidecar); applied by the `move` job of exactly the confirmed plan (fingerprint), which holds the rest when paused, cancelled or failed and lets a sequence still receiving photos keep its file names; crash-safe plan and file journals (two-phase renames through hidden temporary names, recovery by the next writer); a sequence of the plan left as it was inside a moving folder goes with it; the index, frames and exports follow a moved folder in one transaction, on this index and at another index's next scan; writers take the folder under the lease, never create a left one again and never write into a folder another sequence took; `POST /api/v1/archive/reorganize` with a kept, bounded plan cache and `sequenceChanged` `reorganized`; Rename… and Move… replaced. |
|
||||
| 2026-10-26 | Owner review 2, R7 (naming) | §7.1, §13, §14.3 | One naming rule for import, upload and Reorganize: the sequence's camera and lens, `{n}` its place, a frame without a time at the sequence's start; template rules everywhere a template is typed or sent (no folder level scans skip, one a value such as a title gives escaped with `_`; a file template keeps the extension, tells photos apart, holds no slash; long names shortened before `.{ext}`; titles as text), held to a template only when it is given anew; `invalid_template` names the rule. |
|
||||
|
||||
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
|
||||
|
||||
+19
-13
@@ -29,12 +29,13 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
every file back, and a crash is completed by the next program that writes the sequence. XMP files follow their
|
||||
photo. The plan's journal lets an interrupted Reorganize finish at the next archive open; one whose job was paused,
|
||||
cancelled or failed waits for that job to be resumed or retried (a job that failed because the archive's drive went
|
||||
away completes the plan once the drive is back).
|
||||
away completes the plan once the drive is back; retried while the drive is still away, it fails and keeps the plan).
|
||||
- A folder that moves takes along the sequences nested in it and the exports inside it; an editor open on a
|
||||
reorganized sequence reloads where it is now (desktop).
|
||||
- A sequence still receiving photos does not stop a Reorganize: it keeps its file names while its folder and title
|
||||
change, the others go on, and the job then says how many sequences were not reorganized as planned. A new
|
||||
Reorganize completes them.
|
||||
- A sequence still receiving photos does not stop a Reorganize: it keeps its file names, and its folder and title
|
||||
change while its first photo still gives them, else it stays as it is; the others go on, and the job then says how
|
||||
many sequences were not reorganized as planned. A new Reorganize completes them. A selected sequence left as it is
|
||||
inside a selected folder that moves goes with that folder, keeping its title and file names.
|
||||
- API v1: `POST /api/v1/archive/reorganize` (archive administrators): a dry run with the plan and its fingerprint, then
|
||||
the change as a `move` job (202) for exactly that plan, 409 `plan_changed` when the archive changed since, 503
|
||||
`plan_dropped` when the server stopped making a plan; the server keeps a dry run a few minutes for its confirmation.
|
||||
@@ -48,7 +49,10 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
sequences is refused while a Reorganize job runs or is paused; a render of another program whose folder moves while
|
||||
it runs is not stopped, and its output can land in a folder created again at the old place; a plan journal that
|
||||
cannot be read is logged and left in `.chronos/journal`: the archive opens, its plan is not resumed and its job
|
||||
fails with the reason.
|
||||
fails with the reason; a render node retries a result the server cannot file for now for about 30 seconds, then
|
||||
its job fails and a retry renders it again; an export one sequence saved into another's folder (the Export folder
|
||||
picker) keeps naming its old path when another program then moves that other sequence away and the first one into
|
||||
its folder (the file is intact: it moved with the other sequence).
|
||||
|
||||
### Changed
|
||||
- Import, upload and Reorganize name photos by one rule: every photo of a sequence is named with the sequence's camera
|
||||
@@ -73,10 +77,10 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
- Renaming a sequence's files raises its frames version: an editor or client holding the old one reloads once.
|
||||
- Proxy passes hold the thumbnail lease one batch (about 30 s) at a time, so another program's Reorganize, sequence
|
||||
deletion or pack compaction waits for one batch rather than the whole pass.
|
||||
- Server: a render upload or a render node's result that cannot be filed for now (the sequence busy past the lease
|
||||
wait, the archive offline, or its folder moved by another program sharing the archive) answers 503 and keeps the
|
||||
upload, to be completed again; the node keeps its job. A proxy upload answers 503 `sequence_busy` while the sequence
|
||||
is busy.
|
||||
- Server: a render upload or a render node's result that cannot be filed for now answers 503 and keeps the upload, to
|
||||
be completed again: `sequence_busy` (the sequence busy past the lease wait), `archive_offline`, or the new
|
||||
`folder_moved` (another program sharing the archive moved its folder, or moved another sequence into it, until the
|
||||
server's next scan); the node keeps its job. A proxy upload answers 503 `sequence_busy` while the sequence is busy.
|
||||
- The job kind *Move* is now *Reorganize*.
|
||||
|
||||
### Fixed
|
||||
@@ -87,12 +91,14 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
capture time in the index, and failed on sequences created without photos; folders now come from the sequence's
|
||||
first photo, and such sequences are left out.
|
||||
- Exports stay reachable when another program sharing the archive moves their sequence's folder (its Reorganize, or a
|
||||
folder moved by hand): the next scan moves their paths with the folder, image-sequence exports included. Before,
|
||||
they answered 404 there.
|
||||
folder moved by hand): the next scan moves their paths with the folder, image-sequence exports included, and when
|
||||
another sequence was moved into the old folder each sequence keeps naming its own exports. Before, they answered
|
||||
404 there.
|
||||
- A writer that read a sequence before its folder moved (an upload, a proxy, an export, an editor save, a sync, a deep
|
||||
analysis) writes where the sequence is now, or, when another program moved it, refuses until the next scan instead
|
||||
of creating the old folder again. Desktop: *Save both* and *Take server* on such a sequence say that its folder is
|
||||
not where the index has it, and a render job of it does not start.
|
||||
of creating the old folder again, and also when that program moved another sequence into the folder it left, so
|
||||
nothing lands in the other sequence's folder. Desktop: *Save both* and *Take server* on such a sequence say that
|
||||
its folder is not where the index has it, and a render job of it does not start.
|
||||
|
||||
## [0.1.0-rc.5] — 2026-10-27
|
||||
|
||||
|
||||
+9
-6
@@ -503,16 +503,19 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-26 | A step's file renames run under `.chronos/rename-files.json` (the frames version, the phase, every file's old, temporary and new name): every file first to a hidden temporary name beside it (`.chronos-rename-<token>-<n>.tmp`), the journal then at phase 2, then every file to its new name, never with overwrite; then the sidecar (frames version + 1, frame order and ids unchanged, so an editor holding the old version reloads once), the index (`FrameRepository.RenameFilesAsync`, only from the version the renames started at), and the journal goes. A failure while files move puts every file back; when one cannot go back, the journal completes the renames at once. After a crash the next writer of the sequence (`SequenceWriter.ReadLocked`; the plan's resume; an archive open for a held plan's unfinished steps) rolls forward, safe to run again from any point: phase 1 becomes phase 2 once every file is at its temporary name, a new name taken meanwhile sends the photo and its companions together back to their old names or the first free `_n` (journaled before they move), and the journal stays while a temporary file is left; the index follows at the plan's resume or the next scan. (Owner review 2, R7.) | Rename one file at a time in place; roll a crash back | Chains (A→B, B→C) and swaps never meet a name another file holds and nothing is ever written over; once files reached their new names, rolling forward is the shorter way to a sidecar that matches the disk. |
|
||||
| 2026-10-26 | Each step (a sequence and those nested in a folder that moves with it) takes the sequence leases, then the thumbnail leases, by id, and checks under them, before anything of it moves: the sequences where the plan has them, no sequence indexed since inside a folder that moves, nothing at its new folder (`TargetTaken`: a folder on disk, or an index row there, around or inside it), no sidecar of a newer format to rewrite, the title it was planned from where it changes the title or names the folder or files after it (`NamedByTitle`), the folder and title the templates give from the settled sidecar, and the file renames planned again (by digest). Those that refuse (all but the names and the file renames) also run up front, without the leases, before a fresh or a held plan starts. Then the folder moves, every index row of the step follows (folder and title, frame paths, export paths, one transaction), and only then are files renamed; once its folder moved, a step goes to its end whatever is cancelled. A sidecar that cannot be read or written after the move still has its row follow (title kept, no scan stamps), every sequence of the step is told, and the step fails so the job holds the plan. (Owner review 2, R7.) | Rename the files first; check only when the plan starts | Nothing of a step is half-applied when the plan no longer fits, the index never names a folder the sequence left, and no writer works in a folder while it moves or its files are renamed. |
|
||||
| 2026-10-26 | A Reorganize is confirmed by its plan's fingerprint: the SHA-256 of the file template and of the steps as the dry run shows them (ids, folders, titles, carried, file count, samples, what stays and why) with each step's file renames as one digest (`RenameStep.FileDigest`), not the frames version. The `move` job's parameters (`MoveJobParameters`) carry the templates, the sequences that have a step in the order the plan was made for (which decides the folder that gets " (2)") and the fingerprint, no file list; the job plans again and applies only a plan of the same fingerprint, else fails with "The archive changed after this plan was made" and nothing changes, naming in its log a sequence deleted since. The server answers a confirmation whose plan differs 409 `plan_changed` with the fingerprint now. (Owner review 2, R7.) | Store the plan or its file list in the job; include the frames version | The change made is exactly the one shown (destructive operations rule); the parameters stay small for 100,000 photos; photos uploaded under the names the plan leaves them (the archive's file template is the Reorganize's, the usual case after saving templates) must not refuse it. |
|
||||
| 2026-10-26 | Photos changed after the plan (received, removed, hashed or copied in, so that the renames planned again differ) refuse nothing: under its leases that sequence keeps its file names (`FilesKept`), and its folder and title change as planned while the templates still give them from its first photo as it is now (the plan journals its folder and title templates; `RenamePlanner.Names`, `Gives`: the expansion or its " (n)"); otherwise it stays as it was (`Dropped`; `TitlesKept` when an interrupted run moved its folder already), and so do the sequences its folder was to carry (`CarriedKept`). A selected sequence that so stays inside a folder that was to move keeps that folder in place, with what it carries, instead of failing every retry. The other steps go on, and the job fails at the end saying how many sequences were not reorganized as planned. A title edited since, a folder taken, a sequence moved or indexed inside a moving folder, or a sidecar of a newer format refuse the rest of the plan instead (a plan an interruption left drops that step, or keeps what no longer fits). A plan journaled before its templates were kept is applied as planned. (Owner review 2, R7.) | Refuse the step, or the whole plan, as soon as a photo arrives | A time-lapse camera uploading every few seconds would make a file Reorganize impossible; a folder or title must never be named after a photo that is no longer first; a user's title edit is never written over. |
|
||||
| 2026-10-26 | Reorganize is a job on both hosts: `JobKind.Move` (stored 14, wire `move`, now labelled *Reorganize*), user priority, target the archive, handled by `MoveJobHandler` through `ArchiveService.CreateJobHandlers`; the desktop dialog keeps its dry run in-window and Apply queues the job. Progress counts the steps that change; the checkpoint is `plan:<id>` once the plan's journal exists. Paused or cancelled by the user, or failed, the job stops between two steps and holds the plan (`RenameJournal.Held`): an archive open leaves it to the job (completing only file renames a step left half-way), and the job's resume or retry completes it while it still fits, else gives it up (journal deleted). A yield to another job or a host that stops leaves it unheld, completed at the next open. A failed job whose plan is over (completed with sequences kept, or given up) checkpoints `applied`, so its retry plans again; one that failed because the archive's volume went away keeps its plan, and its retry completes it once the volume is back. Deleting sequences of the archive is refused while the job runs or is paused. (Owner review 2, R7.) | Apply inside the dialog, as the 2026-10-03 and 2026-10-06 rename dialog did; complete held plans at the next open | A Reorganize can rename every photo of an archive: as a job it is paused, resumed after a restart, followed and retried in Jobs, on the same path as the panel; an archive open must not finish behind the user's back what they paused. |
|
||||
| 2026-10-26 | Photos changed after the plan (received, removed, hashed or copied in, so that the renames planned again differ) refuse nothing: under its leases that sequence keeps its file names (`FilesKept`), and its folder and title change as planned while the templates still give them from its first photo as it is now (the plan journals its folder and title templates; `RenamePlanner.Names`, `Gives`: the expansion or its " (n)"); otherwise its title and file names stay, and its folder too (`Dropped`; `TitlesKept` when an interrupted run moved its folder already), and so do the sequences its folder was to carry (`CarriedKept`). A sequence so left inside the folder of a later step that moves goes with that folder (next row); the folder around it is never kept in place for it. The other steps go on, and the job fails at the end saying how many sequences were not reorganized as planned. A title edited since, a folder taken, a sequence moved or indexed inside a moving folder, or a sidecar of a newer format refuse the rest of the plan instead (a plan an interruption left drops that step, or keeps what no longer fits). A plan journaled before its templates were kept is applied as planned. (Owner review 2, R7.) | Refuse the step, or the whole plan, as soon as a photo arrives | A time-lapse camera uploading every few seconds would make a file Reorganize impossible; a folder or title must never be named after a photo that is no longer first; a user's title edit is never written over. |
|
||||
| 2026-10-26 | A sequence of the plan that an earlier step left as it was (it changed after the plan, such as photos that make the templates name it otherwise now, or, when a plan resumes, whatever drops a step), or that stayed with a folder that was to carry it, is taken along by a later step whose folder moves while the index still has it inside that folder (at its own folder, or where an interrupted run's move took it): `MassRenamer.LeftInsideAsync` adds it to that step as a carried sequence with its title and file names as they are, locked, leased, moved and recorded with the folder. The tally counts it as titles kept (`TitlesKept`, logged "Title and file names kept, changed after the plan") instead of dropped; one whose carrier stayed is no longer kept when it was only to move, and is titles kept when it was to be retitled or renamed too; one a newer Chronos wrote stays counted as newer. Before a held plan resumes, the check without the leases (`RefuseStaleAsync`) accepts inside each moving folder only the sequences of the remaining steps and the completed ones so left there; any other refuses the plan, which is given up. (Owner review 2, R7.) | Refuse the outer step, which failed the plan at every retry; keep the outer folder in place with all it holds | Nested sequences move out first, so one that stayed was found inside the outer folder as a stranger and the plan stayed held for ever; the outer folder's change does not depend on the nested one's, and moving the nested sequence with its index row leaves no row behind. |
|
||||
| 2026-10-26 | Reorganize is a job on both hosts: `JobKind.Move` (stored 14, wire `move`, now labelled *Reorganize*), user priority, target the archive, handled by `MoveJobHandler` through `ArchiveService.CreateJobHandlers`; the desktop dialog keeps its dry run in-window and Apply queues the job. Progress counts the steps that change; the checkpoint is `plan:<id>` once the plan's journal exists. Paused or cancelled by the user, or failed, the job stops between two steps and holds the plan (`RenameJournal.Held`): an archive open leaves it to the job (completing only file renames a step left half-way), and the job's resume or retry completes it while it still fits, else gives it up (journal deleted). A yield to another job or a host that stops leaves it unheld, completed at the next open. A failed job whose plan is over (completed with sequences kept, or given up) checkpoints `applied`, so its retry plans again; one that failed because the archive's volume went away keeps its plan, and its retry completes it once the volume is back. A plan journal not found on an archive that cannot be reached (`ArchiveVolume.Probe` offline) tells nothing: a failed job then keeps its `plan:<id>` checkpoint instead of `applied`, and a retry while the archive is offline fails as offline ("The archive … is offline") instead of logging that the plan was completed at an archive open and ending done. Deleting sequences of the archive is refused while the job runs or is paused. (Owner review 2, R7.) | Apply inside the dialog, as the 2026-10-03 and 2026-10-06 rename dialog did; complete held plans at the next open | A Reorganize can rename every photo of an archive: as a job it is paused, resumed after a restart, followed and retried in Jobs, on the same path as the panel; an archive open must not finish behind the user's back what they paused; an unplugged drive must not make a held plan look completed. |
|
||||
| 2026-10-26 | The plan's journal keeps a tally of the whole plan (`RenameJournal.Done`: changed, files, dropped, files kept, titles kept, files busy, newer, carried kept), so the job log covers every run: "Sequences changed: N, files renamed: M", then one line per sequence not changed as planned, with why. The job then fails with one error: kept first ("changed after the plan"), then newer (a sequence file from a newer Chronos, met only when resuming), then busy (a photo in use or its new name taken); sequences kept because the folder around them stayed follow their carrier's reason. (Owner review 2, R7.) | Report only the last run; one generic error | A plan applied over several runs reports what it did as a whole, and each sentence must be true. |
|
||||
| 2026-10-26 | Each sequence a Reorganize changed is told through `ArchiveServiceOptions.SequenceChanged` (change `reorganized`) once its step is journaled, by its job or by an archive open that completed an interrupted plan, and at once for a step that failed after its folder moved; a failure to tell is logged, never passed on. The server publishes `sequenceChanged` `reorganized` with the row's versions (its open at start has no hook: no client is connected yet); the desktop raises `AppServices.SequenceReorganized`, and an editor open on that local sequence reloads where it is now while the job goes on (`LocalSequenceSource` reads the frames again when the folder changed while it listed them). (Owner review 2, R7.) | One event when the job ends | Steps done before a pause or a failure are told; an open editor would otherwise decode from paths that moved. |
|
||||
| 2026-10-26 | A folder move rebases the archive-relative paths of the exports inside it in the same transaction as the sequence row and its frames (`RenderRepository.RebaseFolderAsync`, `ArchiveIndexer.RebaseRendersAsync`). An export is a file, or a folder for an image sequence. The sequence's own exports follow unless one was written at the old place after the move (there and not at the new place, the old folder not another sequence's now), and so does one whose old path another sequence's export now names; another sequence's export saved inside (the Export folder picker) follows only when it moved with the folder; absolute paths and other folders stay. A scan that finds a sequence in another folder (another index's Reorganize, a folder moved by hand) applies the same rule. (Owner review 2, R7.) | Leave render rows to be recorded again; rebase by sequence only | Exports must stay downloadable and syncable on every host after a move, and a row must keep naming where its file is. |
|
||||
| 2026-10-26 | A writer takes a sequence's folder from the index row read under the sequence's lease (`SequenceWriter.FolderAsync`; renders a client or a node sends through `ArchiveService.UnderLeaseAsync`), so it writes where a Reorganize put the sequence and never creates the folder it left. A folder another index moved is not where this index has it until its next scan: the editor's saves, *Take server* and *Save both*, exports fetched by sync, proxies received or made, the server's render filing and a render job as it starts refuse it (on the desktop with "The folder of this sequence is not where the index has it; try again after the next scan"), and a deep analysis records nothing. Render filing that meets a sequence held past the lease wait, an offline archive or such a moved folder answers 503 and puts the upload back to receiving, the node keeping its job while its client retries; a proxy upload answers 503 `sequence_busy`, or 404 `frame` once its sequence or folder is gone. (Owner review 2, R7.) | Let writers create the old folder again; answer 409, or 500 as before | A folder created again holds files no index row names; `ChronosClient` retries only 503s and a render node fails its job on any other error, which would discard a finished render (a 500 left the upload stuck in Committing until a restart). |
|
||||
| 2026-10-26 | The proxy pass holds the thumbnail lease one batch at a time: a quarter of the lease wait (30 s by default), at least one photo, then lets it go for 750 ms (1.5 × `LeaseFile.LongestPoll`, 500 ms) and reads the folder, sidecar and companions again; a folder gone stops the job with the folder-moved error (resumed from its checkpoint after the scan), and photos changed between batches leave `ProxiesBuilt` unset. File renames take the thumbnail leases too; the thumbnail pass still holds its lease for its whole run. Cost: up to about 2.5 % on long passes. Another process's thumbnail pass may take the lease in a gap, and one longer than the lease wait then fails the running proxy pass, which resumes from its checkpoint. (Owner review 2, R7.) | Hold the lease for the whole pass; no lease | Another program's Reorganize, sequence deletion or pack compaction waits for one batch instead of failing after two minutes behind an hours-long pass, and no pass writes proxies into a folder that moved. |
|
||||
| 2026-10-26 | A folder move rebases the archive-relative paths of the exports inside it in the same transaction as the sequence row and its frames (`RenderRepository.RebaseFolderAsync`, `ArchiveIndexer.RebaseRendersAsync`). An export is a file, or a folder for an image sequence. The sequence's own exports follow unless one was written at the old place after the move (there and not at the new place, the old folder not another sequence's now), and so does one whose old path another sequence's export now names; another sequence's export saved inside (the Export folder picker) follows only when it moved with the folder, and never one of the sequence that holds the old folder now (next row); absolute paths and other folders stay. A scan that finds a sequence in another folder (another index's Reorganize, a folder moved by hand) applies the same rule. (Owner review 2, R7.) | Leave render rows to be recorded again; rebase by sequence only | Exports must stay downloadable and syncable on every host after a move, and a row must keep naming where its file is. |
|
||||
| 2026-10-26 | When another index moved a sequence out of its folder and another sequence into that folder, this index's rebase of the first one reads once which other sequence the old folder holds now (`SequenceFolders.OtherSequence`, the id its sidecar names): the first sequence's own exports follow to its new folder even when an export of that name is at the old path (it is the other sequence's), and a render row of the sequence that holds the old folder never follows, whatever the scan order (`RenderRepository.RebaseFolderAsync` gives the rule each row's owner). Known limitation: an export that sequence had saved through the Export folder picker into the first one's folder, before it took that folder, keeps naming the old path; the file is intact in the first sequence's new folder, and no scan repairs the row. (Owner review 2, R7.) | Let every row under a taken old folder follow; keep any row whose path still holds a file | When the scan rebased the holder first, its row then followed the other sequence and named that sequence's file, its own export left without a row for good; a row must never name another sequence's file, and the case left out needs an export saved into another sequence's folder before two moves by another program. |
|
||||
| 2026-10-26 | A writer takes a sequence's folder from the index row read under the sequence's lease (`SequenceWriter.FolderAsync`; renders a client or a node sends through `ArchiveService.UnderLeaseAsync`), so it writes where a Reorganize put the sequence and never creates the folder it left. A folder another index moved is not where this index has it until its next scan, and neither is one that holds another sequence now (next row): *Take server* and *Save both*, exports fetched by sync, proxies made and a render job as it starts refuse it with "The folder of this sequence is not where the index has it; try again after the next scan" (`Errors.Archive.FolderMoved`), proxies received with 404 `frame`, the server's render filing with 503 `folder_moved` (`FolderMovedException`) and the editor's save with "This sequence is no longer in the archive"; a deep analysis records nothing. Render filing that meets a sequence held past the lease wait, an offline archive or such a folder answers 503 (`sequence_busy`, `archive_offline`, `folder_moved`) and puts the upload back to receiving, the node keeping its job while its client retries (about 30 s; a node then reports the job failed, and its retry renders again); a proxy upload answers 503 `sequence_busy`, or 404 `frame` once its sequence or folder is gone. (Owner review 2, R7.) | Let writers create the old folder again; answer 409, or 500 as before | A folder created again holds files no index row names; `ChronosClient` retries only 503s and a render node fails its job on any other error, which would discard a finished render (a 500 left the upload stuck in Committing until a restart). |
|
||||
| 2026-10-26 | A sequence is in the folder the index has for it only while that folder exists and its sidecar, when it has one, names no other sequence (`SequenceFolders.Holds`; a sidecar that cannot be read does not count as another's). Every writer that files into a sequence's folder asks it, so a folder another index moved the sequence out of, and another sequence into, is refused exactly like a missing folder until this index's next scan: settings sync and *Take server* (nothing written), *Save both*'s copy and its clean-up (which deletes nothing in such a folder), exports fetched by sync (the download stays staged), the server's render filing, a render job as it starts, proxies received, proxy passes, the deep analysis's checkpoint and the editor's save; a thumbnail pass refuses a sidecar of another sequence before it opens the pack. (Owner review 2, R7.) | Check only that the folder exists; check the sidecar's id in some writers | With only the folder checked, *Take server* wrote the server's settings into the other sequence's `project.json`, *Save both* wrote this PC's copy into its `.chronos` and a render sent for the sequence was filed among its exports; one check shared by every writer leaves none out. |
|
||||
| 2026-10-26 | The proxy pass holds the thumbnail lease one batch at a time: a quarter of the lease wait (30 s by default), at least one photo, then lets it go for 750 ms (1.5 × `LeaseFile.LongestPoll`, 500 ms) and reads the folder, sidecar and companions again; a folder gone, or holding another sequence now, stops the job with the folder-moved error (resumed from its checkpoint after the scan), and photos changed between batches leave `ProxiesBuilt` unset. File renames take the thumbnail leases too; the thumbnail pass still holds its lease for its whole run. Cost: up to about 2.5 % on long passes. Another process's thumbnail pass may take the lease in a gap, and one longer than the lease wait then fails the running proxy pass, which resumes from its checkpoint. (Owner review 2, R7.) | Hold the lease for the whole pass; no lease | Another program's Reorganize, sequence deletion or pack compaction waits for one batch instead of failing after two minutes behind an hours-long pass, and no pass writes proxies into a folder that moved. |
|
||||
| 2026-10-26 | A sequence keeps its folder when it already is what the template gives, or that name with the " (n)" filing or an earlier Reorganize gave it, in the template's case; a change of case only is planned while no other folder holds that exact name (another sequence's, or on a case-sensitive file system a folder on disk beside the sequence's own: `RenamePlanner.ExistsExactly` compares every level exactly) and moves through a temporary name. No two sequences of a plan get folders that differ only in case. Under the step's leases a case-only target that now exists beside the sequence's own folder refuses the step (dropped when resuming), as `MoveFolder` would; a change of case in an outer level moves on every file system. (Owner review 2, R7.) | Compare folder names without case; make every target unique again | A second Reorganize must plan nothing (a folder flipped between " (2)" and " (3)" before); NTFS ignores case and Linux does not; a plan that fails at every archive open must never be journaled. |
|
||||
| 2026-10-26 | Template rules (`TemplateRules`, checked on three sample photos two seconds apart): a folder template may not write a level scans never enter (`ReservedFolder`: starting with `.`, or `originals`, `proxies`, `exports`, `.chronos`); a file template may hold no slash (`FileSeparator`), must keep the photo's extension (`Extension`: `PathTemplate.KeepsExtension`, the extension appended or after `.{ext}`) and must give a session's photos different names (`NotUnique`). What a template does not write itself is made safe instead: a folder level a title gives that scans skip gets a leading `_` (`ExpandFolder`, for import, upload and Reorganize alike), a file name over 200 characters is shortened before its `.{ext}` without splitting a surrogate pair, and a title template expands as text (`ExpandText`: control characters as spaces, at most 200 characters, no file-name sanitizing). Each rule has its sentence (`Errors.Template.<Rule>`). (Owner review 2, R7.) | Check only that a template parses | `{n}{ext}` drops the dot, and with it the extension every decoder goes by; a folder scans skip vanishes from a rebuilt index; repeating names fill a session with `_2`, `_3`; titles became `Paris_ night`. |
|
||||
| 2026-10-26 | The rules hold wherever a template is typed or sent: the desktop's Settings › Archive, Import and Reorganize fields (`NamingPreview`), the server's Reorganize and `PUT /archive/settings`, and the archive engine (`ArchiveSettings.Problem`, `CheckTemplates`). A template `archive.json` already holds (saved by 0.1.0-rc.5 or earlier) is held to them only when an edit changes it: the engine's `UpdateSettingsAsync` and the server's PUT check the rules only for templates that differ from the stored ones, every template still having to be non-blank, valid and expandable; `CreateAsync`, and so adopting a new folder, holds both to every rule (this PC's templates saved by an older version then refuse Welcome › Create, the toast naming the rule, fixed in Settings › Archive). A broken rule is a `TemplateRuleException` (an `ArgumentException` naming the field, with the rule), whose sentence the desktop's toasts show; the API's `invalid_template` details are `<field>:<rule>` (`fileTemplate:extension`) with that sentence in the request's language, a blank or invalid template keeping the bare field and the generic message. (Owner review 2, R7.) | Refuse every save while a stored template breaks a rule; check the rules in the user interfaces only | A pre-rules template must not block an edit of the name, the proxy size or the other template, on the desktop or the panel; neither the engine nor the server accepts from another client what the fields refuse. |
|
||||
| 2026-10-26 | The rules hold wherever a template is typed or sent: the desktop's Settings › Archive, Import and Reorganize fields (`NamingPreview`), the server's Reorganize and `PUT /archive/settings`, and the archive engine (`ArchiveSettings.Problem`, `CheckTemplates`). A template `archive.json` already holds (saved by 0.1.0-rc.5 or earlier) is held to them only when an edit changes it: the engine's `UpdateSettingsAsync` and the server's PUT check the rules only for templates that differ from the stored ones, every template still having to be non-blank, valid and expandable (the PUT compares with the archive as the server last read `archive.json`; when that file changed since, a desktop's edit say, and the engine refuses a template the form still sends, the answer is still `invalid_template` with the rule, never 409 `archive_policy`); `CreateAsync`, and so adopting a new folder, holds both to every rule (this PC's templates saved by an older version then refuse Welcome › Create, the toast naming the rule, fixed in Settings › Archive). A broken rule is a `TemplateRuleException` (an `ArgumentException` naming the field, with the rule), whose sentence the desktop's toasts show; the API's `invalid_template` details are `<field>:<rule>` (`fileTemplate:extension`) with that sentence in the request's language, a blank or invalid template keeping the bare field and the generic message. (Owner review 2, R7.) | Refuse every save while a stored template breaks a rule; check the rules in the user interfaces only | A pre-rules template must not block an edit of the name, the proxy size or the other template, on the desktop or the panel; neither the engine nor the server accepts from another client what the fields refuse. |
|
||||
| 2026-10-26 | The server keeps Reorganize dry runs (`ReorganizePlanCache`), keyed by the archive, the selection (all, or the ids in their order), the templates and `SequenceRepository.GetStampAsync`: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (`nested_target`, `not_found`), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (`Concurrency`) and 8 kept or being made (`Capacity`: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (`PlanTimeout`, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 `plan_dropped`. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) | Plan again at every request; plan in a background job with progress | An `all` dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). |
|
||||
| 2026-10-26 | `POST /api/v1/archive/reorganize` (ManageArchive): exactly one of `sequenceIds` (1–1,000) and `all`, a null template kept, at least one given; a dry run answers the plan (`ReorganizePlanDto`: steps with folders, titles, carried, frames version, file count, up to 3 samples and what stays, its reason in snake case with a sentence in the request's language; totals; fingerprint); the change answers 202 with the `move` job. 400 `bad_request` (`sequenceIds`, `templates`, `fingerprint`), `invalid_template`; 404 `not_found` (`sequence`); 409 `nested_target` (details: the folder), `plan_changed` (details: the fingerprint now), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_reorganized` ("sequences · files · folder, file and title templates"), which the panel's audit log and Dashboard show as a sentence. (Owner review 2, R7.) | Separate rename and move endpoints; every planned name in the answer | One request carries the three templates as both programs do; a dry run of 100,000 photos answers counts and samples, not every name. |
|
||||
| 2026-10-26 | Panel: the Library's *Reorganize…* sends the selected ids, up to 1,000, and `all: true` only above that while the selection is exactly *Select all* without a filter and the total has not changed; any other larger selection is refused with a toast, never split into several plans or jobs. The dialog's switches start on for the parts with a template (Titles off and empty, the archive having no title template; from the Archive page's toast only the changed parts), templates are sent trimmed, a dry run runs 400 ms after typing (Enter at once) with one request in flight and a change meanwhile planned right after, an older request's refusal is not shown, and Apply runs only while the shown plan is the fields' and changes a sequence. The confirmation has two buttons and asks for nothing typed (nothing is deleted); a different plan answered during it is shown, not applied. `toast(message, isError, action)` takes an optional link or button; such toasts stay 15 s and pause under the pointer or the keyboard focus. (Owner review 2, R7.) | Split a large selection into several jobs; a typed confirmation | One dialog is one plan and one job, and separate plans could give two sequences one destination; a typed word is for what cannot be undone. |
|
||||
|
||||
+1
-1
@@ -16,7 +16,7 @@ by its `windows` job once a Windows runner is registered (`WINDOWS_RUNNER`), and
|
||||
| 8 Release readiness | Release pipeline end to end (installers, portable and server zips, SHA256SUMS, release notes, optional signing, server image in the Gitea container registry, optional separate releases repository), update check with verified download, scrubbed diagnostics bundles (desktop and server), performance gates, 38 cultures (`en`, `it` and 36 machine translations with glossaries and independent reviews), RTL pass (`ar`, `he`: mirrored windows, left-to-right islands for media, charts, numbers and paths; any right-to-left culture added later follows), accessibility pass (names, live regions, keyboard paths for charts and the curve editor). The installer test (silent install of the packed installers, run, upgrade in place, uninstall: files, Add/Remove Programs, shortcuts, file type, user data kept, exit codes) runs in CI's `windows` job on a Windows runner. Pending: the interactive install on a real PC, Unraid template validation on a real server. |
|
||||
| 8.1 Owner review 1 | In progress (request, answers and plan: `docs/requests/2026-10-15-owner-review-1.md`). Phase 1 done: stalled thumbnail and proxy jobs no longer fail and stay Running (frame-counted progress, bounded time left, final state always written); the editor's cancelled decodes stay in their tasks (no debugger stops in `WicDecoderProvider.cs`); WIC decodes RAW only through the Raw Image Extension and never DNG; GoPro DNGs converted by Adobe software are DNGs, developed natively for videos, read through their embedded preview for analyses and previews, and reclassified in existing archives by the next light analysis. Phase 2 done: jobs run one at a time on the desktop and the server; Parallelism is how many photos the running job processes at once (thumbnail and proxy passes, tier probes, deep analysis, render decodes); pausing the running job starts the next; an optional priority queue by job kind (Settings › Rendering, admin panel › Settings › Jobs, `CHRONOS_PRIORITY_QUEUE`) pauses lower jobs and resumes them by themselves; `CHRONOS_PARALLELISM` replaces `CHRONOS_WORKERS`. Phase 3a done: the rail is 200 px and collapses to icons with ≡ or Ctrl+B (tooltips then name the sections, the choice saved at once); the admin panel's sidebar is 256 px and collapses the same way. Phase 3b done: the Sequence section is now Edit, one sequence at a time chosen in a picker inside the section (Change sequence, Ctrl+O; the sequence edited last selected first), and the editor's tabs are the steps of a guided, freely navigable path from a new Analysis step (every finding with the step that deals with it) to Export, each step showing where it stands, with Previous and Next. Next, after owner review 2 (the owner's order): phase 4, the visual crop locked to the output's proportions (R5) and mirroring, 90° rotations, straightening and colour filters (R6). |
|
||||
| 8.2 Chronos on Gitea | Done (request: `docs/requests/2026-10-23-chronos-gitea.md`): Titano renamed Chronos everywhere, translations' grammar included; repository, update check, links, issue forms and registry moved to the self-hosted Gitea; Gitea Actions CI, release, nightly image and performance workflows for the Linux runner, with the Windows programs cross-compiled and checked (`pe-check`); new `Chronos.Tools` commands `zip`, `gitea-release`, `postgres-ci`, `pe-check`. Pre-releases `v0.1.0-rc.1` and `v0.1.0-rc.2` (the update check builds its links from `ChronosReleasesUrl`, since Gitea's use its LAN ROOT_URL) published; `REGISTRY_TOKEN` is set and the `v0.1.0-rc.2` server image is in the registry. |
|
||||
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and four fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed and lets a sequence still receiving photos keep its file names; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everywhere (no folder scans skip, the extension kept, names that tell photos apart), held only to templates given anew. Known limitations: a readeLine truncated
|
||||
| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/<share>` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and five fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules eveLine truncated
|
||||
| 9 Monetization | Not started: requires explicit approval (§22). |
|
||||
|
||||
## Verification (2026-10-12)
|
||||
|
||||
@@ -72,7 +72,7 @@
|
||||
| 1 | R1 `:latest`, R2 array space, R4 gear and Settings at the bottom, R5 About inside Settings, R9 whole-folder import | done 2026-10-26, released as `v0.1.0-rc.3`: BRIEF §12.1, §12.4, §12.8, §12.9, §13, §14.4, §14.8, §14.9, §19.3, §19.5, §19.6, §24; 12 DECISIONS rows dated 2026-10-26 (R1 `:latest` and `release-channels`; R2 space path, mountinfo file system, fall-back warning, write volume, 507 at completion, `VolumeSpace`; R4/R5 admin menu and About group; R4 gear icon and `icons.py` generating `icons.js`; R5 desktop About page; R9 whole-folder grouping and its session key); CHANGELOG [Unreleased]; STATUS 8.3. `:latest` appears with the next pre-release: re-publishing `v0.1.0-rc.2` builds the tag's `Chronos.Tools`, which lacks `release-channels` | `1f089888` |
|
||||
| 2 | R11 log settings, R10 scheduled jobs (migration 0007) | done 2026-10-27, released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): BRIEF §5, §6.2, §7, §12.5, §12.6, §12.8, §14.1, §14.3, §14.6, §14.8, §14.9, §19.6, §24; 30 DECISIONS rows dated 2026-10-26 (R10 text recurrence form instead of cron, compare-and-set claim, system schedules seeded once, the timers they replace, catch-up, live services that are not schedules, the trash only reported, history and audit purges in clean-ups, one audit retention, scan at start, deep analysis read at run time, 6-hour upload sweep, Scheduled as a Jobs tab, Backup and Cleanup job kinds, 500 sequences per job, index backups and one backup retention, the archive.json timer, schedule API and audit, `scheduleChanged`, time zone, cache trim, desktop toasts, texts and archive reopening; R11 log defaults, rotation and pruning, the Debug/Trace fix, `CHRONOS_LOG_LEVEL` locking both levels, the log settings DTO and desktop rows, logging that never fails a job), six earlier rows marked superseded; CHANGELOG [Unreleased] with the `CHRONOS_LOG_LEVEL` and migration 0007 upgrade notes; STATUS 8.3 | `af9eeaab` |
|
||||
| 3 | R6 library on the panel, photo delete and trash (migration 0008), R3 web upload | done 2026-10-27, released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; tried by hand in a browser): BRIEF §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8, §24; 24 DECISIONS rows dated 2026-10-26 (R6 photo trash layout, deletion journal and hidden pending record, restore journal and `.restoring` staging under the entry lease, restore rules and kept reasons, tombstones in sidecar and index, never-hashed photos hashed at deletion with the missing ones left without a tombstone as a known limitation, positions and follow-ups, Empty only as an explicit job with a fingerprint and never scheduled, trash API and audit, photo-delete permission and body limit, bulk limits of 1,000 a request and the verify fix, the upload tombstone checks and the explicit restore flag, sync tombstones and aliases, hidden dot files refused, Library navigation and the on-demand upload module, facets and covers, panel confirmations, CSV and grids, live refresh without job kinds, static files `no-cache` with ETag; R3 in-house SHA-256 worker, fail-closed self-test, no folder upload and `server/info` extensions, upload pacing and capture time, Cancel deletes and Close keeps); CHANGELOG [Unreleased] with the migration 0008 upgrade note and the known limitations; STATUS 8.3 | `9aa818ed` |
|
||||
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and four fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 20 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; writers under the lease and render filing's 503; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and five fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 23 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 4b | R7 mass conversion | todo | |
|
||||
| 5a | R8 workspace and projects with a local home (migration 0009) | todo | |
|
||||
| 5b | R8 server home | todo | |
|
||||
|
||||
Reference in new issue
Block a user