docs: phase 5a in BRIEF, DECISIONS, CHANGELOG, STATUS and ARCHITECTURE
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
6e00c3c996
commit
86185c422a
6 files changed
+359
-30
No files matched your search
+11
-8
@@ -55,14 +55,14 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
|---|---|
|
||||
| `Sqlite`, `Postgres` | SQLite P/Invoke binding (winsqlite3 / libsqlite3), in-house PostgreSQL wire protocol v3 client with pool and LISTEN |
|
||||
| `Migrations/{sqlite,postgres}/NNNN_name.sql` | Embedded, applied in one transaction at open (`MigrationRunner`) |
|
||||
| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list), `SequenceRepository.GetStampAsync` (a digest of what a Reorganize plans from in the index) and `GetConvertStampAsync` (with what a conversion plans from: its photos' count, sizes, formats, pixel sizes and the flags that decide), `JobRepository.ListPendingTargetsAsync` (the targets of pending jobs of a kind, also of those created before a time), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder); projects and their versions (`ProjectRepository`, `projects`, `project_versions`: rows derived from the projects' sidecars, a head advanced by compare-and-set, Main's last mirror); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) |
|
||||
| `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) |
|
||||
| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list), `SequenceRepository.GetStampAsync` (a digest of what a Reorganize plans from in the index) and `GetConvertStampAsync` (with what a conversion plans from: its photos' count, sizes, formats, pixel sizes and the flags that decide), `JobRepository.ListPendingTargetsAsync` (the targets of pending jobs of a kind, also of those created before a time), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder); projects and their versions (`ProjectRepository`, `projects`, `project_versions`: rows derived from the projects' sidecars, a head advanced by compare-and-set, Main's last mirror); `JobRepository.ListPendingAsync` (the queued, running and paused jobs of a kind and target, full rows); `FrameRepository.CountNamedAsync` (hashed frames and a checksum of their hashes, for a home's frames stamp); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) |
|
||||
| `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), `ICancelledJobHandler` (a handler's clean-up after a cancel: `JobEngine.CancelAsync` calls it for a paused or failed job no handler runs, and waits first for a paused job's run that has not ended) |
|
||||
| `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; a full scan or a rebuild takes the projects' sidecars back too), `ArchiveIngest` (uploads and imports, named through `FrameNaming`; content a conversion replaced is a duplicate of the frame holding its conversion; a restore or a replacement not settled yet refuses the batch), `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` (also a conversion job's staging and journals, by the job's state; those of a job this index does not know go together, by age), `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, `TrashKept` with its `TrashKeptReason` for each entry kept; `SequenceTrash.Replaced`: where a replaced entry's conversions are, read from the archive's sidecars (in the index's or the entry's folder, in the trash, else by one `SidecarWalk` of the archive per dry run or emptying) through their replaced tombstones, a conversion deleted only on the archive's word (a tombstone, the trash, or an `ErasureRecord` in `trash/.erased/`, written when an emptying erases a deleted sequence a replaced entry still needs), `TrashEntry.ConversionDeleted` in the dry run and its fingerprint, the erase weighed under the entry's and the sequence's leases once the sequence is settled; `BusyAsync`: what running and paused jobs hold, but the job asking, from `JobRepository.ListHoldsAsync`), `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; a replaced entry swaps back while its converted frames are unchanged (`SwapBackAsync`); `FLine truncated
|
||||
| `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 |
|
||||
| `Projects` | `ProjectService` (`ArchiveService.Projects`: the projects of this PC's sequences as a home, under the sequence's lease and only in a folder that holds the sequence (`SequenceFolders.Holds`; otherwise `SequenceFolderMovedException`: reads answer from the index, writes are refused): list, create, rename, delete into `projects/.trash`, history, push with fast-forward / idempotent repeat / divergence / hash and portability checks; each call first catches up: the sidecars into the index (`ProjectIndexer`, also run by full scans and rebuilds; a version file a push left past its record adopted, a stray one moved to `versions/.stray`), Main made from the sequence's settings, settings another path wrote appended to Main as an `external` version, a mirror a crash cut short completed or merged; a push to Main mirrored into `project.json` and the settings with the settings version check), `ProjectSidecars` (record and immutable version files, the settings as a JSON string checked against their hash), `ProjectMerge` (three-way merge member by member, pending frames merged photo by photo, conflicts, `Replay` of local commits on a moved head), `IProjectHome` and `ArchiveProjectHome` (the home a workspace pushes to and pulls from, a project or version the index lacks looked for in the sidecars first; the server's comes in phase 5b), `HomePhotos` (a sequence's photos as positions name them, with the encodings its Replaced tombstones join) |
|
||||
| `Workspaces` | `WorkspaceStore` (a folder outside the library: `workspace.json`, one folder per project, no index), `WorkspaceProject` (`project.chronos` working state, `media/` with `media.json`, `proxies/<frame id>.jpg` and `analysis.json`, `versions/`, `sync.json` for a restore or a conflict, `exports/`, the lease `.lock.lease`), `WorkspaceSync` (checkout, open, save, commit, push, pull with replay and merge, conflicts settled by keep mine, take server or save both, restore, status), `WorkspaceCopyJobHandler` (`WorkspaceJobs.Copy`, registered by the desktop only: the archive only read, from a folder that holds the sequence; a workspace inside a library refused; the archive's current proxies copied, the others made in the workspace, each hash-verified, resumable from a checkpoint of its frames version; the encodings conversions joined kept in `media.json`; the working state's positions moved by frame where frames stay, by photo where they came or went) |
|
||||
| `Projects` | `ProjectService` (`ArchiveService.Projects`: the projects of this PC's sequences as a home, under the sequence's lease and only in a folder that holds the sequence (`SequenceFolders.Holds`; otherwise `SequenceFolderMovedException`: reads answer from the index, writes are refused); reads wait 3 s for the lease, then answer from the index; a read-only archive is read without writing (an index-only Main written back once it takes writes): list, create, rename, delete (the folder into `projects/.trash` first, then the deleted record; never Main), history, head (NotFound once deleted), `StoredAsync` (a version file read back and checked), push with fast-forward / idempotent repeat / divergence / hash, portability, strict format and 64 MiB checks; each call first catches up: the sidecars into the index, Main made from the sequence's settings, settings another path wrote appended to Main as an `external` version or, with a push whose mirror was cut short, merged into one `merge` version where they win, a mirror never written over `project.json` settings it has not taken in (`MovedSharedAsync`), records behind the index healed (`HealAsync`, `UpdatedAfter`), projects the archive lost written back (`WriteBackAsync`); a push to Main mirrored into `project.json` and the settings with the settings version check), `ProjectIndexer` (the reconcile, also run by full scans and rebuilds: the projects' trash read before the live folders, so a deletion wins and the live folder's late version files move beside it; a record that cannot be read held back, never taken for a deletion; a lost record written again from the index only once its folder settled (`RecordSettle`, 2 minutes) and no trash folder holds it back (`TrashRecordGrace`, 1 day); a creation cut before its record left as it is; a version file a push left past its record adopted, a stray one moved to `versions/.stray`; `BehindAsync`, one rule for a record behind the index; `SettleMainAsync` and `SwapMainAsync`, one Main from the records, passed in one transaction), `ProjectSidecars` (record and immutable version files, the settings as a JSON string checked against their hash, `MaxVersionBytes` 64 MiB refused before writing), `ProjectMerge` (three-way merge member by member, pending frames merged photo by photo, conflicts, `Replay` of local commits on a moved head; `NewerSettingsException` rather than merge a newer format), `IProjectHome` and `ArchiveProjectHome` (the home a workspace pushes to and pulls from: `HoldsAsync` reads a version back, `FramesStampAsync` says when the frames changed, an offline archive or busy lease is `HomeUnavailableException`; the server's comes in phase 5b), `HomePhotos` (a sequence's photos as positions name them, with the encodings its Replaced tombstones join) |
|
||||
| `Workspaces` | `WorkspaceStore` (a folder outside the library: `workspace.json` written atomically, one folder per project, no index; a leftover folder holding only stale lease files removed on listing), `WorkspaceProject` (`project.chronos` working state, `media/` with `media.json`, `proxies/<frame id>.jpg` (and `<frame id>-<sha16>.jpg` while a copy replaces one) and `analysis.json`, `versions/` with `.replaced` (versions set aside, pruned by age and count) and `.replaced.since`, `sync.json` for a conflict, a restore or the journal of a replay or a Save both, `exports/`, the lease `.lock.lease`; `UnreadableVersions`), `WorkspaceMedia` (`NamedAsAt`: the media learn the home's hashes and aliases), `WorkspaceSync` (checkout, open under the lease, save, commit, push, pull with replay and merge, the base in `project.chronos` as every write's commit point, `SettleAsync` finishing or undoing a cut push, replay or Save both, conflicts settled by keep mine, take server or save both only as shown, restore, status with Gone, Damaged and `MediaOutdated`, the home's frames read again only when their stamp moved), `WorkspaceCopyJobHandler` (`WorkspaceJobs.Copy` and `CopyFactsAsync`, registered by the desktop only: the archive only read, from a folder that holds the sequence; a workspace inside a library refused; the archive's current proxies copied, the others made in the workspace, each hash-verified, resumable from a checkpoint of its frames version and folder, free space checked against its estimate plus 512 MiB; the encodings conversions joined kept in `media.json`; the working state's positions moved by frame where frames stay, by photo where they came or went; a cancelled first copy's media cleared under the project's lease only when no other copy of the project waits or runs, through `ICancelledJobHandler` too) |
|
||||
| `Sync` | `SyncService` (sync table of one server: compare, link by content through the aliases, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, the proxies this PC can send, aliases followed; no I/O), `SyncTombstones` (photos either side removed are not offered back; the replaced tombstones of both sides join the encodings of one photo, union-find, each compared as the smallest SHA-256 among them, a deletion covering them all; immutable once made), `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, and a frame missing here whose photo the server holds in another encoding takes that file through `FrameTrash.ReplaceMissingAsync`; job log lines from the catalog), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) |
|
||||
|
||||
### 2.3 Chronos.App areas
|
||||
@@ -72,8 +72,8 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `Shell` | `MainWindow` (rail and its shortcuts, taskbar progress), `ShellViewModel` (rail, sections, first run), `OsNotifications` (toasts as Windows notifications while the window is minimised or in the background), dialogs, `ErrorText` (the sentence of an error toast), `ScreenCapture` (`--capture` scenes), `SectionTemplates.xaml` (view model → view) |
|
||||
| `Sections` | One `XxxView.xaml` + `XxxViewModel` per screen: Welcome, Library, Sequence (the Edit section: the editor, `SequencePickerView` choosing in place a project of the workspace or a sequence of the library, the in-window dialogs of the workspace, and the opening of this PC's sequences as workspace projects: the project opened last, else "Open in workspace", the checkout and the copy job followed until it opens), Import, Archive, Jobs (two tabs, Queue and Scheduled: `SchedulesView` shows `Jobs/SchedulesViewModel`), Server, Settings (its last page is About) |
|
||||
| `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions (`MassActions`: Reorganize and Convert for the sequences of one archive), remote cards and thumbnails, thumbnail cache, list export |
|
||||
| `Editor` | `EditorSession` (project, undo/redo, saving, merges through `Data/Projects/ProjectMerge`), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`, `WorkspaceSequenceSource`: a workspace project over its media, the working state saved in `project.chronos` under the project's lease and merged, renders at the home with the portable settings through `IProjectRenders`), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files: format 2 opens its workspace project, format 1 gives its settings to Main) |
|
||||
| `Workspace` | Owner review 2, R8: `WorkspaceHost` (the desktop's `WorkspaceStore` and `WorkspaceSync` over Settings › Workspace's folder, this PC's archive as the home; checkout and copy, status, Save version with the sync after it, sync, resolve, restore, history, new, rename, delete, the plan and removal of a local copy whose unsent work goes to `<workspace>/.trash`, pruning past Kept versions), `ProjectMenuViewModel` (the title's ▾: state chip, the menu, Update media; `IWorkspaceUi` is what it asks of the section), `WorkspaceDialogs` (Open in workspace, project name, Save version, History, conflict, Remove local copy; `WorkspaceDialogs.xaml`), `WorkspaceProjectItem` (a picker row), `WorkspaceText` (states, versions, failures) |
|
||||
| `Editor` | `EditorSession` (project, undo/redo, saving, merges through `Data/Projects/ProjectMerge`), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`, `WorkspaceSequenceSource`: a workspace project over its media, the working state saved in `project.chronos` under the project's lease and merged photo by photo in the portable form (`Merge`, a setting both sides changed asked through `ProjectConflictException`), `ReadOnlyChanged` for a project of a newer Chronos, an unstored edit kept aside in `versions/.replaced` (`SetAsideAsync`), renders at the home with the portable settings through `IProjectRenders`, naming a version only while none waits to be sent), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files: format 2 opens its workspace project, format 1 gives its settings to Main) |
|
||||
| `Workspace` | Owner review 2, R8: `WorkspaceHost` (the desktop's `WorkspaceStore` and `WorkspaceSync` over Settings › Workspace's folder, this PC's archive as the home; checkout and copy with its size and free space, status, Save version with the sync after it, sync, resolve, restore, history, open, new, rename, delete, the plan and removal of a local copy whose files but the media go to `<workspace>/.trash` (put back whole when a move fails), pruning past Kept versions after `HoldsAsync`, copies a newer Chronos wrote or that cannot be read listed as such and never changed, a folder inside a library refused, `PlanFolderAsync` and `UseFolderAsync`), `WorkspaceFolderChange` (Settings › Workspace › Change… and the refused folder's Choose folder), `ProjectMenuViewModel` (the title's ▾: state chip read again after edits, the menu, Update media; `IWorkspaceUi` is what it asks of the section, `ShowDialogWhenFree` holding a background conflict until the open dialog closes), `WorkspaceDialogs` (Open in workspace with unreadable projects listed disabled, project name, Save version, History, conflict, a format conflict offering only Save both, Remove local copy with its typed confirmations; `WorkspaceDialogs.xaml`), `WorkspaceProjectItem` (a picker row), `WorkspaceText` (states, versions, authors, failures) |
|
||||
| `Import` | `CardPool` (inserted cards, remembered cards, folders), camera profiles, plans and choices, destinations (archive, folder, server through `ServerImportSink`), card actions (verified delete, format, eject) |
|
||||
| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, Reorganize (`ReorganizeDialogViewModel`: folder, file and title templates each with its switch, the dry run, Apply queues the `move` job of that plan; `ReorganizePlans`: each template's check, the plan as rows and a summary; `ReorganizeOffer`: per archive, the templates Settings › Archive's toast offers, joined while that archive's toast is up), Convert (`ConvertDialogViewModel`: format, JPEG quality and a mode chosen at every run, the dry run made once per format and quality, Apply behind the mode's confirmation queues the `convert` job of that plan through `MassConverter.QueueAsync`; `ConvertPlans`: the plan as rows in the mode's words, a summary, the space line, the Replace confirmation that types the number of photos and the New sequence one that counts the photos not copied; `ConvertUndo`: the Undo the Jobs screen's toast offers when Replace conversions end, which restores the `Replaced` trash entries their jobs made, by the job's id), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation, every entry whose conversion was deleted named first), `ArchiveFailures` |
|
||||
| `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync), sync table, `RemoteSequenceApi` |
|
||||
@@ -121,7 +121,7 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S
|
||||
| `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, keeps it while the archive is offline, tells each sequence changed as its step completes) | yes | yes |
|
||||
| `Convert` | `Archiving/Jobs/ConvertJobHandler` (mass conversion through `MassConverter`, `ConvertJobParameters`: the target, quality and mode, the sequences with their frames version and the digest of the photos confirmed, whose ids wait in `journal/convert-<job>.photos`, and the fingerprint; targets are the sequences; settles what a crash left, refuses short space, converts each sequence all or nothing, the confirmed photos alone, resumes from its journal, tells each sequence `converted` or `created` and queues the passes it needs as it completes) | yes | yes (formats and files the server cannot decode natively are skipped: convert on a PC) |
|
||||
| `WorkspaceCopy` | `Workspaces/WorkspaceCopyJobHandler` (via `WorkspaceJobs.CreateHandlers`: a sequence's proxies and deep report into a workspace project's media; originals refused until phase 5c) | yes | no: it writes into the folder its parameters name |
|
||||
| `WorkspaceCopy` | `Workspaces/WorkspaceCopyJobHandler` (via `WorkspaceJobs.CreateHandlers`: a sequence's proxies and deep report into a workspace project's media, high in the priority queue by default; its cancel clean-up as an `ICancelledJobHandler`; originals refused until phase 5c) | yes | no: it writes into the folder its parameters name |
|
||||
| `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)
|
||||
@@ -182,7 +182,10 @@ replayed on them (`ProjectMerge.Replay`) and the working state merged, and setti
|
||||
conflict for the user. Main's head is the sequence's own settings (mirrored both ways), so analyses, the Library's quick
|
||||
renders and server sync keep reading `project.json` and the index's settings; other projects never leave their home. The
|
||||
desktop's Edit opens only workspace projects (`App/Workspace`): it edits their working state, and a render of one runs
|
||||
at the home with its portable settings, recording the project and the version.
|
||||
at the home with its portable settings, recording the project and the version. The archive's sidecars stay the truth: a
|
||||
deletion is taken only from the projects' trash, read first, a record that cannot be read holds its project back, and the
|
||||
index heals the records it is ahead of. In a workspace the base in `project.chronos` is the commit point of every
|
||||
write, so a cut push, replay or Save both is finished or undone by the next sync (`SettleAsync`).
|
||||
|
||||
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
|
||||
|
||||
+209
-10
@@ -283,6 +283,17 @@ sequence manifest atomically (write temp → fsync → rename).
|
||||
| Server-connected | server archive; local proxies/thumbs cache | server DB via API; local SQLite caches only | server (managed formats), render nodes (MP4), or this PC after downloading originals |
|
||||
| Mixed | both; each sequence has an `origin` and a `sync state` | both | as above |
|
||||
|
||||
Workspace and projects (amended 2026-10-26, R8). The desktop edits in a **workspace**, a folder
|
||||
on a fast disk outside every library (default `%LOCALAPPDATA%\Chronos\workspace`, or
|
||||
`.\data\workspace` for a portable copy), never inside the library. A sequence's **home** is
|
||||
where it lives: this PC's archive (phase 5a) or a server (phase 5b). The home keeps the
|
||||
sequence's **projects**: Main, which is the sequence's own settings, and other named sets of
|
||||
edits ("4K landscape", "Vertical social"), each with a linear history of versions pushed and
|
||||
pulled like git, with no branches. The workspace holds a working copy of a project: its
|
||||
working state, its versions and the sequence's proxies (originals from phase 5c). Final
|
||||
renders run where the originals are. A local-only library works the same way, its archive
|
||||
being the home.
|
||||
|
||||
---
|
||||
|
||||
## 5. Domain model
|
||||
@@ -303,7 +314,23 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st
|
||||
preview info (offset/length), light stats (mean log-luminance, clip fractions) once
|
||||
analysed, flags (missing, corrupt, duplicate, excluded).
|
||||
- **Render** — id, sequence id, preset name, settings JSON, output relative path, codec,
|
||||
width, height, fps, duration, bytes, created, produced by (client id / server / node).
|
||||
width, height, fps, duration, bytes, created, produced by (client id / server / node),
|
||||
project id and project version id (the project and version rendered, the version only
|
||||
when the home holds it with the settings rendered; amended 2026-10-26, R8).
|
||||
- **Project** (amended 2026-10-26, R8) — id, sequence id, name (1–60 characters, unique
|
||||
among the sequence's live projects), is main (one live Main per sequence), head version
|
||||
id and number, mirrored version id and mirrored settings version (Main: the version and
|
||||
the settings version of its last mirror into the sequence's settings), created by,
|
||||
created, updated, deleted. Derived from the project's sidecars (§7) and rebuilt from them.
|
||||
- **ProjectVersion** (amended 2026-10-26, R8) — id (UUIDv7 made by the client), project
|
||||
id, parent id, number (1…, unique per project), kind (commit, merge, restore, imported,
|
||||
external), author, client name, note, settings JSON in the portable form (every frame
|
||||
position parked by photo, canonical text, stored as text and never re-encoded), content
|
||||
hash (SHA-256 of that text's UTF-8 bytes), settings format, frames version, restored
|
||||
from, created, stored (when the home took it; none while only a workspace has it).
|
||||
Immutable once stored.
|
||||
- **Workspace** (amended 2026-10-26, R8) — no table: a folder that describes itself
|
||||
(`workspace.json` and one folder per project, §12.3).
|
||||
- **Job** — id, kind (scan, rebuild, verify, light-analyse, deep-analyse, proxies,
|
||||
thumbs, render, import, upload-commit, maintenance; backup, cleanup, and the read-only
|
||||
duplicates and orphans reports; empty-trash, stored as 18, which erases exactly the trash
|
||||
@@ -313,7 +340,9 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st
|
||||
and holds the rest of it when paused, cancelled or failed: amended 2026-10-26, R7; convert,
|
||||
stored as 19, a conversion of exactly the photos a confirmed plan lists, its targets the
|
||||
sequences, each converted all or nothing into its own frames or a new sequence: amended
|
||||
2026-10-26, R7), target ids, state (queued, running, paused, done, failed, cancelled),
|
||||
2026-10-26, R7; workspace-copy, stored as 20, the copy of a sequence's proxies and deep
|
||||
report into a workspace project's media, run by the desktop only: amended 2026-10-26, R8),
|
||||
target ids, state (queued, running, paused, done, failed, cancelled),
|
||||
progress (done/total, fps, eta), log tail, created by, node id, attempts, error, schedule id
|
||||
(the schedule that queued it; amended 2026-10-26, R10).
|
||||
- **Schedule** (amended 2026-10-26, R10) — id, system key (set, and unique, on a host's
|
||||
@@ -348,7 +377,9 @@ Indexes: `frame(sequence_id, index)`, `frame(sha256)`, `frame(captured_at)`,
|
||||
`sequence(archive_id, first_capture)`, `sequence(camera_model)`, tags, jobs by state and by
|
||||
schedule, `schedules(enabled, next_run)` (amended 2026-10-26, R10),
|
||||
`frame_removals(sequence_id, sha256)` (the key) and `frame_removals(sha256)` (migration 0008;
|
||||
amended 2026-10-26, R6).
|
||||
amended 2026-10-26, R6), `projects(sequence_id, name)` and `projects(sequence_id)` where
|
||||
Main, both on live rows only, `project_versions(project_id, number)` (migration 0009, with
|
||||
`renders.project_id` and `renders.project_version_id`; amended 2026-10-26, R8).
|
||||
Paging everywhere (keyset pagination on `(first_capture, id)`).
|
||||
|
||||
---
|
||||
@@ -437,7 +468,8 @@ The archive is the source of truth; the database is an index that can be rebuilt
|
||||
│ └── .chronos/
|
||||
│ ├── sequence.json sidecar manifest (below)
|
||||
│ ├── analysis.json full deep-analysis report
|
||||
│ ├── project.json render settings (the "project")
|
||||
│ ├── project.json render settings (the "project"; Main's head, below)
|
||||
│ ├── projects/ <project id>/project.json + versions/000001-<version id>.json …; .trash/: deleted projects (below; amended 2026-10-26, R8)
|
||||
│ ├── thumbs.pack packed thumbnails (one file per sequence, indexed; avoids 100k tiny files on SMB)
|
||||
│ ├── rename-files.json the file renames of a Reorganize a crash interrupted (below; amended 2026-10-26, R7)
|
||||
│ └── *.pending.json journals of an ingest, a photo deletion, a frame replacement (replace.pending.json, a conversion or its undo; amended 2026-10-26, R7) or a restore a crash interrupted (below)
|
||||
@@ -595,6 +627,49 @@ moves each original into the trash, New sequence leaves it where it is.
|
||||
job this index does not know (another host's on a shared archive) keeps both while any of
|
||||
their files was written within 90 days, then both go.
|
||||
|
||||
Projects (amended 2026-10-26, R8; §5, §12.3, §14.5). A sequence's projects live in its
|
||||
`.chronos/projects/`, and the sidecars are the truth: a full scan or a rebuild takes them
|
||||
back into the index, and every project operation first brings the index in line with them,
|
||||
under the sequence's lease (a read waits at most 3 s for it, then answers from the index).
|
||||
- `<project id>/project.json` is the record (`chronos-project-record` v1: id, sequence id,
|
||||
name, is Main, head `{id, number}`, `mirrored` `{id, number}` for Main, created, created
|
||||
by, updated, deleted). Its `updated` time never goes back: each write stamps now or 1 ms
|
||||
past the record it replaces. Older builds ignore `mirrored`.
|
||||
- `<project id>/versions/000001-<version id>.json` holds one immutable version
|
||||
(`chronos-project-version` v1), its settings as a JSON string checked against its content
|
||||
hash. A version file is at most 64 MiB, refused before it is written. A version is
|
||||
written first, then the record, then the index in one transaction; a version file past
|
||||
its record that follows the head is adopted, any other moved to `versions/.stray`.
|
||||
Nothing is ever deleted.
|
||||
- A deletion moves the project's folder into `projects/.trash/<id>-<ticks>`, then writes
|
||||
the deleted record there. Main cannot be deleted. The projects' trash is never emptied
|
||||
by Chronos (Empty trash does not see it); it leaves with its sequence's folder.
|
||||
- A deletion is never inferred from a missing folder or a record that cannot be read: only
|
||||
a record that says deleted, or a folder in the projects' trash, deletes. The trash is read
|
||||
before the live folders, so a deletion is never undone; a version another PC pushed into
|
||||
the live folder before the deletion reached it is moved beside the deleted record, into
|
||||
the trash folder's `versions/`, never deleted. A record that cannot be read holds
|
||||
its project back: listed as the index has it, nothing written for it, writes refused
|
||||
until it reads again.
|
||||
- Main mirrors the sequence's settings: its head is written to `project.json` and to the
|
||||
index's settings, so analyses, the Library, renders and server sync keep reading them.
|
||||
Main is made lazily, from the settings as they are, the first time a project of the
|
||||
sequence is asked for. Settings another path writes (an older Chronos, the API, an
|
||||
analysis, sync) become an *external* version of Main at the next project operation; a
|
||||
mirror a crash cut short is completed, and if the settings also moved meanwhile, one
|
||||
*merge* version is made in which the settings written meanwhile win where both changed.
|
||||
A mirror never writes over settings written in `project.json` since this index last knew
|
||||
what it held: it takes them in first.
|
||||
- The index heals the sidecars from what it knows: a project whose folder is gone is
|
||||
written back from the index; a record behind the index (a projects folder put back from
|
||||
a backup) gets the missing version files, then the index's head and, when it is older,
|
||||
the index's name; a record that is lost is written again from the index only once the
|
||||
folder has looked the same for 2 minutes and no trash folder holds the project, so a
|
||||
record a sync tool is still bringing wins. A folder with versions and no record, of a
|
||||
project no index knows, is a creation cut short: it holds nothing back and is left as it
|
||||
is. One Main per sequence is decided from the records (the oldest that says Main); any
|
||||
other becomes an ordinary project with every version kept.
|
||||
|
||||
Rules: originals are immutable (never rewritten; edits are settings; a conversion takes an
|
||||
original out of its sequence only into the trash, amended 2026-10-26, R7); every write of a
|
||||
sidecar goes to a temp file, `fsync`, rename; the folder name is derived from templates at
|
||||
@@ -1030,11 +1105,15 @@ player smoke test on Windows CI.
|
||||
hero, keyframes) wait as pending frames until a restore brings the photos back, and the
|
||||
others follow their photos without a settings edit. *Delete…* still moves whole sequences
|
||||
into the archive's trash, which lists photo entries too (§12.5).
|
||||
- Open (a card, the Archive manager's Open, Jobs' Open; amended 2026-10-26, R8) opens a
|
||||
sequence of this PC in Edit as a project of the workspace (§12.3): the project of that
|
||||
sequence opened last on this PC, else *Open in workspace* asks which. A server-only
|
||||
sequence still opens with proxies (§14.5) until the server home (phase 5b).
|
||||
|
||||
### 12.3 Edit (amended 2026-10-16, R7; formerly "Sequence editor")
|
||||
### 12.3 Edit (amended 2026-10-16, R7; formerly "Sequence editor"; amended 2026-10-26, R8)
|
||||
|
||||
```
|
||||
│ ← Harbour sunset ▾ · 3,600 frames · Canon EOS R5 · 2 s interval · 2 h 00 m [Analyse] [Optimise all] [Render ▾] │
|
||||
│ ← Harbour sunset ▾ · [Main ● In sync ▾] · 3,600 frames · Canon EOS R5 · 2 s · 2 h 00 m [Analyse] [Optimise all] [Render ▾] │
|
||||
│ ✓ Analysis ── ▲ Frames ── ✓ Exposure ── ✓ Motion ── ✓ Camera ── ✓ Time ── ⑦ Stack ── ⑧ Export │ ← the path
|
||||
├──────────────────────────────────────────────────────────────────┬──────────────────────────────────┤
|
||||
│ ┌──────────────────────────────────────────────────────────────┐ │ Exposure │
|
||||
@@ -1056,7 +1135,12 @@ player smoke test on Windows CI.
|
||||
sequence whose proxies are still coming, or one that cannot open, leaves it open), its
|
||||
last edit saved first, or discarded on the user's word and then never written. The
|
||||
Library, Jobs, the Server screen, project files and the command line still open
|
||||
sequences in Edit; ← goes back to the Library.
|
||||
sequences in Edit; ← goes back to the Library. Amended 2026-10-26, R8: the picker has two
|
||||
groups, *Workspace* (the workspace's projects, the one saved last first, each with its
|
||||
state chip read from its home after the list shows) above *Library*; the search filters
|
||||
both, and Enter opens a library match, a project only when no sequence matches. A
|
||||
Workspace row's context menu and the Delete key offer *Remove local copy*, also for a copy
|
||||
that cannot open.
|
||||
- The steps form a guided path, freely navigable: **Analysis** (every finding of the
|
||||
analyses with the step that deals with it; light, flicker, exposure steps received,
|
||||
shake and flagged frames; Analyse), **Frames** (virtualized table: index, time,
|
||||
@@ -1086,6 +1170,85 @@ player smoke test on Windows CI.
|
||||
- While a job runs on this sequence, settings that would change the rules mid-render are
|
||||
disabled; viewing tools stay live.
|
||||
|
||||
Workspace (amended 2026-10-26, R8; §4.4, §7). Edit opens a sequence of this PC's archive only
|
||||
as a project of the workspace, and never writes into the library; a capture (sample data)
|
||||
keeps editing the library, and a server sequence keeps opening with proxies until phase 5b.
|
||||
- Which project: the one of that sequence opened last on this PC. Otherwise *Open in
|
||||
workspace* asks: **Project** (an existing one, Main first, made from the sequence's
|
||||
settings as they are; or New, with a name of 1–60 characters unique in the sequence) and
|
||||
**Media** (*Proxies*; *Originals* is disabled until phase 5c and its tooltip says why),
|
||||
with the copy's size and the drive's free space (*Not enough space* below the size plus
|
||||
0.5 GB). A Main this Chronos cannot read (saved by a newer Chronos, or damaged) is listed
|
||||
disabled with the reason; asked for alone, or with nothing else to offer, it is refused at
|
||||
once, a damaged one offering *Remove local copy*. The project is then checked out and its
|
||||
proxies copied by a *Workspace copy* job, followed like a server sequence's proxies (the
|
||||
picker line, a toast with a Jobs link); it opens when the copy is done, and the open
|
||||
sequence stays open meanwhile.
|
||||
- The workspace folder holds `workspace.json` and one folder per project:
|
||||
`project.chronos` (the working state, a project file of format 2 with a `workspace`
|
||||
section: project, name, Main, home, base version, media; at most 64 MiB), `media/`
|
||||
(`media.json`, `proxies/`, `analysis.json`), `versions/` (the versions taken from the
|
||||
home and those not sent yet; `versions/.replaced` keeps every version a sync replaced),
|
||||
`sync.json` (a conflict, a restore, or the journal of a sync under way), `exports/`, and
|
||||
the lease `.lock.lease`. A workspace folder inside a library is refused before anything
|
||||
is written, with *Choose folder*.
|
||||
- The editor writes only the working state, atomically under the project's lease a moment
|
||||
after each edit, merged photo by photo with what a sync or a copy wrote. Where a sync and
|
||||
the editor changed the same setting, it asks (keep mine, take the library's).
|
||||
- Beside the title, the project button (its name; Main in the UI language) with a state
|
||||
chip: In sync, Changed, Not sent, Library newer, Conflict, Offline, No media, Syncing,
|
||||
Not in library (the home deleted it: its copy can only be discarded), Damaged (a version
|
||||
saved here cannot be read: nothing is saved, sent or taken until it is repaired from the
|
||||
home's copy). The chip is read again a moment after each edit. Its ▾ menu:
|
||||
- *Save version…* (Ctrl+S): a note, Enter saves. With Sync automatically on, the version
|
||||
is sent at once.
|
||||
- *Sync*: take the library's new versions, then send yours. A push whose parent is the
|
||||
library's head goes straight in; otherwise the library's versions are taken, yours are
|
||||
replayed on them (a version that changes nothing once replayed is not sent) and the
|
||||
working state is merged setting by setting, pending frames photo by photo.
|
||||
- *History…*: the versions, newest first: number, kind (Saved, Merged, Restored,
|
||||
Imported, Outside change), the PC, time, note, Not sent or Current. *Compare* lists the
|
||||
settings that differ from now (heroes, exclusions and keyframes by name, several photos
|
||||
counted); *Restore* makes a version the project as one undo step, unsaved changes saved
|
||||
as a version first, and a toast offers Undo.
|
||||
- *Open project…* (another project of the home), *New project…* (from this project's
|
||||
last version in the library), *Rename…*, *Delete project…* (never Main; confirmed; it
|
||||
sends everything first, then the project goes to the library's project trash with all
|
||||
its versions).
|
||||
- *Remove local copy…*: a plan (files, size, versions not sent, unsaved changes,
|
||||
conflict). *Remove* only when everything is in the library, whose head and the base are
|
||||
read back and checked against their hashes first; *Send first* sends what is missing,
|
||||
then removes; *Discard changes* asks for the project's name to be typed. The copy's
|
||||
files, every one but the media, go to `<workspace>/.trash/<id>-<time>`; the media are
|
||||
deleted. A removal that cannot move a file puts everything back and says so.
|
||||
- Conflicts are asked only when a merge finds settings both sides changed, and list this
|
||||
side's value as the working state holds it: *Keep mine*, *Take library's* (one undo step;
|
||||
the toast's Undo brings back only those settings), *Save both* (your versions go to a
|
||||
sibling project "<name> (<PC>)" and this one takes the library's) or *Later* (the chip
|
||||
says Conflict, Save version is disabled and the next Sync asks again). A choice settles
|
||||
only the conflict shown: if the library moved again, the dialog asks again. A conflict
|
||||
met by an automatic sync waits for the open dialog to close. A project the library holds
|
||||
in a newer Chronos's format is never merged: only *Save both* and *Later*; with nothing
|
||||
unsent, the project takes it read-only.
|
||||
- A project read-only (a newer Chronos's settings) says so with a toast and disabled
|
||||
controls; an edit not stored yet when such settings arrive is kept in
|
||||
`versions/.replaced` (*Edit kept aside*).
|
||||
- When the library's photos changed since the copy (added, removed, converted, verified),
|
||||
a banner offers *Update media*: the media are copied again and positions follow their
|
||||
photos.
|
||||
- Renders of a workspace project run on this PC's engine at the library, with the
|
||||
originals and the project's portable settings embedded, one job per preset; they record
|
||||
the project, and the version only while no version waits to be sent and the library
|
||||
holds that version with the settings rendered.
|
||||
Analyses run at the library; with Sync automatically on, Main takes an analysis' Auto
|
||||
values.
|
||||
- `.chronos` files: format 2 opens its workspace project (a copy of one gives it its
|
||||
settings as one undo step; a project the library lacks falls back to Main); format 1
|
||||
gives its settings to the sequence's Main. *Save project file* still writes format 1.
|
||||
- Not yet (phase 5c): originals in the workspace and renders from them, moving the
|
||||
workspace folder with its projects, emptying `<workspace>/.trash`, automatic clean-up and
|
||||
the size limit. The server home is phase 5b.
|
||||
|
||||
### 12.4 Import (cards)
|
||||
|
||||
```
|
||||
@@ -1313,6 +1476,10 @@ R10; a tab, not a rail entry, so a schedule and the jobs it queued are side by s
|
||||
schedule's background run raises a toast only when it fails, unless it is upkeep the next
|
||||
run repeats (scan, thumbnails, proxies, light analysis, clean-up); Run now raises one only
|
||||
when it queued nothing.
|
||||
- *Workspace copy* jobs (amended 2026-10-26, R8; §12.3) are listed like any job; Open opens
|
||||
their sequence in Edit. Cancelling a first copy removes the media it wrote, once it has
|
||||
stopped and only while no other copy of that project waits or runs; a paused copy keeps
|
||||
them and resumes.
|
||||
|
||||
Global job bar mirrors the active job.
|
||||
|
||||
@@ -1345,9 +1512,20 @@ toast is up joining it; on the Archive screen it never replaces an open dialog,
|
||||
that one closes: amended 2026-10-26, R7), Import (defaults, session rules, verify,
|
||||
post-actions), Analysis (widths, thresholds, deep analysis auto-run), Rendering (quality
|
||||
profile, memory budget, spill folder, parallelism = photos the running job processes at once, priority queue
|
||||
with a level per job kind, encoders detected, hardware preference; amended 2026-10-16, R2),
|
||||
with a level per job kind, encoders detected, hardware preference; amended 2026-10-16, R2;
|
||||
Workspace copy listed, high by default, as Download: amended 2026-10-26, R8),
|
||||
Formats (per
|
||||
format tier on this PC, codec install links), Server (last servers, trusted fingerprints,
|
||||
format tier on this PC, codec install links), Storage, Workspace (amended 2026-10-26, R8:
|
||||
*Folder*, the path read-only with *Open* and *Change…*, which shows a plan (projects left,
|
||||
projects found), closes an open workspace project and moves nothing, the old folder's
|
||||
projects coming back when it is chosen again; *Sync* *After each version*, on by default:
|
||||
each saved version is sent at once and the library's new ones taken; *Kept versions* 5, 10,
|
||||
20, 50, 100 or 200, default 20: how many of the library's versions each project keeps on
|
||||
this PC besides its base and those not sent, an older one dropped only once the library
|
||||
gives it back unchanged; Reset restores Sync and Kept versions; Reset all and Import keep
|
||||
the folder and the projects opened last, Export leaves them out. Moving the folder with its
|
||||
projects, the size limit, the default media, version on render, clean after and the
|
||||
project to open come in phase 5c), Server (last servers, trusted fingerprints,
|
||||
render node), Updates (check on start; latest version: check now, download, releases page),
|
||||
Advanced (portable mode, data folder; logs: the logs folder, *Log level* (Trace…Error,
|
||||
default Info), *Keep logs* (1–365 days, default 14), *File size* (MB, default 50, or No
|
||||
@@ -1782,6 +1960,21 @@ sequence saved into another sequence's folder (the Export folder picker), before
|
||||
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.
|
||||
|
||||
Projects (amended 2026-10-26, R8; §7, §12.3). A project's history is linear, with no
|
||||
branches, and its home numbers the versions. A workspace pushes its versions in order; a
|
||||
push is stored only when it names the head as its parent, is portable, of a settings format
|
||||
the home knows, matches its content hash and fits 64 MiB, and a repeat of a stored version
|
||||
is answered as stored. Otherwise the workspace pulls the home's new versions, replays its
|
||||
own on them and merges the working state field by field (pending frames photo by photo);
|
||||
only settings both sides changed are a conflict. Versions are compared and placed by photo
|
||||
(the portable form), so photos added, a copy's other frame order, a Verify that hashed a
|
||||
photo or a conversion that replaced one never move a position. Only Main's head is
|
||||
mirrored into the sequence's settings, so only Main crosses to a linked server copy,
|
||||
through the settings sync above; other projects never leave their home. A home that is
|
||||
read-only or out of reach leaves the versions waiting in the workspace. Phase 5a's home is
|
||||
this PC's archive; the server home (API under `/sequences/{id}/projects`, the
|
||||
`projectChanged` event) is phase 5b.
|
||||
|
||||
### 14.6 Job engine
|
||||
|
||||
Persistent queue in the DB; jobs run one at a time, and the parallelism (configurable,
|
||||
@@ -1795,7 +1988,12 @@ server) gives each job kind a level (high, normal, low):
|
||||
higher kinds are claimed first, and a queued job of a higher level makes the running job
|
||||
of a lower level yield without asking; that job returns to the queue with its checkpoint
|
||||
and resumes by itself afterwards. Jobs of the same level never interrupt each other, and a
|
||||
job's own follow-ups never interrupt it. (Amended 2026-10-16, R2.)
|
||||
job's own follow-ups never interrupt it. (Amended 2026-10-16, R2.) The desktop's *Workspace
|
||||
copy* (`workspace-copy`, stored as 20) is high by default, as Download is, since Edit waits
|
||||
for it; a server never runs it, because it writes into the folder its parameters name. A
|
||||
handler may clean up after a cancel: cancelling a paused or failed job no handler runs calls
|
||||
it, and cancelling a paused job whose run has not ended waits for that run to end first
|
||||
(amended 2026-10-26, R8).
|
||||
|
||||
Scheduled jobs (amended 2026-10-26, R10). Recurring work is queued only by schedules (§5),
|
||||
shown in Jobs › Scheduled on the desktop (§12.6) and the admin panel (§14.8): no job is
|
||||
@@ -2536,6 +2734,7 @@ questions asked and the answers; DECISIONS rows give the reasons.
|
||||
| 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. |
|
||||
| 2026-10-26 | Owner review 2, R7 (conversion) | §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9 | Convert after import on the desktop (the Archive manager's set, the Library's selection) and the admin panel (the Library's selection): JPEG with a quality, TIFF-16 or linear DNG (the archival choice, scene-referred so a RAW's highlights above white and colours outside sRGB survive), Replace or New sequence chosen at every run and never remembered, behind a dry run that lists each sequence's photos, sizes and the photos that stay as they are with why, and the free space where the conversion writes; Replace confirmed by typing; the `convert` job (stored as 19) converts exactly the photos confirmed, one sequence at a time and all or nothing, resumable through its journals and staging, never twice at once; full-resolution decodes only (the managed decoders first, never a 16-bit file from an 8-bit RAW development; the server leaves what it cannot read to a PC), what Chronos reads from a photo never changed (profiles carried, a linear DNG of sRGB values only), Exif carried, every file verified by the server's decoders; Replace swaps the files of the frames in place under a crash-safe journal, the originals going into a replaced trash entry that Undo or Restore swaps back and that Empty erases only while the archive on disk shows each conversion intact, or deleted on its own word (a tombstone, the trash, an erasure record); import still copies byte for byte and the card keeps a converted photo's copy; sync and the ingest count every encoding of a photo as one; `POST /api/v1/archive/convert` with the plan cache it shares with Reorganize, `sequenceChanged` `converted` and `created`, the audit `archive_converted`. |
|
||||
| 2026-10-26 | Owner review 2, R8 (phase 5a: workspace and projects, local home) | §4.4, §5, §7, §12.2, §12.3, §12.6, §12.8, §14.5, §14.6 | A sequence's home (this PC's archive) keeps its projects: Main, mirrored both ways with the sequence's settings so older clients and sync keep working, and other named projects, each a linear history of immutable versions in the portable form (positions parked by photo, SHA-256 of canonical text), stored as sidecars in `.chronos/projects/` and indexed by migration 0009 (`projects`, `project_versions`, `renders.project_id`/`project_version_id`); deletions only on the archive's word, the trash read first; Edit opens only workspace projects: *Open in workspace* (project, proxies), the `workspace-copy` job (stored as 20, desktop only, hash-verified, resumable, space checked), the working state in a folder outside the library, the project button with its state chip and menu (Save version, Sync, History with Compare and Restore, Open, New, Rename, Delete, Remove local copy), push and pull with replay and field-level merge, conflicts only when both sides changed a setting (Keep mine, Take library's, Save both, Later), renders at the home with the settings embedded; Settings › Workspace (folder, sync, kept versions). The server home is phase 5b; originals, local render, clean-up and the rest of Settings › Workspace are phase 5c. |
|
||||
|
||||
## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated)
|
||||
|
||||
|
||||
@@ -5,6 +5,77 @@ commits follow Conventional Commits (release notes are generated from them by `C
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
## [0.1.0-rc.8] — 2026-11-03
|
||||
|
||||
### Added
|
||||
- **Workspace and projects** on the desktop (owner review 2, R8, phase 5a): Edit no longer edits inside the library.
|
||||
A sequence of this PC's archive opens as a project of the workspace, a folder on a fast disk outside the library
|
||||
(`%LOCALAPPDATA%\Chronos\workspace`, or `.\data\workspace` for a portable copy). The first time, *Open in workspace*
|
||||
lets you choose the project (Main, another one, or a new one with a name) and the media (*Proxies*; *Originals*
|
||||
comes later), and shows the copy's size and the free space. A *Workspace copy* job then copies the sequence's
|
||||
proxies, hash-verified and resumable, checking the free space as it goes, and the project opens when it is done.
|
||||
After that the project you opened last opens directly.
|
||||
- Projects: a sequence can have several projects ("4K landscape", "Vertical social"), each with a linear history of
|
||||
versions kept next to the sequence in `.chronos/projects/` and taken back by a full scan or a rebuild. Main is the
|
||||
sequence's own settings, kept in step both ways, so analyses, the Library, renders, the server's sync and older
|
||||
Chronos versions keep working; settings changed elsewhere are recorded as *Outside change* versions.
|
||||
- A project button beside the editor's title, with a state chip (In sync, Changed, Not sent, Library newer,
|
||||
Conflict, Offline, No media, Not in library, Damaged) and a menu:
|
||||
- *Save version…* (Ctrl+S, with a note), sent to the library at once with *Sync automatically*;
|
||||
- *Sync*: take the library's new versions, then send yours;
|
||||
- *History…*: compare a version with now, restore it as one undo step;
|
||||
- *Open project…*, *New project…*, *Rename…*, *Delete project…* (never Main; its versions go to the library's
|
||||
project trash);
|
||||
- *Remove local copy…*, after a plan, which never discards work not sent without your word (typing the project's
|
||||
name) and keeps every file but the photos in the workspace's trash folder.
|
||||
- Changes made in the library and in the workspace merge setting by setting (excluded photos, the hero and camera
|
||||
keyframes photo by photo); only settings both sides changed ask: *Keep mine*, *Take library's* (undoable), *Save
|
||||
both* (your versions go to "<name> (<PC>)") or *Later*.
|
||||
- *Update media* when the library added, removed, converted or verified photos of the sequence after the copy.
|
||||
- Edit's picker lists the workspace's projects, with their state, above the library; right-click or Delete on one
|
||||
offers *Remove local copy*.
|
||||
- Settings › Workspace: *Folder* (with *Open* and *Change…*, which shows a plan and moves nothing), *Sync*
|
||||
(after each version, on) and *Kept versions* (default 20).
|
||||
- Renders from Edit run at the library with the project's settings, and record the project and the version.
|
||||
- Known limitations: the server home is phase 5b, so a server sequence still opens with proxies as before and its
|
||||
projects stay on this PC's archive only; originals in the workspace, renders from them, moving the workspace
|
||||
folder with its projects, emptying the workspace's trash folder, automatic clean-up, the size limit and the rest of
|
||||
Settings › Workspace are phase 5c; a capture (`--capture`) still edits the library, so its screenshots do not show
|
||||
the workspace; Main's merge after a crash lets the settings written meanwhile win where both changed, the push's
|
||||
values staying in its version; a version a deletion moves beside the deleted project is not indexed, and nothing
|
||||
restores from the projects' trash yet; a lost project record is written again only after its folder has looked
|
||||
the same for 2 minutes in one running Chronos; the picker reads each project's state from the library one after
|
||||
the other.
|
||||
|
||||
### Changed
|
||||
- `.chronos` files: one of format 2 opens its workspace project; one of format 1 gives its settings to the sequence's
|
||||
Main project. *Save project file* still writes format 1.
|
||||
- Project files keep settings a newer Chronos added, and a project saved by a newer Chronos opens read-only. Project
|
||||
files with a workspace section are format 2; others are still written as format 1. Project files and versions can
|
||||
be up to 64 MB.
|
||||
- Merging edits merges excluded photos, the hero and camera keyframes that wait for their photos photo by photo,
|
||||
instead of as one list; burst photos keep their positions once hashed.
|
||||
- Settings › Rendering's priority queue lists *Workspace copy*, high by default like *Download*.
|
||||
- Cancelling a job that is paused, or failed, lets its kind clean up after it: a cancelled first workspace copy
|
||||
removes the photos it wrote, unless another copy of that project waits or runs.
|
||||
- **Upgrade:** migration 0009 runs on start: the index (SQLite, or the server's PostgreSQL database) moves to schema 9
|
||||
(the `projects` and `project_versions` tables, two columns in `renders`), one way: an older build refuses the
|
||||
upgraded index, so going back means restoring a copy made before the upgrade. Each sequence's settings become its
|
||||
Main project the first time a project of it is asked for; nothing else is rewritten. The first open of a sequence in
|
||||
Edit asks *Open in workspace* and copies its proxies (about the size of the sequence's proxies). Older builds
|
||||
sharing the archive ignore `.chronos/projects/` and keep reading the sequence's settings, which follow Main.
|
||||
|
||||
### Fixed
|
||||
- Found by the phase's review before any release had them (one adversarial round, 55 findings, five fix rounds): one
|
||||
project record that could not be read once no longer deletes the sequence's projects or makes a second Main, and a
|
||||
deletion half-synced to another PC is never undone; an index meeting Main for the first time (a second PC, a rebuild,
|
||||
a backup put back) no longer takes its own stale settings for an outside change; a projects folder put back from a
|
||||
backup no longer blocks pushes nor reverts a rename; a pull no longer undoes a frame edit after the library hashed or
|
||||
converted photos; a sync cut at any step loses no version and makes no false conflict; a conflict choice settles only
|
||||
what the dialog showed; *Take library's* sends no empty version; *Restore* during a conflict saves your changes first;
|
||||
large projects (tens of thousands of excluded photos) are checked out, saved and sent; a Workspace copy no longer
|
||||
fills the system drive; a cancelled copy never removes photos another copy of the project wrote.
|
||||
|
||||
## [0.1.0-rc.7] — 2026-11-02
|
||||
|
||||
### Added
|
||||
|
||||
+51
-5
@@ -144,7 +144,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-03 | Perf gates (opt-in, weekly `perf.yml`): Library open through a new connection pool with warm OS cache; filters as the median of 5 runs; rebuild at one fifth of §1.1 (400 × 250 real photos, 120 s budget) on SQLite and PostgreSQL. No perf migration was needed. | Drop OS caches / full 500k files | Portable on CI runners while still catching plan and index regressions. |
|
||||
| 2026-10-03 | `fixtures --allow-missing` prints a warning annotation per missing sample and exits 0; without it, 1. `Chronos.Tools.Tests` covers tool behaviour CI relies on. | continue-on-error | CI shows the gap instead of a silent pass. |
|
||||
| 2026-10-03 | Editor: the corrected-frame preview is built in the App layer (RenderPreparation corrections, then geometry, exposure and the knee), measured at 128 px; the preparation is split into a measuring pass and re-solves so slider steps never re-decode; analysis decodes are kept as Half within 1/16 of available memory (64–512 MB). | A Core single-frame entry point | Preview speed without touching the render engine. |
|
||||
| 2026-10-03 | Editor autosave 400 ms after the last change with a three-way JSON merge (the editor wins on members both sides changed); a failed save stays pending and retries from 2 s doubling to 60 s; closing with an unsaved failure asks through a destructive modal. Undo takes adopted outside changes; a drag, click or key press is one step. | A Save button / dropping the change | Data safety; §12.1 allows modals for destructive actions. |
|
||||
| 2026-10-03 | (Partly superseded by the 2026-11-03 workspace editor saves row: a workspace project's save merges photo by photo, and a setting a sync and the editor both changed is asked, not won by the editor.) Editor autosave 400 ms after the last change with a three-way JSON merge (the editor wins on members both sides changed); a failed save stays pending and retries from 2 s doubling to 60 s; closing with an unsaved failure asks through a destructive modal. Undo takes adopted outside changes; a drag, click or key press is one step. | A Save button / dropping the change | Data safety; §12.1 allows modals for destructive actions. |
|
||||
| 2026-10-03 | Editor 1:1 and wheel zoom render at the source's long edge, Fit at the view's size; labelled preview tools (icon + text) with full screen, play and the crop view icon-only; the shot-data pill moves above the tools when they do not fit at 1200 px. | Render only the visible region | Decoders decode whole frames; simplest correct option. |
|
||||
| 2026-10-03 | Export tab: preset grid columns = width / 200 px; Output label column fixed at 96 px with ellipsis and tooltip; Optimise all skips Stack; render follow-ups are a toast with Show in folder plus the history line's show-file link. User presets ("Customise") are not built; the Export "Sync" box is (2026-10-06: ExportSettings.SyncToServer, off by default). | Fixed 4 columns / placeholder controls | The fixed grid clipped at 1200 px; user presets need a preset store and render-path resolution. |
|
||||
| 2026-10-03 | Exposure measuring tool switches Luminance / Flicker (frame-to-frame log-luminance change before and after correction) / Waveform (luma per column band of the corrected preview); the Time tab shows a plan chart beside the remap curve; the Camera free crop is four margin sliders (≤ 45 % each, ≥ 10 % of the frame left). | One chart per tab | §12.3 measuring needs and Editor.html. |
|
||||
@@ -299,7 +299,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-12 | A replaced import result is disposed by the `Result` setter, and a just-queued import job is read back once after its id is recorded. | Dispose only in Finish; rely on job events | New import and a source change replace the result too, and a job that ends before its id is recorded (destination offline) sends its events before the screen listens. |
|
||||
| 2026-10-12 | Offering and completing a render upload (`POST /sequences/{id}/renders`, `/renders/{uploadId}/complete`) needs the Edit permission | Upload or Edit, as for frame uploads | A render output counts against no quota and changes what the sequence shows to everyone. Clients already offer Send exports only with Upload plus Edit, so no flow breaks. |
|
||||
| 2026-10-12 | A client that imports a card into the server reports it through `POST /api/v1/uploads/cards` (Upload permission). The server republishes each report as `cardEvent`, naming the account and client. A server without the endpoint (404) gets no further reports | Server-side detection from upload session keys | The server sees single uploads, not the card, the plan's size or when the import ends. §14.3 names the event but not its source. |
|
||||
| 2026-10-12 | Project frame positions (exclusions, hero, camera keyframes) stay positions in `project.json`. When the index takes a sidecar in which frames were only inserted, they move with their frames, inside the index transaction and under the sequence lease, without a new settings version. `project.json` follows unless it was written since. Any other frame change leaves them as they are | Store exclusions and the hero by frame id; bump `settings_version` on a move | Keeps the project format and old projects. Each copy (server, synced PC) moves its own positions when it receives the same frames, whereas a version bump would make sync push a move the other copy then makes again. The lease makes a local editor's save read the moved positions and merge onto them, and remote editors already go read-only when frames change. |
|
||||
| 2026-10-12 | (Partly superseded by the 2026-11-03 portable form row: project versions store every position parked by photo; `project.json` and a workspace's working state keep positions.) Project frame positions (exclusions, hero, camera keyframes) stay positions in `project.json`. When the index takes a sidecar in which frames were only inserted, they move with their frames, inside the index transaction and under the sequence lease, without a new settings version. `project.json` follows unless it was written since. Any other frame change leaves them as they are | Store exclusions and the hero by frame id; bump `settings_version` on a move | Keeps the project format and old projects. Each copy (server, synced PC) moves its own positions when it receives the same frames, whereas a version bump would make sync push a move the other copy then makes again. The lease makes a local editor's save read the moved positions and merge onto them, and remote editors already go read-only when frames change. |
|
||||
| 2026-10-12 | A damaged or wrong-size original replaced by a verified re-upload is kept beside it as `<name>.damaged-<UTC time>` and is never deleted by Chronos | Delete it after the repair, or move it to the trash | BRIEF §0.2 rule 8 forbids automatic deletion. Scans ignore the name, and the user decides. |
|
||||
| 2026-10-12 | The Uploader deletes a source only after its own verified upload, not when the server answers that it already holds the content, so such watch-folder files stay | Also delete on "already on the server" | That answer comes without the server re-reading the bytes. BRIEF §15 deletes after a verified upload only. |
|
||||
| 2026-10-12 | An upload whose target sequence (the requested one, or the one its session key names) already holds its content is free: a repair adds no used bytes, and the quota checks at start and completion skip it | Charge every committed upload | The archive does not grow. `used_bytes` is never recomputed, so charged repairs drifted it upward and could refuse the repair itself. |
|
||||
@@ -318,7 +318,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-12 | The MakerNote exposure mode (Canon, Olympus, Fujifilm, Panasonic, Sony) fills `ExposureProgram` only when Exif has none | Prefer the vendor value | Exif is the standard field most cameras write; the vendor value covers bodies that leave it out. |
|
||||
| 2026-10-12 | `PRAGMA compile_options` is probed once per process, logged and written to the diagnostics bundle; any failure gives an empty list | Fail opening the index; probe on every open | BRIEF §6.2 makes it informational: Chronos uses no optional SQLite feature (FTS, JSON). |
|
||||
| 2026-10-12 | Frames both analyses find undecodable are one finding over the union of both lists, at the higher severity | Keep the light finding and drop the deep one | The deep pass also lists missing and corrupt frames and those beyond this host's decoders, which are never flagged; dropping its finding hid them and miscounted. |
|
||||
| 2026-10-12 | A `.chronos` project file is versioned UTF-8 JSON (`chronos-project`, formatVersion 1) that names the archive (id, name, path) and the sequence (id, folder, title, frame count) and carries the project.json settings. Opening it finds the sequence by id, otherwise by the same folder in the same archive, and applies the settings as one undo step. | A self-contained bundle (zip with frames or proxies), or a bare copy of project.json | Frames live in the archive and the index already knows them. A small reference plus settings is what BRIEF §18's file association needs, survives an index rebuild (folder fallback) and never duplicates photos. |
|
||||
| 2026-10-12 | (Partly superseded by the 2026-11-03 project file format 2 and `.chronos` files rows: a workspace's working state is format 2 with a `workspace` section; opening a format 1 file gives its settings to the sequence's Main project in the workspace.) A `.chronos` project file is versioned UTF-8 JSON (`chronos-project`, formatVersion 1) that names the archive (id, name, path) and the sequence (id, folder, title, frame count) and carries the project.json settings. Opening it finds the sequence by id, otherwise by the same folder in the same archive, and applies the settings as one undo step. | A self-contained bundle (zip with frames or proxies), or a bare copy of project.json | Frames live in the archive and the index already knows them. A small reference plus settings is what BRIEF §18's file association needs, survives an index rebuild (folder fallback) and never duplicates photos. |
|
||||
| 2026-10-12 | One Chronos per data folder: a named mutex keyed by the data folder's hash. A later launch hands its arguments over a current-user named pipe. The running one listens from the moment it holds the mutex and queues messages until its window exists. It stops listening when its window closes but keeps the mutex until its services have stopped. A launch that gets no answer waits up to 30 s for it to exit and starts in its place. An elevated instance's mutex counts as 'running'. | Several instances on one data folder, one instance per user, or exiting when the hand-over fails | Two processes would share one SQLite index and job engine. Portable copies have their own data folder. Without the queue and the wait, a file double-clicked during start-up or just after closing was silently dropped. |
|
||||
| 2026-10-12 | The Server component installs only for all users in a folder inside Program Files or Program Files (x86), not Program Files itself. Upgrading an installation elsewhere (per-user, or all-users in another folder) cannot add it, and a Server it carried is dropped with its service. | A protected DACL set by setup on a custom folder, or only a warning | A LocalSystem service must not start a program a standard user can replace (CWE-732). Program Files' inherited permissions already guarantee that, while rewriting ACLs on arbitrary drives (FAT, network shares, folders with other files) is unreliable. |
|
||||
| 2026-10-12 | Setup changes only services, sign-in entries and shortcuts that start a program its install log or payload lists, with full paths compared ignoring case. The services are stopped, started, pruned or deleted through the Service Control Manager. An unelevated setup runs `/SERVICES=… /NAMES=… /DIR=…` in an elevated copy that reads each named service again and refuses one that no longer starts such a program. | Everything under the install folder; sc.exe; trusting the caller's list | The folder may be shared (D:\Apps, /DIR="C:\Program Files"). No external processes may run. An elevated step must not act on what an unelevated caller merely names. |
|
||||
@@ -369,7 +369,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-12 | A thumbnail drawn before a verify hashed its photo still counts as that photo's (`ThumbPack.IsFrom`): image passes reuse it and the server serves it. Such a thumbnail carries the fingerprint of the file name and size. One drawn from another hash, file or size does not count. | Clear ThumbsBuilt when a verify hashes frames, and draw them again; serve only exact fingerprints | Hashing changes nothing about the photo. After a verify, the thumbnail of every scan-adopted frame answered 404 while ThumbsBuilt stayed set and no pass was queued, and the next pass drew them all again. |
|
||||
| 2026-10-12 | A deep analysis checks its own report against the frames as they are when it records. It reloads them under the sequence lock and applies `SequenceAnalyser.ReadReport`'s rule. If the run found a frame unreadable and that frame's proxy arrived during the run, the report counts as none for the Auto values, AnalyzedDeep, HasWarnings, the warning count and the stored summary. The advice is applied under the same lock as the status. Refines 2026-10-12 '`analysis.json` lists the frames…'. | Queue another light analysis when the report is stale; keep the deep status until the next light analysis | The light analysis that an arriving proxy queues can finish on another worker (Auto is cores/2) before the deep run records, and nothing runs it again. The stale deep status, warning count and Library badge then stayed, while the report endpoint answered 404. Under one lock, that light analysis either ran before and is not undone, or runs after. |
|
||||
| 2026-10-12 | Before deleting a row that the folders listed at its start do not back, a rebuild checks it again under the row's sequence lease. The row stays when it waits for its first frame, when its current folder holds a sidecar naming it, when that sidecar cannot be read, or when another process holds its lease. | List the folders again at the end; keep rows whose updated_at is later than the rebuild's start | Uploads go on during a rebuild, which can take minutes. A first frame's new folder, or a new session's sequence, is not in the listing taken at the start. Dropping its row gave the Uploader 404, and (with the session mapping cascaded away) split the session into a ' (2)' sequence. A second listing still races, and updated_at moves for many unrelated edits. |
|
||||
| 2026-10-12 | A local editor's save is refused under the sequence lease (`FramesChangedException`, nothing written) when the sequence's frames version has moved since the editor read its frames. The index edit also names that version. The editor then reads the sequence again and moves its project, its basis and every undo and redo step the way the index moved the stored copy (`ProjectSettings.FollowFrames`): by frame id when every frame it read is still there, otherwise unchanged; waiting photos are placed. It then saves the project in the new order, up to 3 times. The editor reads the row and frames as one state: the frames are listed between two reads of the row at the same frames version, 3 attempts, then 'Photos are being added to this sequence; wait a moment and try again.' Reads of the sequence never overlap: each waits for the one under way, and saves wait for it, so each read follows the frames the one before took. The frame on screen stays on its photo. | Translate inside the source and keep the editor's old frame list; refuse with an error and reload, losing the edit; store positions by frame id | Insertions hold the same lease, so the check is exact. Applying the index's own rule moves basis, edit and stored copy alike, so the three-way merge stays meaningful. Undo steps must move too, or Ctrl+Z brings back positions in the old order. Two jobs that end together read the sequence at once, and the later frames must not be followed back to the earlier ones. Positions stay positions (row 'Project frame positions…'). |
|
||||
| 2026-10-12 | (Partly superseded by the 2026-11-03 Edit opens workspace projects row: Edit edits this PC's sequences only as workspace projects, whose media change only through Update media; the rule stays for a capture.) A local editor's save is refused under the sequence lease (`FramesChangedException`, nothing written) when the sequence's frames version has moved since the editor read its frames. The index edit also names that version. The editor then reads the sequence again and moves its project, its basis and every undo and redo step the way the index moved the stored copy (`ProjectSettings.FollowFrames`): by frame id when every frame it read is still there, otherwise unchanged; waiting photos are placed. It then saves the project in the new order, up to 3 times. The editor reads the row and frames as one state: the frames are listed between two reads of the row at the same frames version, 3 attempts, then 'Photos are being added to this sequence; wait a moment and try again.' Reads of the sequence never overlap: each waits for the one under way, and saves wait for it, so each read follows the frames the one before took. The frame on screen stays on its photo. | Translate inside the source and keep the editor's old frame list; refuse with an error and reload, losing the edit; store positions by frame id | Insertions hold the same lease, so the check is exact. Applying the index's own rule moves basis, edit and stored copy alike, so the three-way merge stays meaningful. Undo steps must move too, or Ctrl+Z brings back positions in the old order. Two jobs that end together read the sequence at once, and the later frames must not be followed back to the earlier ones. Positions stay positions (row 'Project frame positions…'). |
|
||||
| 2026-10-12 | Before a render, the editor checks that the frames it read are still the sequence's (`ISequenceSource.FramesCurrentAsync`: the index row's frames version on this PC, the manifest on a server). On this PC it reads the sequence again first, so the project the job embeds names the moved positions. A server sequence whose frames changed turns outdated (read-only, Get proxies) and the render is not queued. A render already waiting in the queue keeps the project it embedded. | Carry the frames version in `RenderJobParameters` and fail the job in the local, managed and render-node handlers; check inside `SubmitAsync` | The editor learns of an insertion only at its next save or after its own job, while Render embeds the project at once. One row read (one manifest read on a server) per render keeps the check in the editor, and the job format, the render handlers and the render nodes stay as they are. A render left waiting in the queue while earlier photos arrive is the one window left; closing it needs the job format to change. |
|
||||
| 2026-10-12 | The desktop editor of a server sequence sends `expectedFramesVersion` in its PATCH: the frames version of the proxies it holds. On any 409 it reads the manifest. Other frames make it outdated (read-only, Get proxies; the edit stays pending). The same frames at a new frames version retry at that version. After a lost event socket, and before a render, it compares the frames again. Servers that predate the field ignore it. | Read the new frames and translate the edit (needs the new frames' proxies); show `Server.Error.FramesConflict` and drop the edit | Server scans publish no sequenceChanged event, and events missed during a reconnect were never checked, so a save or a render could use positions the server had moved. The outdated state (row 'Server sequences whose cached frames…') already says why and offers the fix in the editor's own sentence. |
|
||||
| 2026-10-12 | Positions crossing copies by photo tell copies of one photo apart by their order (`FramePhotos.Occurrence`). A position on the n-th frame holding a photo goes to the n-th frame holding it on the other copy. When that copy holds fewer, it waits as a pending frame with `occurrence` n; occurrence 0 is not written. A hashed photo is the frames holding its hash; size and capture time count only when no frame holds the hash. | Map to every matching frame; keep the first copy; keep the receiving copy's own positions for duplicates; count unhashed frames of the same size and time as copies of a hashed photo | A PC keeps one copy where an adopted server folder holds two ('IMG_0001.JPG', 'IMG_0001 (1).JPG'). The server's exclusion of the duplicate, which the deep analysis flags, must not exclude the PC's only copy, and a push must give the server back exactly what it had. Keyframes then never pile on one frame, and older projects read the same. A frame not hashed yet may be another photo of the same size taken in the same second (an uncompressed RAW in a burst): parking a position until hashing is safe, while moving it to that photo is not. |
|
||||
@@ -416,7 +416,7 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-10-16 | The Sequence section is renamed Edit ("Modifica"): `SectionKey.Edit`, `Shell.Nav.Edit` and `Tooltips.Nav.Edit`; the classes keep their names (`SequenceView`, `SequenceViewModel`, `ShellViewModel.Sequence`, `Icon.Sequence`) and so do the editor's resource keys (`Editor.*`). Screenshots are `edit-*` (`edit-picker`, `edit-<step>`, `edit-change`, `edit-busy`). (Owner review 1, R7.) | Rename the classes and keys too | The owner's word is the section's name; renaming twenty files and two hundred keys would change nothing the user sees and would bury the real change in churn. |
|
||||
| 2026-10-16 | The editor's tabs become the steps of a guided path, freely navigable (the owner's choice): a step bar of equal cells under the header (the tab strip under the filmstrip is gone), a new first step **Analysis** (every finding with the step that deals with it, five measurements, the other steps with their states, Analyse), Previous · n / m · Next under the step's column (both buttons measured whole, the counter giving way), Alt+1…8, Ctrl+PgUp/PgDn (read on the way down the tree, since the filmstrip and the curve editors take Page Up/Down whatever the modifiers) and ←/→ in the bar. Each step shows a status by its own glyph (to do, ✓ done, ▲ attention, ◐ running, ○ waiting) worked out by `EditPath.Of` from the content, the advice, the project, the active analysis and render (`SequenceJobs.Active`), the render's blocker and whether a render has the current settings; no status ever blocks a step. The step's tooltip is "name · what it is for · state · Alt+n" (the name first, because a long name ends in an ellipsis in its cell: about 82 px at the 1200 px minimum, which every English and Italian name fits). After a step change the keyboard goes to the new step's cell when it was in the bar, on a control of the replaced step or on Previous turning itself off, and the preview takes it back if it falls to the window; Space on the step shown plays; Ctrl+click or Ctrl+Space never leaves the bar without a current step. The editor opens on the step last shown for that sequence in this run (a deep analysis that ended meanwhile resets its visited marks), else on Analysis while there is no current deep analysis or one waits, runs or is paused (`EditPath.Start`, applied again once the jobs are read unless the user chose a step), else on Frames. Last step's Next is "Next sequence". (Owner review 1, R7.) | Steps that unlock in order; a wizard with its own window; a ninth "Result" step | The owner asked for a path from the deep analysis to completion that stays freely navigable; locking steps would get in the way of photographers who know what they want; the result belongs to phase 5's export and videos library. |
|
||||
| 2026-10-16 | Step rules: Analysis is running while a deep analysis is active; needs attention when the index says AnalyzedDeep but the saved analysis describes another number of frames ("Frames changed") or cannot be read now ("Analysis unavailable": archive offline, file moved or damaged, a server that sends none; `SequenceContent.DeepOfOtherFrames` tells them apart); done with its warning count; else to do. Frames waits for the analysis, then needs attention while frames the analysis flags as black, white, duplicate or unreadable are neither excluded nor skipped by the render anyway. Exposure, Motion, Camera and Time wait while an Auto setting of the section needs the deep analysis and there is none, need attention while an Auto setting that applies lacks other data (timestamps, exposure data, source size: the tooltip is the advisor's reason), which taking the value over by hand settles; a setting whose switch is off (`EditorSettings.Applies`, the same rule as the rows' n/a) is never asked for, and a value the analysis could not measure (no usable region mask) stays at the engine's fallback. Otherwise Auto, or Edited once an Auto setting or a value set by hand differs (crop, offsets, camera moves, fit to a duration, exposure offset). Stack is optional. Export is running with its render, needs attention when the export cannot render or no render, of any age, was made from settings with the project's `EditPath.Signature` (which leaves out hero, frames to place, batch, folder, output name and server copy); the renders count as current when the newest keeps no settings (a server's, or one fetched from it) or none's settings can be read. Findings go to steps through `EditPath.FindingSteps` (all 29 keys, tested by reflection; frames of another size or orientation go to Frames, which excludes them); Frames lists its own under "Frame warnings". | A finding count per step; any missing data as "waiting" | Counts would turn Frames ▲ for timing findings it cannot fix; analysis cannot supply timestamps or exposure data, so those need the user, not a wait; a setting shown n/a cannot be taken over, so asking for it would leave a ▲ nobody can clear. |
|
||||
| 2026-10-16 | The sequence is chosen inside Edit: without an open sequence, or after Change sequence (the title's ▾, Ctrl+O, Next on the last step), a picker covers the editor in place (not a popup): this PC's sequences and the server's sequences the Library knows, newest first, searched after 250 ms (Enter and ↓ in the search box wait for the list to match what was typed), read page by page (more pages are read until the open sequence, else the one edited last, is listed, then it is selected and scrolled into view); Enter or a double-click opens, Esc clears the search then goes back. The open editor stays laid out behind it (hidden, not collapsed, so its preview is not rendered again) and keeps saving each change a moment after it is made (2026-10-03 autosave). Choosing another sequence reads it first; only once it has loaded is the open one's pending change written at once and the editor closed. When the next one cannot open now (its proxies are on their way, or it fails), the open one stays open and is again the sequence asked for (`ShellViewModel.KeepSequence`), so coming back to Edit neither asks again nor retries; Cancel also stops a server sequence chosen meanwhile from opening over it when its proxies arrive. A failed write is either kept (Keep editing) or discarded on the user's word. Asking for the open sequence again (Library, Jobs, a project file) ends a choice of another; coming back to Edit leaves it on screen (`ShellViewModel.SequenceRequests`). Deleting the sequence asked for clears the request. The section remembers each sequence's step and visited steps for the run, and `AppSettings.LastEditedSequence` (saved with `SavePreferences`) is selected first in the picker. (Owner review 1, R7.) | A popup or a separate window; close the editor when the picker opens; close it before the next sequence is read | Captures render the window's visual tree and off-screen test windows make popups fragile; keeping the editor open makes Cancel instant, and closing it only once the next sequence has loaded means a sequence that cannot open never costs the open one (nor its undo history). |
|
||||
| 2026-10-16 | (Partly superseded by the 2026-11-03 Edit picker row: the picker lists the workspace's projects above the library's sequences, and a sequence of this PC opens as a workspace project.) The sequence is chosen inside Edit: without an open sequence, or after Change sequence (the title's ▾, Ctrl+O, Next on the last step), a picker covers the editor in place (not a popup): this PC's sequences and the server's sequences the Library knows, newest first, searched after 250 ms (Enter and ↓ in the search box wait for the list to match what was typed), read page by page (more pages are read until the open sequence, else the one edited last, is listed, then it is selected and scrolled into view); Enter or a double-click opens, Esc clears the search then goes back. The open editor stays laid out behind it (hidden, not collapsed, so its preview is not rendered again) and keeps saving each change a moment after it is made (2026-10-03 autosave). Choosing another sequence reads it first; only once it has loaded is the open one's pending change written at once and the editor closed. When the next one cannot open now (its proxies are on their way, or it fails), the open one stays open and is again the sequence asked for (`ShellViewModel.KeepSequence`), so coming back to Edit neither asks again nor retries; Cancel also stops a server sequence chosen meanwhile from opening over it when its proxies arrive. A failed write is either kept (Keep editing) or discarded on the user's word. Asking for the open sequence again (Library, Jobs, a project file) ends a choice of another; coming back to Edit leaves it on screen (`ShellViewModel.SequenceRequests`). Deleting the sequence asked for clears the request. The section remembers each sequence's step and visited steps for the run, and `AppSettings.LastEditedSequence` (saved with `SavePreferences`) is selected first in the picker. (Owner review 1, R7.) | A popup or a separate window; close the editor when the picker opens; close it before the next sequence is read | Captures render the window's visual tree and off-screen test windows make popups fragile; keeping the editor open makes Cancel instant, and closing it only once the next sequence has loaded means a sequence that cannot open never costs the open one (nor its undo history). |
|
||||
| 2026-10-17 | A double-click on a row is read on the row (`MouseDoubleClick` on its `ListBoxItem`, left button only, not over one of its own buttons) in Edit's picker and in the Library's list and grid, instead of a gesture on the list: a `ListBoxItem` marks every left mouse-down handled to select, so the list's gesture only ever fired on its empty area. While the user is asked whether to discard a change that could not be written, no retry runs (`ProjectSaver.HoldAsync`, `EditorSession.HoldPendingAsync`); Discard drops it unwritten (`DiscardPending`), Keep editing lets the retries go on (`KeepPending`). (Owner review 1, R7 review.) | A double-click binding on the row template; retry during the question and drop only what is still pending | A template binding misses the row's padding; a retry that succeeds while the question is open would write the change the user is about to drop. |
|
||||
| 2026-10-23 | The product is Chronos: a byte-exact rename of every tracked file's contents and path (`Titano`, `titano`, `TITANO` → `Chronos`, `chronos`, `CHRONOS`; 10,394 replacements in 1,744 files, 1,159 moved), so identifiers, namespaces, projects, `CHRONOS_*` variables, `%LOCALAPPDATA%\Chronos`, `.chronos` files and sidecar folders, the error code `CHRONOS001` and the image name change together. No migration of old data folders or settings. Translations were then reviewed per language for forms the old name's final vowel had dictated (Finnish and Estonian cases, Hungarian, Turkish suffixes, Scandinavian genitives, Slavic and Baltic cases): 80 strings changed. Two golden values that contained the old name were recomputed (PostgreSQL MD5 response of `chronos_md5`, verified independently; the payload-tampering test's target). (Chronos on Gitea, R1.) | Keep `Titano` in identifiers and paths; migrate `%LOCALAPPDATA%\Titano` and `.titano` files | No release has shipped, so nobody has data under the old names; one name everywhere is what the owner asked for. |
|
||||
| 2026-10-23 | The repository is `BalboSoft/Chronos` on the owner's Gitea (`https://gitea.encke-hake.ts.net`). Builds embed its web address as `ChronosReleasesUrl` (replacing `ChronosReleasesRepo`, an `owner/name` on GitHub): the update check reads `<server>/api/v1/repos/<owner>/<name>/releases?draft=false&pre-release=false` (a path prefix in front of the owner is kept), the licence opens `<repository>/src/branch/main/EULA.md`, issues `<repository>/issues`, and Add/Remove Programs shows the repository. (R2.) | Two properties (server and repository); keep the GitHub API shape | One address is what the owner sees in the browser; Gitea's release JSON has the fields the update check reads (`tag_name`, `html_url`, `draft`, `prerelease`, `assets[].browser_download_url`). |
|
||||
@@ -565,3 +565,49 @@ One line per decision: date · decision · alternative · reason.
|
||||
| 2026-11-03 | Sidecar walk: a dry run or an emptying walks the archive's sidecars at most once (`SidecarWalk`: sequence id to folders, the first unreadable sidecar kept). An emptying shares one walk between its plan and every erase, so nothing walks the archive under a lease, and walks again once per lookup only when a folder it found no longer holds the sequence; still moving after that, the entry is kept as Busy. A stale walk can only keep an entry, never erase one. (Owner review 2, R7, fix round 3.) | A survey per entry (round 2) | Each erase walked the whole archive again while holding the entry's and the sequence's leases. |
|
||||
| 2026-11-03 | Download follow-ups: `SyncTransfers.QueuePassesAsync` queues every pass a download needs, a frame swap's included, with `CancellationToken.None` through the new `JobContext.EnqueueFollowUpAsync(…, CancellationToken)`, as `FrameTrash.RestoreAsync` does. (Owner review 2, R7, fix round 3.) | The job's own token | A Stop right after a swap dropped the passes it cleared, leaving frames without thumbnails, proxies or analyses. |
|
||||
| 2026-11-03 | Confirmation detail keyboard: the desktop confirmation's detail (`DetailScroll`) is focusable and a Tab stop, through a style trigger, only while its vertical scroll bar shows (a detail longer than its 288 px), with the focus ring, the detail's tooltip and accessible name; the arrow, page and Home/End keys scroll it. (Owner review 2, R7, fix round 3.) | Always a Tab stop; the mouse only | A long list of entries that may hold the last copy of their photos must be readable from the keyboard; a detail that fits needs no stop. |
|
||||
| 2026-11-03 | Projects: a sequence has one Main project and any number of other named ones (1–60 characters, unique among its live projects), each a linear history of immutable versions (`ProjectVersionKind`: commit, merge, restore, imported, external), with no branches. Migration 0009 adds `projects` and `project_versions` (rows derived from the sidecars, a head advanced by compare-and-set, Main's `mirrored_version_id` and `mirrored_settings_version`) and `renders.project_id`/`project_version_id`; `JobKind.WorkspaceCopy` is stored as 20 (wire `workspace-copy`). (Owner review 2, R8.) | Branches; one project per sequence | The owner's answer: several projects, each pushed and pulled like git, no branches. |
|
||||
| 2026-11-03 | Project sidecars: `<sequence>/.chronos/projects/<id>/project.json` (`chronos-project-record` v1: id, sequence id, name, is Main, head, `mirrored` for Main, created, created by, updated, deleted) and `versions/<number:000000>-<id>.json` (`chronos-project-version` v1, immutable, the settings as a JSON string checked against `contentHash`) are the truth. A version file is written first, then the record, then the index in one transaction, under the sequence's lease; a version file past its record that follows the head is adopted, any other moved to `versions/.stray`. Full scans, rebuilds and every `ProjectService` call take them back into the index. A record of another sequence (a hand-copied folder) is ignored. (Owner review 2, R8.) | Index rows only; a journal | The archive is the source of truth and the index is rebuilt from it; the immutable version file is its own journal; nothing is ever deleted. |
|
||||
| 2026-11-03 | Portable form: a stored version holds its settings with every frame position parked by photo (`ProjectSettings.TranslateFramePositions`), in canonical text (pending frames sorted by photo, wall-clock capture times, keyframe frame values zeroed), its content hash the SHA-256 of the UTF-8 text (`ProjectContent`). A photo not hashed yet is parked by size and capture time. (Owner review 2, R8.) | Positional settings with a frames version | The same text means the same choices on every copy; photos added, another copy's frame order, merges and splits never move a position or change a hash. |
|
||||
| 2026-11-03 | Placing by photo: `ProjectContent.Rebind` gives a renamed entry the occurrence its frame has among the frames that hold its new name, and folds the entries of one photo (excluded and hero kept if either has them, keyframes joined once each, unknown members joined; `ProjectMerge.Keyed` too). Two texts hold the same choices on a copy's frames when they are equal once each pending entry is named as the frame it lands on, hashed or not (`SameChoices`); Rebind still never drops a SHA-256. (Owner review 2, R8, fix rounds 1–2.) | Exact text comparison; the last entry wins | Burst photos keep their positions once hashed; a version the home made after a Verify and a working state saved on media copied before it read alike, so no false Changed and no version that only re-keys photos. |
|
||||
| 2026-11-03 | Unknown settings members are kept: a settable `Dictionary<string, JsonElement> Extra` with `[JsonExtensionData]` on `ProjectSettings`, its sections, `PendingFrame`, `Auto<T>`, `CameraKey` and `CurvePoint`; a placed pending entry with unknown members stays, its flags cleared, so the next portable form parks into it again. Settings without unknown members keep their canonical text. (Owner review 2, R8.) | `JsonObject` or init-only extension data | Older clients must not erase filters a newer Chronos adds; the source generator cannot bind init-only extension data and wrote `JsonObject` as invalid JSON. |
|
||||
| 2026-11-03 | Newer settings format: settings of a newer format open read-only (`FromJson(json, allowNewer: true)`, `IsNewerFormat`); a format 1 project file still refuses them. They are never merged with this format's (`NewerSettingsException` when both sides changed): a newer Main head is listed and pulled but never mirrored, merged or built on (`MirrorAsync` reads leniently and skips it), pushes must parse strictly, and the editor drops its undo steps rather than rebase them onto newer settings. (Owner review 2, R8, fix rounds 1–2.) | Refuse such settings everywhere; merge member by member | A workspace must show what a newer Chronos pushed without misreading or overwriting it, and undo must never bring this Chronos's values back over the newer ones. |
|
||||
| 2026-11-03 | Project file format 2: `ProjectBundle` is written as format 2 only with a `workspace` section (project id, name, Main, home, base version id, number and hash, media kind and frames version); a file without it is still written as format 1. `IsReadOnly` marks a project of a newer settings format. (Owner review 2, R8.) | Always format 2 | Earlier Chronos versions keep opening the project files users save. |
|
||||
| 2026-11-03 | Size limits: `ProjectBundle.MaxBytes` and `ProjectSidecars.MaxVersionBytes` are both 64 MiB, one limit for writing and reading, refused before anything is written (`ProjectTooLargeException`, `Errors.Project.TooLarge`; `ProjectVersionTooLargeException`; `PushOutcome.TooLarge`, appended last, shown as `Errors.Workspace.VersionTooLarge`). A 100,000-frame sequence with every frame parked takes about 26 MB. (Owner review 2, R8, fix rounds 1–2.) | 4 MiB for project files and 8 MiB for versions (the first version) | Large projects could not be checked out, and a version written that no read takes back was lost silently. |
|
||||
| 2026-11-03 | Main mirroring: Main is made lazily (`MainAsync`) from the sequence's settings (`project.json` first) as version 1, Imported; its head is mirrored into `project.json` and the index's settings with the settings version check; the record's `mirrored` names the version `project.json` was last known to hold. Settings any other path writes (an older Chronos, the editor's old path, an analysis, the API, sync) become an External version of Main at the next project call; a mirror a crash cut short is completed. (Owner review 2, R8.) | Migrate every sequence; an API version bump | Older clients and the server's settings sync keep working unchanged, and no migration pass runs over large archives. |
|
||||
| 2026-11-03 | Main catch-up merge: a push whose mirror a crash or a race cut short, met by settings written meanwhile by another path, becomes ONE Merge version on the head, in which the settings written meanwhile win where both changed; the push's values stay in its own version. A merge that holds nothing the head lacks makes no version and the head is mirrored, so a merge cut before its mirror is finished next time by the same index or a rebuilt one. (Owner review 2, R8, fix round 3; supersedes rounds 1–2's External and Merge pair.) | An External version, then a Merge, resumed by their shape; the push wins | The settings written meanwhile are the newer write, in force, and what older clients wrote and read; the pair's resume misfired on ordinary histories and reverted the latest edit. |
|
||||
| 2026-11-03 | An index meeting Main with no mirror known decides from `project.json`, never from its own settings column: the record's `mirrored` is a lower bound, `project.json` matching any version from the head down to it completes the mirror, a record naming the head or no version gives an External, and one naming an older mirror that `project.json` matches nowhere merges (`project.json` wins where both changed). When the catch-up records a version as mirrored and `project.json` holds it, the record names it too. (Owner review 2, R8, fix rounds 1–3.) | Compare with the index's settings column | That column can be stale on a second PC or after a backup, and taking it as an outside change reverted pushed heads. |
|
||||
| 2026-11-03 | A mirror never writes `project.json` over settings written there since this index last knew what it held (the version mirrored, the settings just taken in, the index's or the record's mirrored version): it takes them in first (External, or a merge where they win), then mirrors; if `project.json` moves again meanwhile, nothing is written and the next call catches up. A `project.json` that cannot be read is written over as before. (Owner review 2, R8, fix round 4.) | Write the mirror unconditionally | An edit another PC or an older client made only in `project.json` would be lost, its values in no version. |
|
||||
| 2026-11-03 | Catch-up: every `ProjectService` call first catches up under the sequence's lease (sidecars into the index, Main made, outside settings appended, write-back and heal); reads wait at most 3 s for the lease, then answer from the index. Unique and foreign-key errors are contained per project, other database errors per sequence in the scan and in reads. A read-only archive is read without writing: a sequence with no Main gets an index-only Main, whose sidecars are written once the archive takes writes (ours becomes `Main (2)` if another index's Main appeared meanwhile). (Owner review 2, R8, fix rounds 1–2.) | Catch up at scans only | One place keeps the index, the sidecars and Main's mirror in step; a busy sequence never blocks a screen; one damaged project never stops a scan of the archive. |
|
||||
| 2026-11-03 | Project deletion: only a record that says deleted, or a folder in `projects/.trash`, deletes; a missing folder or a record that cannot be read never does. The trash is read before the live folders, so a reconcile never undoes a deletion. A record that cannot be read holds its project back (listed as the index has it, nothing written, writes refused with `ProjectsUnreadableException`, a `HomeUnavailableException` to workspaces). Delete refuses Main, moves the folder into the projects' trash first, then writes the deleted record there. (Owner review 2, R8, fix rounds 1 and 4.) | Mark deleted when the folder is missing; write the record first | One failed read deleted every project of a sequence and made a second Main; a half-synced deletion was undone by an index that still had the project. |
|
||||
| 2026-11-03 | When a deletion wins over a live folder, the live folder's version files that the trash folder lacks and that name this project are moved into `<trash folder>/versions`: never deleted, never over an existing name, a Warning logged, a failed move retried at the next reconcile. They are not indexed (nothing restores from the projects' trash). (Owner review 2, R8, fix round 5.) | Leave them in the ignored live folder | A push another PC made before the deletion reached it stays beside the deleted record. |
|
||||
| 2026-11-03 | Lost records: a project the index holds but the archive has no folder for is written back from the index (versions, then record), never over an existing folder nor into a sequence folder without its manifest. A live folder whose record is lost gets it written again from the index only after the folder looked the same (a SHA-256 of every file's path, size and mtime) on two reconciles `RecordSettle` (2 minutes, in process) apart and while no projects' trash folder holds the project back; meanwhile it is held back, and a record that arrives wins. Settling state is kept per sequence and forgotten when the folder goes or has a record again. A folder with versions and no record whose id no index row names is a creation cut short: it holds nothing back and is left as it is. (Owner review 2, R8, fix rounds 1–5.) | Adopt or move such folders; measure the settle time from file mtimes | Sync tools bring files one by one and often keep the source's mtimes; moving files could spread a delete. |
|
||||
| 2026-11-03 | Trash record settle time: a projects' trash folder holds back the rebuild of a lost record only if its record names this sequence, or its record cannot be read, or it has no record, its newest write is under `ProjectIndexer.TrashRecordGrace` (1 day) old and no readable version in it names another project. (Owner review 2, R8, fix round 5.) | Any trash folder of the id holds it back for good | A deletion's record still on its way must win, but a trash folder of another sequence (a hand-copied folder) or one that never gets a record must not hold a project back for ever. |
|
||||
| 2026-11-03 | Records behind the index: a record whose head is a version the index holds below its own head, or that names none (`ProjectIndexer.BehindAsync`, one rule for the index and the heal), is made whole at every writable catch-up and before any append, rename or delete: the missing version files first, then the index's head. A record whose `updated` is older than the index's gives no name, and the heal writes the index's name back. `updated` never goes back: each write stamps `UpdatedAfter` (now, or 1 ms past the record replaced), the heal past both the record and the index. Only a record ahead of the index, or naming another version at its number, is refused. (Owner review 2, R8, fix rounds 2–5.) | Refuse pushes while a record lags; take the record's name | A projects folder put back from a backup must not block pushes nor revert a rename, and a rename from a PC whose clock is behind is still the newer one. |
|
||||
| 2026-11-03 | One Main per sequence, decided from the records: of the live records in step that say Main and have a version, the oldest by `created`, then id, is Main in every index; the others become ordinary projects with every version kept, their records rewritten when the archive takes writes, under the index's name (`Main (2)`…). Main passes in one transaction, the demoted project going through the temporary name `~<id>` so `ux_projects_name` and `ux_projects_main` never fail. Nothing moves while the index's Main is held back or its record behind. (Owner review 2, R8, fix rounds 2–3.) | Each index keeps its own Main | Two indexes, or a Main made while another's record was not there yet, would each mirror a different Main into the same `project.json`. |
|
||||
| 2026-11-03 | Push rules: a version is stored only when it names the head as its parent, is portable, of a known settings format, parses strictly, matches its content hash and fits 64 MiB; the home numbers it head + 1, and a repeat of a stored id answers AlreadyStored (`PushOutcome`: Stored, AlreadyStored, Diverged, HashMismatch, NewerFormat, Invalid, TooLarge). A push to Main is mirrored (its I/O failure after storing is completed by the next catch-up). (Owner review 2, R8.) | Trust the client | Hash checks and idempotent retries make pushes safe over bad links. |
|
||||
| 2026-11-03 | `IProjectHome`, the home a workspace pushes to and pulls from: `ArchiveProjectHome` in 5a, the server's in 5b. `HeadAsync` answers NotFound for a deleted project (the workspace reads Gone). `HoldsAsync` reads the version file back and checks its id, project and hash, and guards pruning and Remove local copy. `FramesStampAsync` (`frames_version:hashed:checksum:removals`, the checksum a weighted sum over the first 5 hex digits of each SHA-256) lets a workspace read the home's frames again only when they changed. An offline archive or a busy lease is `HomeUnavailableException`. (Owner review 2, R8, fix rounds 1–4.) | Read back from the index; read the frames at every status | The read-back that allows deleting a local version must come from the durable copy; a hash replaced in place must move the stamp. |
|
||||
| 2026-11-03 | `ProjectMerge` moved from the App to `Chronos.Data/Projects`: three-way merge member by member, pending frames merged per photo and flag, two heroes one conflict at path `hero`; `Replay` re-applies the home's change to each unpushed commit against the common base (named Replay: `Rebase` is the nested class). (Owner review 2, R8.) | A whole-array merge; a git-style sequential rebase | Excluding different photos on two PCs never conflicts, the last replayed commit equals the net three-way merge, and the Linux-tested Data layer can use it. |
|
||||
| 2026-11-03 | Workspace folder: no index; `WorkspaceStore` reads `<root>/*/project.chronos` and `workspace.json` (`chronos-workspace` v1, written to a temp file and moved into place without overwrite). Each project folder has `project.chronos`, `media/` (`media.json`, `proxies/`, `analysis.json`), `versions/` (with `.replaced` and `.replaced.since`), `sync.json`, `exports/` and its lease `.lock.lease`. Default `%LOCALAPPDATA%\Chronos\workspace` (or `.\data\workspace`); a folder inside a library is refused before anything is written. A GUID-named folder without `project.chronos` holding only lease files older than 2 minutes, not held, is removed by the next listing. (Owner review 2, R8, fix rounds 1 and 5.) | An SQLite table | The folder describes itself and can be moved or inspected by hand; a cancelled copy's clean-up leaves no folder that is not a project. |
|
||||
| 2026-11-03 | Workspace write order: the base in `project.chronos` is the commit point of every write sequence. A push writes the base, then marks the local file stored; a replay journals itself in `sync.json` (`WorkspaceReplay`: onto base, replaced, replayed, adopted, settles), writes the replayed versions, then the base with the merged working state, then sets the old versions aside and clears the journal. `SettleAsync`, at the start of every push, pull and resolve, finishes or undoes a cut operation; a settling replay past its commit point counts as applied. Checkout writes `project.chronos` before the base version file. (Owner review 2, R8, fix rounds 1 and 3.) | Write in place | A cut at any step loses no version and makes no false conflict. |
|
||||
| 2026-11-03 | Set-aside place: rebased local commits get new ids and the old files go to `versions/.replaced`, as does the working state Take library's replaces and an edit kept aside; nothing there is in the chain or sent. A local version that changes nothing once replayed is not sent and stays aside; Merge marks the last rebased version whose own settings meet a listed conflict path. `.replaced` is pruned after a sync that ends well: files set aside more than 30 days ago or past the newest 20 go, except any a journal, conflict or restore names; each is dated at the later of its mtime and `versions/.replaced.since`, when this build first knew the folder. (Owner review 2, R8, fix rounds 1–4.) | Rewrite versions in place; never prune | Never lose a version or an edit, and never grow without bound; files an earlier build set aside last a month after the upgrade. |
|
||||
| 2026-11-03 | Conflicts: a pull or push stops at settings both sides changed (recorded in `sync.json`) until Keep mine, Take library's, Save both or Later. A choice settles only the conflict shown; if the head or the differences moved, the new conflict is recorded and asked. The listed value is the working state's (against the last local version and the base); a path where the working state already holds the library's value is no conflict and takes it silently. Take library's commits nothing first: the working state it replaces goes to `versions/.replaced`, and the editor takes the result as one undo step. Restore saves unsaved changes as a version first, also during a conflict. (Owner review 2, R8, fix rounds 1–3.) | Auto-pick; commit before taking | Only real conflicts ask, the answer applies to what was shown, and nothing is lost or sent empty. |
|
||||
| 2026-11-03 | Save both naming: the sibling is `<name> (<PC name>)` within 60 characters, else the engine's `<name> (2)`…; your versions go to it, made from the base, and this project takes the library's head. It is journaled in `sync.json` (`WorkspaceSaveBoth`: first the intent, name, from version and hash, time asked; then the copy's id and each version's id there) before the home is asked; a retry reuses the copy found by name (created at most 5 minutes before, still version 1 with that hash) or by id while its head is ours, otherwise makes one new copy. Its commit point is the base moving onto the library's head; Keep mine or Take library's after a cut Save both finish the copy first. (Owner review 2, R8, fix rounds 1–3.) | No journal; delete a partial copy | The owner's naming; a cut never makes two copies nor leaves versions only half sent. |
|
||||
| 2026-11-03 | The workspace's media learn the home's photo names: whenever the home is asked (every sync under the lease, a status when the lease can be taken at once or after one 500 ms retry, a checkout of a project already here), a frame copied unhashed takes the home's SHA-256 when its id, size and capture millisecond match, and the home's conversion aliases are added; frames, files and the frames version stay as copied. `MediaOutdated` (the Update media banner) means the home's frames version moved, or it names photos otherwise and the media could not learn it yet. (Owner review 2, R8, fix rounds 1–3.) | Treat any hash as a change; learn only at a replay | A Verify or a conversion at the home after the copy must not undo frame edits at the next pull. |
|
||||
| 2026-11-03 | The frames stamp: a workspace status reads the home's frames again only when `IProjectHome.FramesStampAsync` changes (the archive's: frames version, hashed-frame count, a checksum of the hashes, removal count); a home without a stamp is read every time, and a sync's replay always reads them. (Owner review 2, R8, fix rounds 3–4.) | Read every frame at every status | The picker reads a state per project; a large sequence must not be loaded each time, yet a hash replaced in place must be seen. |
|
||||
| 2026-11-03 | Workspace states: In sync, Changed, Not sent, Library newer, Conflict, Offline, No media, Not in library (`Gone`: the home has no such project or sequence; push, pull and resolve return it without replaying anything, it is logged once, it carries no conflict, and the copy goes only by Discard) and Damaged (a version file after the base cannot be read or breaks the chain: commit, push, pull, resolve and Save both are blocked, the file is repaired from the home's verified copy when it has one, and it is reported only once a re-read under the lease confirms it). A read-only library is named so (`Errors.Workspace.ReadOnlyHome`), not offline. (Owner review 2, R8, fix rounds 1–4.) | Offline for every failure | The user sees why nothing is sent and what settles it. |
|
||||
| 2026-11-03 | Damaged and newer copies: a copy whose `project.chronos` a newer Chronos wrote (a format above 2) is listed as *Newer Chronos* and is never opened, checked out over or removed from here; one that cannot be read is *Damaged* and goes only by Discard. Both are named by what is still known (the file read loosely, else the index's project name or sequence title); discarding a damaged one asks for that name, else its number of files. Open in workspace with such a Main lists it disabled with its reason (`Tooltips.Editor.Workspace.State.NewerCopy` or `DamagedCopy`) and selects the first readable project; it refuses at once only when Main was asked for or the home has no other project, a damaged Main then offering Remove local copy. (Owner review 2, R8, fix rounds 2–5.) | Hide them; refuse the whole open | A newer format is never fatal for the rest of the workspace, nothing in such a copy is changed, and the other projects of the sequence still open. |
|
||||
| 2026-11-03 | Edit opens workspace projects: a sequence of this PC's archive opens in Edit only as a workspace project, the one opened last for it on this PC (`AppSettings.WorkspaceRecent`), else *Open in workspace* (Project: existing or new; Media: Proxies, Originals disabled until 5c; copy size and free space, warned below size + 0.5 GB). Edit waits for the Workspace copy job as for a server sequence's proxies. A capture keeps `LocalSequenceSource`; server sequences keep `RemoteSequenceSource` until 5b. (Owner review 2, R8.) | Ask at every open; edit the library | One project is worked on at a time; the library is never edited in place; a capture has no engine to copy media. |
|
||||
| 2026-11-03 | Workspace editor saves: the working state is saved atomically under the project's lease shortly after an edit, merged in the portable form, photo by photo, whenever positions conflict; a setting the editor and a sync both changed throws `ProjectConflictException` and is asked (keep mine, take the library's). A read-only project raises `ReadOnlyChanged`: a toast, disabled controls, no save. An edit not stored yet that meets a newer Chronos's settings is written to `versions/.replaced` (*Edit kept aside*) and the pending save dropped. The chip is read 600 ms after the last edit. (Owner review 2, R8, fix rounds 1–3.) | Positional merge, the editor winning | Exclusions, keyframes and values a sync just pulled are never dropped silently. |
|
||||
| 2026-11-03 | Sync: Sync is pull, then push, then prune. With *Sync automatically* (on by default) it also runs after Save version and after an analysis while the project is behind, so Main takes the analysis' Auto values. Ctrl+S opens Save version with the note focused; Enter saves. A home out of reach leaves the version waiting. (Owner review 2, R8.) | Push only; a silent Ctrl+S | The local home is always at hand, and the editor keeps showing analysis results as before the workspace. |
|
||||
| 2026-11-03 | Kept versions: pruning keeps the base and the newest N−1 other versions taken from the home, and deletes a version file only after `HoldsAsync` finds the home's copy with the same hash; versions not sent and `versions/.replaced` are never touched. It runs after each sync; N is Settings › Workspace › Kept versions (5–200, default 20). (Owner review 2, R8.) | Prune in 5c; prune without asking the home | The setting is part of 5a, and pruning without the read-back could lose a version. |
|
||||
| 2026-11-03 | Remove local copy: a plan first (files, size, versions not sent, unsaved changes, conflict, damaged versions counted as unsent). Remove only when everything is at the home, whose head and the base are read back and hash-checked; Send first sends, then removes; Discard changes asks for the project's name typed. Every entry of the copy but `media/` and the lease files moves to `<workspace>/.trash/<id>-<ticks>`, the media are deleted, and a move that fails puts everything back in reverse order. A copy whose project the home deleted goes only by Discard (`Errors.Workspace.DeletedAtHome`). A copy job still running for the project is cancelled first. `<workspace>/.trash` is emptied in 5c. (Owner review 2, R8, fix rounds 1–4.) | Delete the whole folder | Never lose a version, an edit or a file this Chronos does not know. |
|
||||
| 2026-11-03 | Delete project commits and sends everything first, refuses while anything stays unsent or in conflict, then deletes at the home (the projects' trash) and removes the local copy; Main cannot be deleted; at Gone it says the project was deleted in the library. (Owner review 2, R8.) | Delete at once | Every version survives in the library's project trash. |
|
||||
| 2026-11-03 | Workspace copy: the job (desktop only, `WorkspaceJobs.CreateHandlers`) runs the archive's proxy pass, copies current proxies, makes the rest in the workspace at 1920 px when the archive makes none, and reads each file back. It writes `media.json` last and moves the working positions by photo under the project's lease for that step only; it starts again when the frames change (3 passes). Its checkpoint is `copy:<frame>:<frames version>:<folder>`; changed bytes go under `proxies/<id>-<sha16>.jpg` until the commit, and no file `media.json` names is deleted before it. Free space: an estimate per frame (0 when held, the archive proxy's size, else 1.5 MB × (edge/1920)²) plus 512 MiB, checked before each pass and every 5 s (`Errors.Workspace.DiskFull`). Default level High. Originals are refused until 5c. (Owner review 2, R8, fix rounds 1–4.) | Copy originals; hold the lease throughout; trust a resumed file | Fast editing on proxies while the editor keeps saving; a resume after a move or a conversion checks every file; the system drive never fills. |
|
||||
| 2026-11-03 | The copy job's cancel clean-up: a cancelled first copy clears `media/` only under the project's lease, taken without creating a folder, after checking again that the job is still Cancelled, that no other WorkspaceCopy of the same root (full path, case-insensitive) and project is Queued, Running or Paused (one whose parameters cannot be read counts), that `media.json` is absent and that no copy in this process is writing; otherwise the media stay, with an Info line. It runs from the handler once it has stopped writing, or through the new `ICancelledJobHandler` for a paused or failed job no handler runs; `JobEngine.CancelAsync` of a paused job whose run has not ended waits for that run first. Paused, yielded and shut-down copies keep their files. (Owner review 2, R8, fix rounds 2–5.) | The section's view model deletes the media when the job reads Cancelled | The view model raced the stopping copy and missed a copy nobody watched; a second copy of the same project must keep its files. |
|
||||
| 2026-11-03 | Workspace renders: a render from Edit of a workspace project runs on this PC's engine at the home, with the originals and the portable settings embedded (`RenderJobParameters.SettingsJson`, the handler placing pending frames first), one job per preset. The desktop names a version only while none waits to be sent; `RenderJobHandler.ProvenanceAsync` records the project only if it is one of the sequence, and the version only if the index holds it for that project with the embedded settings' content hash. (Owner review 2, R8, fix round 1.) | Commit before rendering; record any version id | A render never invents a version nor names one whose settings it did not use, or that a later replay renames. |
|
||||
| 2026-11-03 | `.chronos` files: format 2 opens its workspace project (a copy of one gives that project its settings as one undo step; a project the home lacks falls back to Main); format 1 gives its settings to the sequence's Main, opened in the workspace. *Save project file* still writes format 1. (Owner review 2, R8.) | Refuse format 1 | Older files and the file association keep working. |
|
||||
| 2026-11-03 | Edit picker: the workspace's projects (saved last first) above the library's sequences; each state is read from its home after the list shows; the search filters both; Enter opens a library match first, a project only when no sequence matches. A row's context menu and Delete offer Remove local copy, also for a copy that cannot open. (Owner review 2, R8.) | One merged list | The picker's keyboard behaviour and paging stay as they were. |
|
||||
| 2026-11-03 | Settings › Workspace (after Storage): *Folder* with *Open* and *Change…* (a plan, projects left and found; it closes an open workspace project and moves nothing; the default is stored as no setting), *Sync* (After each version, on) and *Kept versions*. Reset all and Import keep `WorkspaceFolder` and `WorkspaceRecent`; Export leaves them out. Moving the folder with its projects, the size limit and the plan's other settings are 5c. (Owner review 2, R8, fix round 2.) | An editable path that moves the projects now | The folder holds this PC's unsent work: moving it needs its own plan and confirmation. |
|
||||
| 2026-11-03 | Workspace texts: the workspace's strings live in the existing Editor, Tooltips, Settings and Errors areas; the home is called "the library" (the server home will name its server), Main is shown in the UI language (it: Principale), and versions carry the bare PC name (`Environment.MachineName`; History strips `chronos@`, `server@`, `workspace@` and `Chronos on`). (Owner review 2, R8.) | A new Workspace area | No new resource files to translate; the wording matches the rest of the desktop. |
|
||||
| 2026-11-03 | `ProjectMenuViewModel` reaches the window only through `IWorkspaceUi` (dialogs, `ShowDialogWhenFree`, confirmations, toasts, opening and closing a project). A conflict found by an automatic sync waits for the open dialog and is asked once. (Owner review 2, R8.) | Depend on the shell; replace the open dialog | Its logic is tested without a window, and a background prompt never hides what the user is doing. |
|
||||
| 2026-11-03 | Leases: `LeaseFile.TryAcquire` and `AcquireAsync` take `createDirectory` (default true); the copy's clean-up passes false. `WorkspaceSync.OpenAsync` reads the working state and the media under the project's lease; a lease still busy after the wait is `Errors.Workspace.Busy`. (Owner review 2, R8, fix rounds 1, 2 and 5.) | Always create the folder; read without the lease | A clean-up must never make a removed project folder again, and the editor never reads a half-written working state. |
|
||||
+15
-5
@@ -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 six 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 everLine 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 six 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 everLine truncated
|
||||
| 9 Monetization | Not started: requires explicit approval (§22). |
|
||||
|
||||
## Verification (2026-10-12)
|
||||
@@ -95,8 +95,14 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
*Replace*; when the job ends, *Undo* in its toast brings the originals back (later: Maintenance › *Trash…*).
|
||||
Admin panel: Library › select sequences › *Convert…* › JPEG, *New sequence* › *Convert…* › *Convert* › *Open job*:
|
||||
the copies appear as "… (JPEG)"; with *Replace*, type "replace", and the trash's *Restore* swaps the originals back.
|
||||
- Workspace: open a sequence from the Library: *Open in workspace* asks the project (Main, or New with a name) and
|
||||
the media (Proxies), with the copy's size and the free space; the editor opens once the *Workspace copy* job ends.
|
||||
Edit, then Ctrl+S, type a note, Enter: the chip says *In sync* and the Library's sequence takes the settings (Main).
|
||||
Ctrl+O lists the project in the picker's *Workspace* group. The title's ▾ › *History…* › *Compare* or *Restore*;
|
||||
▾ › *Remove local copy…* shows its plan. Two workspace folders on one archive (Settings › Workspace › *Change…*)
|
||||
stand in for two PCs: change the same setting in both and *Sync* to see the conflict dialog.
|
||||
- Project files: Export › *Save project file* writes a `.chronos` file; opening it (double-click or `Chronos.exe <file>`)
|
||||
opens the sequence with those settings in the running Chronos.
|
||||
opens the sequence with those settings in the running Chronos, given to its Main project in the workspace.
|
||||
- Notifications: minimise Chronos and insert a card or finish a job: a Windows notification appears; Ctrl+1…6 and
|
||||
Ctrl+, switch sections.
|
||||
- Edit: Ctrl+3 with no sequence open shows the picker (type to search, Enter opens); the title's ▾ or Ctrl+O chooses
|
||||
@@ -108,9 +114,13 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot
|
||||
Owner reviews, in the owner's order (owner review 2 first, then the rest of owner review 1); each phase ends with a
|
||||
release (owner review 2, R12):
|
||||
|
||||
1. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009).
|
||||
2. Owner review 2, phase 5b: R8 server home.
|
||||
3. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings.
|
||||
1. Owner review 2, phase 5a: translate its 241 new keys into the 36 other languages, then release `v0.1.0-rc.8`
|
||||
(the PR green on Gitea Actions, squash-merge, tag, the Docker image and the Windows programs) and update the
|
||||
memory notes.
|
||||
2. Owner review 2, phase 5b: R8 server home (the projects API under `/sequences/{id}/projects`, `projectChanged`, the
|
||||
server's `IProjectHome`, workspace copies from the server, Open in workspace on the Server screen).
|
||||
3. Owner review 2, phase 5c: R8 originals, local render (`WorkspaceRender`), Remove local copy's clean-up and the
|
||||
workspace's trash, the size limit, moving the workspace folder, the rest of Settings › Workspace.
|
||||
4. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations,
|
||||
straightening and colour filters (project settings in the workspace).
|
||||
5. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library.
|
||||
|
||||
@@ -73,8 +73,8 @@
|
||||
| 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 six 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; 25 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; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | `7e4a3b48` |
|
||||
| 4b | R7 mass conversion | done 2026-11-02, released as `v0.1.0-rc.7` (one adversarial review round, 42 findings, and two fix rounds; strings in all 38 languages): BRIEF §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9, §24; 26 DECISIONS rows dated 2026-10-26 (R7 conversion after import, import still byte for byte; Replace or New sequence at every run, never remembered; targets and the scene-referred archival DNG; the conversion's decoder order, managed first and no 16-bit file from an 8-bit RAW development; the TIFF reader's refusals; colour profiles carried, converted or refused; the converted files' Exif; a dry run that probes what it promises; exactly the confirmed photos, by digest and ids; the two-stage, resumable job; the purge of staging and journals; free space measured where the conversion writes; no conversion of the same sequences twice; New sequence holding the converted copies alone, saying what it lacks; the Replace swap; the replace journal decided by content; Undo by the job's own entries; replaced entries weighed against the archive on disk; every last copy named before the typed confirmation; sync aliases as equivalence classes; link by content, proxies and downloads following them; the ingest taking a replaced original as present; the plan cache shared with Reorganize; the convert API; the `convert` job kind; failure sentences by cause), four earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.7] with the upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 5a | R8 workspace and projects with a local home (migration 0009) | todo | |
|
||||
| 4b | R7 mass conversion | done 2026-11-02, released as `v0.1.0-rc.7` (one adversarial review round, 42 findings, and two fix rounds; strings in all 38 languages): BRIEF §5, §7, §8.1, §8.3, §8.7, §9, §12.2, §12.4, §12.5, §13, §14.3, §14.4, §14.5, §14.8, §14.9, §24; 26 DECISIONS rows dated 2026-10-26 (R7 conversion after import, import still byte for byte; Replace or New sequence at every run, never remembered; targets and the scene-referred archival DNG; the conversion's decoder order, managed first and no 16-bit file from an 8-bit RAW development; the TIFF reader's refusals; colour profiles carried, converted or refused; the converted files' Exif; a dry run that probes what it promises; exactly the confirmed photos, by digest and ids; the two-stage, resumable job; the purge of staging and journals; free space measured where the conversion writes; no conversion of the same sequences twice; New sequence holding the converted copies alone, saying what it lacks; the Replace swap; the replace journal decided by content; Undo by the job's own entries; replaced entries weighed against the archive on disk; every last copy named before the typed confirmation; sync aliases as equivalence classes; link by content, proxies and downloads following them; the ingest taking a replaced original as present; the plan cache shared with Reorganize; the convert API; the `convert` job kind; failure sentences by cause), four earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.7] with the upgrade note and the known limitations; STATUS 8.3 | `efa87f68` |
|
||||
| 5a | R8 workspace and projects with a local home (migration 0009) | done 2026-11-03, to be released as `v0.1.0-rc.8` (one adversarial review round, 55 findings, and five fix rounds; strings in en and it, the 36 other languages still to translate): BRIEF §4.4, §5, §7, §12.2, §12.3, §12.6, §12.8, §14.5, §14.6, §24; 46 DECISIONS rows dated 2026-11-03 (R8 projects and versions in the index by migration 0009; the sidecars as the truth; the portable form with positions parked by photo and canonical text; placing by photo; unknown members kept; a newer settings format read only; project file format 2; the 64 MiB limits; Main mirroring the settings and `project.json`; the Main catch-up merge; a mirror never written over settings it has not taken in; deletion from the trash read first, late versions moved beside it; lost and behind records; one Main; push rules; `IProjectHome`; the workspace folder and its write order; versions set aside and pruned; conflicts and Save both naming; media learning names; the frames stamp; Gone and Damaged states; newer and damaged copies; Edit opening workspace projects; editor saves; sync; Kept versions; Remove local copy; Delete project; the workspace copy job and its cancel clean-up; renders with project and version; `.chronos` files; the picker; Settings › Workspace; texts; `IWorkspaceUi`; leases), five earlier rows marked superseded in part; CHANGELOG [0.1.0-rc.8] with the migration 0009 upgrade note and the known limitations; STATUS 8.3 | |
|
||||
| 5b | R8 server home | todo | |
|
||||
| 5c | R8 originals, local render, clean-up, Workspace settings | todo | |
|
||||
|
||||
|
||||
Reference in new issue
Block a user