Owner review 2, R8, phase 5a (docs/requests/2026-10-26-owner-review-2.md). To be released as v0.1.0-rc.8.
What changes
Workspace. Edit no longer edits inside the library. A sequence opens as a project in a workspace folder on a fast disk (%LOCALAPPDATA%\Chronos\workspace). The first open asks Open in workspace: you pick the project (Main, an existing one or a new one) and the media (Proxies). A hash-verified, resumable Workspace copy job (JobKind.WorkspaceCopy = 20) then copies the proxies.
Projects. A sequence can have several projects, each with a linear version history. The histories are stored as sidecars in .chronos/projects/, which a scan or a rebuild reads back.
Main mirrors the sequence's own settings in both directions, so older clients, analyses and server sync keep working.
Migration 0009_projects.sql adds the projects and project_versions tables and two columns in renders.
Sync like git. The editor's project button has a state chip and these actions:
Save version (Ctrl+S) and Sync, which pushes, or fast-forwards, or rebases and merges setting by setting;
History (compare, restore);
Open/New/Rename/Delete project;
Remove local copy, which shows a plan first and never discards unsent work without a typed confirmation.
Only settings changed on both sides ask you to choose: Keep mine, Take library's or Save both.
Settings › Workspace: Folder, Sync, Kept versions. Update media appears when the library's photos changed after the copy.
Renders from Edit run at the library with the project's settings and record the project and the version.
Every new string (241 keys) is in en, it and the 36 machine-translated languages. The new terms are added to GLOSSARY.md and to each glossary.tsv.
How it was checked
Review: one review round found 55 findings. Five fix rounds followed, each with an independent checker, until the last check passed.
Phase 4b merge: the final phase 4b head (11d2c67e, released as rc.7) is merged in with a real merge. main is recorded with -s ours; its tree equals 11d2c67e.
Build:dotnet build -c Release gives 0 warnings.
Tests:
Suite
Passed
Failed
Skipped
Core
1368
0
6
Data
832
0
314 (PostgreSQL, run in CI)
Tools
60
0
0
Server
277
0
7
Core.Windows
85
0
0
App
751
0
1
Core.Windows and App ran with the usual local exclusions.
Checks:i18n check (0 errors, 0 warnings), xaml-lint, package-guard and dotnet format are all clean.
Not in this phase
The server home is phase 5b.
Phase 5c covers originals in the workspace, local renders, automatic clean-up, the size limit and the rest of Settings › Workspace.
CHANGELOG [0.1.0-rc.8] lists the known limitations.
Docs: BRIEF (amended 2026-10-26, R8), DECISIONS (2026-11-03), CHANGELOG, STATUS, ARCHITECTURE, and the request file (with the 4b commit cell set to efa87f68).
Owner review 2, R8, phase 5a (`docs/requests/2026-10-26-owner-review-2.md`). To be released as `v0.1.0-rc.8`.
## What changes
- **Workspace.** Edit no longer edits inside the library. A sequence opens as a project in a workspace folder on a fast disk (`%LOCALAPPDATA%\Chronos\workspace`). The first open asks *Open in workspace*: you pick the project (Main, an existing one or a new one) and the media (Proxies). A hash-verified, resumable *Workspace copy* job (`JobKind.WorkspaceCopy = 20`) then copies the proxies.
- **Projects.** A sequence can have several projects, each with a linear version history. The histories are stored as sidecars in `.chronos/projects/`, which a scan or a rebuild reads back.
- Main mirrors the sequence's own settings in both directions, so older clients, analyses and server sync keep working.
- Migration `0009_projects.sql` adds the `projects` and `project_versions` tables and two columns in `renders`.
- **Sync like git.** The editor's project button has a state chip and these actions:
- *Save version* (Ctrl+S) and *Sync*, which pushes, or fast-forwards, or rebases and merges setting by setting;
- *History* (compare, restore);
- *Open/New/Rename/Delete project*;
- *Remove local copy*, which shows a plan first and never discards unsent work without a typed confirmation.
Only settings changed on both sides ask you to choose: *Keep mine*, *Take library's* or *Save both*.
- **Settings › Workspace:** Folder, Sync, Kept versions. *Update media* appears when the library's photos changed after the copy.
- Renders from Edit run at the library with the project's settings and record the project and the version.
- Every new string (241 keys) is in en, it and the 36 machine-translated languages. The new terms are added to `GLOSSARY.md` and to each `glossary.tsv`.
## How it was checked
- **Review:** one review round found 55 findings. Five fix rounds followed, each with an independent checker, until the last check passed.
- **Phase 4b merge:** the final phase 4b head (`11d2c67e`, released as rc.7) is merged in with a real merge. `main` is recorded with `-s ours`; its tree equals `11d2c67e`.
- **Build:** `dotnet build -c Release` gives 0 warnings.
- **Tests:**
| Suite | Passed | Failed | Skipped |
|---|---|---|---|
| Core | 1368 | 0 | 6 |
| Data | 832 | 0 | 314 (PostgreSQL, run in CI) |
| Tools | 60 | 0 | 0 |
| Server | 277 | 0 | 7 |
| Core.Windows | 85 | 0 | 0 |
| App | 751 | 0 | 1 |
Core.Windows and App ran with the usual local exclusions.
- **Checks:** `i18n check` (0 errors, 0 warnings), `xaml-lint`, `package-guard` and `dotnet format` are all clean.
## Not in this phase
- The server home is phase 5b.
- Phase 5c covers originals in the workspace, local renders, automatic clean-up, the size limit and the rest of Settings › Workspace.
- CHANGELOG `[0.1.0-rc.8]` lists the known limitations.
Docs: BRIEF (amended 2026-10-26, R8), DECISIONS (2026-11-03), CHANGELOG, STATUS, ARCHITECTURE, and the request file (with the 4b commit cell set to `efa87f68`).
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Owner review 2, R11 asked for more log settings. The file sink now writes daily or
hourly files, continues a full file in numbered parts and prunes by age and by the
total size (never the file being written); its options change while it runs.
Server: the file and console levels are separate and read by the logging filters
at every line, so the admin panel's new Logs group applies without a restart; the
engine's level follows the lower of the two. This also fixes a bug: the file logger
was fixed at Information, so CHRONOS_LOG_LEVEL=Debug or Trace never reached the
files. New variables CHRONOS_LOG_CONSOLE_LEVEL, CHRONOS_LOG_RETENTION_DAYS,
CHRONOS_LOG_MAX_FILE_MB, CHRONOS_LOG_MAX_TOTAL_MB, CHRONOS_LOG_ROTATION,
CHRONOS_AUDIT_RETENTION_DAYS and CHRONOS_DIAGNOSTICS_LOG_MB lock their settings like
the others; the diagnostics zip keeps the configured share of each log.
Desktop: Settings > Advanced gains Log level, Keep logs, File size, Logs total,
Rotation and Diagnostics logs, applied at every save; Advanced's Reset section
restores them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit cc875784e4952ee0e4c807b9d9c18496d3d5a8c3)
Owner review 2, R10: every timer that queues work becomes a visible schedule,
so the server and the desktop need one shared engine to run them.
- Migration 0007: schedules table (system rows keyed by system_key) and
jobs.schedule_id; Job.ScheduleId, JobDto.ScheduleId, JobRepository
HasPendingAsync / ListPendingTargetsAsync / ListByScheduleAsync.
- ScheduleRepository: seeding that keeps user edits, reset, compare-and-set
claim of a run (one winner across processes), outcomes.
- Scheduling: in-house recurrence (every/daily/weekly/monthly, DST gap moves
forward, ambiguous time runs once), ScheduleActions resolving scan, verify,
thumbnails, proxies, analysis, maintenance, backup, cleanup, duplicates and
orphans into archive jobs, IScheduleHost, and the Scheduler loop (catch-up,
clock going back, run now, CRUD as API v1 DTOs).
- New job kinds Backup (16) and Cleanup (17) with handlers, shared clean-up
steps (job history, audit log, trash report that never deletes) and host
steps through ArchiveServiceOptions; read-only Duplicates and Orphans report
handlers, so the server can run those kinds too.
- JobEngine no longer purges history at start: the housekeeping schedule's
job-history step does; JobEngine.CanRun and an EnqueueAsync with scheduleId.
- Protocol DTOs for schedules; job kind names in en and it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit eb0edd2483a493db7c6945d5b494461cabb2a4ad)
Owner review 2, R10: nothing may run out of sight, so every timer the server
ran becomes a system schedule the admin panel shows and manages, and
administrators create their own.
- SchedulerHost runs the shared Scheduler on the job engine (started after
JobEngineHost, stopped before it); ServerScheduleHost gives it the
container's time zone (UTC with a warning when TZ is unknown), the archive
refreshed from archive.json at every run (what ArchivePolling did), the
clean-up steps and the system schedules: archive-scan every 10 minutes
(no catch-up, also run once at start like the polling), upload-cleanup
every 30 minutes, index-backup at 03:00 (SQLite only), housekeeping (job
history) at 04:00 and audit-cleanup at 04:30.
- ArchivePolling and DatabaseBackupService are gone; UploadMaintenance only
recovers commits at start, its sweep is the "uploads" clean-up step.
- /api/v1/schedules (ManageArchive, audited): list with actions and time
zone, create, PUT/PATCH, delete (409 schedule_system), run now (409
schedule_pending), reset (409 schedule_no_defaults), runs paged by cursor;
invalid fields are 400 invalid_schedule naming the field.
- CHRONOS_AUDIT_RETENTION_DAYS (AuditRetentionDays, default 365) seeds the
audit clean-up; set by the environment it is applied at every start and
locked. Job history leaves Settings: it is the housekeeping schedule's age
limit, and the setting is what a reset restores.
- Admin panel: Jobs has Queue and Scheduled tabs; schedules with when (in
the panel's language and the server's zone), next run, last result, a
switch, Run now, Edit, Delete or Reset, their runs linking to the jobs, and
a side panel for the action, recurrence and parameters; job rows a
schedule queued carry a Scheduled pill. Strings in en and it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 808ce94ae29e3bf4522cb4d40dfd76d4f8529c64)
Owner review 2, R10 on the desktop: every timer that queued work out of
sight is now a visible, editable schedule of this PC.
- DesktopScheduleHost implements IScheduleHost: the PC's time zone, the
archive at Settings › Archive's folder (refreshed from archive.json,
none while it is offline), and three system schedules: archive-scan
(every:<ScanIntervalMinutes>m, seeded once from the old setting, no
catch-up), index-backup (every day with catch-up, replacing
DatabaseBackups.RunDailyAsync) and housekeeping (daily 04:00 with
catch-up: job history 90 days and the new cache-trim step).
- AppServices starts the Scheduler after the engine, once the archive was
reopened; an unplugged archive is looked for every minute and the
scheduler woken when it is back. The rescan loop and the daily backup
loop are gone; ApplyJobSettings wakes the scheduler.
- CacheStore.Trim brings the cache to Settings › Storage › Cache limit,
oldest files first, skipping files in use and the proxies, render-node
and server-import folders; CacheTrimStep runs it as a clean-up step.
- Jobs gets a Queue | Scheduled segmented control. Scheduled lists the
schedules (switch, name, action, when, next run, last result) with Run
now, Edit, Reset (system) or Delete (user's, confirmed), the selected
schedule's last runs with Show in queue, and an in-window editor that
checks every field with the scheduler's limits. Jobs a schedule queued
carry a "Scheduled" pill; the history line follows the housekeeping's
job-history days.
- JobNotices: a scheduled background run raises a toast only when it
fails (upkeep stays silent).
- Settings › Archive › Rescan every is removed; ScanIntervalMinutes stays
only as the seed. Strings in en and it; the others are retranslated.
- The capture shows jobs-scheduled and jobs-schedule-editor on a stopped
scheduler clock with sample schedules.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit e25d812feb3f417cb9251c748c29e8035fd9b03c)
Settle what the R10 scheduler and R11 log packages left open when they were
integrated (owner review 2, phase 2).
- Audit retention has one source of truth, the audit-cleanup schedule's age
limit. AuditRetentionDays defaults to 0 (the audit log is kept forever, so
an upgrade deletes nothing; the schedule is seeded off) and accepts 0-3650,
what a schedule's age limit takes. Saving Settings › Logs › Keep audit sets
the schedule's limit (on with a limit, off at 0) without a restart;
CHRONOS_AUDIT_RETENTION_DAYS locks it and Reset goes back to it.
- Both hosts scan right after start again, as their polling did: the server
after the scheduler starts, the desktop once the archive was reopened and
again when an unplugged one is back. Scheduler.RunSystemNowAsync runs the
archive-scan schedule when it is enabled and has not run since the start,
and skips while its scan is pending.
- Desktop scans follow Settings › Analysis › After a scan at every run: a scan
schedule without its own deep parameter asks the host
(IScheduleHost.DeepAnalysisAfterScan), the archive-scan schedule no longer
freezes the setting, and the editor offers deep only for analyses, so the
setting's tooltip stays true.
- The server's upload clean-up runs every 6 hours instead of every 30
minutes, to keep the job history readable; idle uploads still expire after
UploadRetentionHours.
- The Unraid template and docker-compose leave CHRONOS_LOG_LEVEL empty or
commented out, and say that setting it locks both log levels, so the admin
panel can change them.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The desktop opened its log files with the default limits and wrote its first
line, which prunes, before Settings › Advanced › Logs were applied. Every start,
and every launch that only hands its file to the running Chronos, deleted logs
older than 14 days and cut the folder to 1 GB whatever the user kept.
AppLogging.Open now builds the sink from the stored settings before that line;
the settings are read again once the launch owns the data folder.
A total below one file deleted each finished file as the next one opened. The
rule now lives in LogFileOptions.TotalBelowFile: the server keeps refusing it,
the desktop raises the total to the file size and its rows no longer offer the
combination.
The desktop log rows threw on negative sizes from an imported or hand-edited
file and showed raw values the files never got; they now show the applied ones.
Upgraded Unraid and compose installs keep CHRONOS_LOG_LEVEL=Information, which
locks both levels. The lock stays; the server now reports which variable fixes
each locked setting (LockedBy), so the panel's tooltip names it exactly and says
to remove it to change the value there. The releases README tells upgraders.
The former-constructor log test no longer fails across midnight UTC.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 8ba7162bd5926d34c5ec4e40e2a2dad063ee19c3)
Settings › Logs › Keep audit showed ServerOptions.AuditRetentionDays, a second
copy of the audit clean-up schedule's age limit. Edits made on Jobs › Scheduled
never reached it, so the panel could say "kept forever" while entries were
being deleted every night. Saving 0 there then changed nothing, because the
endpoint only compared against the stale option value.
- GET and PUT /server/settings now report the schedule's limit in force (0
while the schedule is off). Saving compares against that value. A value sent
back unchanged leaves the server.json reset default and the env lock alone. A
new value sets the schedule and becomes the reset default.
- ApplyAgeAsync also turns the schedule on when it already holds the days but
is off.
- CHRONOS_AUDIT_RETENTION_DAYS is now applied before the scheduler's first
pass, through a new Scheduler.StartAsync overload with a beforeFirstPass hook.
Before, a missed 04:30 run was caught up at start with the stale days, which
could delete entries the variable says to keep. While the variable fixes a
limit above 0, turning the schedule off is a 409 setting_locked.
- Corrected the comments in SchedulerHost, ServerOptions, ServerSettingsStore,
LogSettingsDto, the header of settings.js and ARCHITECTURE.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 490ed286e9f32745174b13b1963d6ec91955196b)
Owner review 2, phase 2 review findings (scheduler core).
- Log.Write caught only IOException. Microsoft.Extensions.Logging wraps
provider failures in an AggregateException, so a log line that could not
be written (in tests: the process-wide sink of a stopped server whose log
folder was gone) escaped JobEngine.RunAsync's catch before the failure was
stored: the job stayed running and the worker faulted. This was the cause
of the intermittent JobApiTests/ArchiveModuleTests failures. Log.Write now
drops any non-fatal sink failure, TeeLogSink keeps a line from the other
sinks, FileLogSink drops a line it cannot write and reopens the file at the
next one, and LoggerSink drops what the providers throw. The scheduler's
loop relies on the same guarantee.
- The daily backup loop (RunDailyAsync, IsDue, Interval, CheckInterval) had
no caller since the index-backup schedule replaced it; it is removed and
the DatabaseBackups summary describes the schedule.
- The first copy after the upgrade no longer waits a day (or for 03:00):
SystemSchedule.LastDone seeds a new row due at once when its work was last
done a period or more before, and both hosts pass the newest copy in the
backups folder for index-backup.
- Back up now (Settings and Archive), the copy kept before a restore and a
backup job that keeps fewer prune to the largest Copies kept of the backup
schedules (DatabaseBackups.KeptAsync), not a fixed three. The four
tooltips that promised three daily copies are reworded (en, it) and their
stale translations deleted.
- New tests for the scheduler loop itself: a tick, Wake, a pass that threw,
and dispose during a pass.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c5ad0c4c3f636129afe5dd1ce039185516da5621)
- SchedulerHost reads archive.json every 10 minutes on its own timer. The archive-scan
runs that used to do it are skipped while a long scan is pending, and the schedule may
be off or daily, so uploads kept a desktop's old folder template or proxy size.
- Every schedule change and run, a skipped run included, is published as a
scheduleChanged event. The Scheduled tab reloads on it, so skipped runs, next-run moves
and other administrators' edits show without waiting for a job.
- The Scheduled tab still draws when the schedule a job links to, or an expanded one, no
longer exists: its runs are dropped instead of failing the whole load.
- Every time on the Scheduled tab (next run, last result, runs) is in the server's time
zone, as its "Times in" line says.
- Audit details name a system schedule after its key (system:<key> · name · ...). The
dashboard and the Logs page show it by its localized name and the recurrence code in
words, as the Scheduled tab does. Older entries keep their recorded name.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c20f573d0bdf1cdcf3a86e9702ac76a4bf9508d9)
Owner review 2, phase 2 (R10) review findings on the desktop:
- Showing the Scheduled tab (and coming back to Jobs on it) reads the
actions' availability again, as does a Run now answered unavailable;
rows and an open editor follow, so turning proxies on no longer needs a
restart.
- A delete the index refuses keeps the row: the failed call no longer
reads as Deleted (the enum's default), so a live schedule never leaves
the page.
- SchedulerReady completes false when the index (or the engine) does not
open, so the tab shows that the schedules do not run instead of an
empty panel.
- A read of a schedule's last job that started before a live change or a
later read is ignored, so a finished job no longer shows as running.
- The editor's Action, Unit and Priority dropdowns follow a language
change, keeping what was chosen.
- Weekly days in the table read from the UI language's first day, as the
editor's toggles do.
- Backup tooltips no longer promise daily copies with three kept (their
translations are dropped for retranslation); two tooltips now name the
real Settings rows (Proxy size; Spazio su disco › Limite della cache).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c137e2c74cddef299b2e4179ef0417fa4977953c)
The audit retention in force ignored the audit clean-up's steps: with the
audit step unticked nothing was deleted, yet Settings › Logs still showed the
age limit. It is now 0 without that step, and setting a limit (Settings › Logs
or CHRONOS_AUDIT_RETENTION_DAYS at start) ticks the step again, so a saved or
fixed retention always takes effect. While the variable fixes a limit above 0,
an edit that drops the step is 409 setting_locked like turning the schedule off.
The admin panel's Scheduled tab disables what the variable fixes (the row's
switch, the form's Enabled and audit step, the age limit) with the locked
tooltip, and points a setting_locked refusal at the field actually refused.
The Copies kept tooltips now say the backups folder keeps as many copies as
the backup schedule that keeps the most; the LastDone and Newest comments
state the real first-copy rule; Keep audit is documented last-writer-wins.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, R6: the web panel manages the library without editing it, so
the engine and the server must delete single photos safely, keep them out of
sync afterwards, and let an administrator restore or finally erase the trash.
- Migration 0008: frame_removals (tombstones by sequence and SHA-256, reason,
replacement); the sidecar gains "removed" (omitted when empty) and frames a
reserved "source"; the indexer writes the tombstones on every sync, so a
rebuild keeps them, and drops a hero frame that is gone.
- FrameTrash: dry run (busy, frames changed, offline, would empty), delete under
the sequence lease with a write-ahead journal that the next writer undoes
after a crash, files to trash/photos/<seq>-<time>/originals with a record,
sidecar without the frames plus tombstones, index sync clearing analyses,
thumbnails and proxies, proxies renamed to follow their frames, follow-up
jobs. Restore re-hashes every file, keeps mismatches in the trash, puts the
same frame records back and drops their tombstones, or files the photos into
a new sequence through the ingest when theirs is gone.
- Project positions on vanished photos are translated by photo and wait as
pending frames, so they come back with a restore.
- Trash entries have a kind (sequence, photos, replaced); emptying is a dry run
with a fingerprint and a new EmptyTrash job (18) that erases exactly the
planned entries, refuses a stale plan and erases replaced originals only
while their replacements still hash right.
- Sync honours tombstones: nothing one side deleted is offered back, local
files are never deleted, replaced photos count as their replacement; the
server answers an upload of a tombstoned SHA-256 as already there.
- Server: sequence thumbnail, photo delete, bulk delete/retag/jobs, trash
list/restore/empty endpoints with their error messages; a verify of
sequences now targets their archive (POST /jobs failed before).
- Desktop trash dialog lists photo entries and empties the trash after a
typed confirmation through the same job.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 35bb56690a1d69eae57153d036e1409201cd73f7)
The web panel now manages the library without editing it: the owner can
browse and view sequences and photos, delete sequences and photos into the
archive's trash, restore or empty the trash and run mass operations, as
R6 asks, on top of the engine endpoints of the previous commit.
- Library page right after the Dashboard: search, Year/Camera/Status/Tag
filters fed by a new GET /api/v1/sequences/facets, sort, cards or list
(remembered per browser), lazy cover thumbnails, Load more by cursor,
multi-select with Shift ranges and "Select all N" of the filter, and a
sticky bar for the selection: Analyse, Proxies, Thumbnails, Verify,
Tags (add/remove), Export CSV (client-side) and Delete (dry run, list
of what moves to the trash, then the move). Filters live in the address,
so Back from a sequence finds them again.
- Sequence view (#/library?id=): inline title, tags, rating and notes,
facts, photos in pages of 500 with content-visibility, a photo viewer
(proxy, arrows, Esc, Exif facts), Set cover, Download original, Delete
photos (typing the count above 20 photos), Delete sequence, renders to
download. No video editing controls.
- Trash view (#/library?view=trash, also linked from Archive): entries,
Restore, and Empty (dry run, list, the localised word typed, the plan's
fingerprint sent back, the job followed to its end).
- Live updates from sequenceChanged and jobState; keyboard grid (one tab
stop, arrows, Space, Shift+Space, Enter, Ctrl+A, Esc); RTL, dark theme.
- GET /sequences takes rendered=true|false for the Status filter.
- ui.js: confirmDialog's typed confirmation by name, word or count, with a
list of what the action concerns; formDialog. api.js: putBytes for the
web upload, which the Library imports on demand (upload.js, optional).
- New web icons from icons.py (Image for the Library, trash, grid/list,
arrows, stars, cover); directional glyphs mirror in right-to-left pages.
- Strings in en and it; tests for the facets (both dialects), the rendered
filter, the menu, the modules and the on-demand upload import.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 029cf334f66cb6fa1265b96a6f8faff2964c11ea)
Owner review 2, R3: the panel can add photos to an existing or a new
sequence without the desktop app. upload.js is a dialog the library pages
open (openUpload({ api, sequence, onDone })): file picker or drag and drop
(folders are counted and left out: whole-folder import stays on the
desktop), per-photo state, a total bar, Cancel that deletes the started
uploads, and a leave-page guard while sending. Each photo is hashed in a
same-origin module worker with an in-house incremental SHA-256 (8 MiB
reads; crypto.subtle cannot hash in pieces), which runs the FIPS 180-4
known answers and a crypto.subtle cross-check before its first hash and
refuses to hash on any mismatch; the server verifies the hash again.
Chunks go through api.putBytes with the session's CSRF header, two files
and two chunks at a time, retrying no answer, 429 and 503; quota, space
and permission refusals stop the run with the server's message, and a
photo deleted from the sequence shows as deleted before.
server/info now lists the photo extensions the archive files, so the
dialog offers and sends only those. The CSP already allows the worker
(worker-src falls back to script-src 'self'); tests pin that, the module
walk follows the worker, and a browser-shaped upload runs end to end
through the cookie session.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c64c60ab8bb41c102182e284177ac04a56bf1058)
The phase 3 packages land together, so the panel's pieces must stay in step:
- Admin files are served with Cache-Control: no-cache and their content
ETag (If-None-Match lists, W/ tags and * honoured). With max-age=3600 a
browser that loaded the panel before an upgrade could run new modules
next to cached old ones for up to an hour; now it revalidates each file
and only what the upgrade changed is sent again.
- The Library's Upload and a sequence's Add photos open upload.js, which
now ships with the panel: the test requires the module (no 404), the
dynamic import and the openUpload({ api, sequence, onDone }) calls.
- Bulk jobs over more than 1000 sequences queue one job per 1000; the
toast now says how many were queued, also when a later chunk failed.
- The live refresh re-reads every loaded row, a thousand per request,
instead of dropping rows beyond the first 1000 back to Load more.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The review of owner review 2 phase 3 found that the photo trash could destroy or
strand originals outside the Empty job and let deleted photos come back.
- A restore into a new sequence stages each original inside its own entry
(<entry>/.restoring), never in a staging folder other restores share or
maintenance sweeps; any failure moves it back, the commit runs to its end once
the file has left, a cancel stops between photos with the record kept true,
and the next restore of the entry puts back what a crash left staged. Nothing
erases a staging folder any more.
- A restore into an existing sequence writes .chronos/restore.pending.json before
its first move; SequenceWriter.ReadLocked settles it (files back into the entry
before the sidecar was written, record rewritten after), cancellation is
checked once before the journal, and a companion that cannot follow puts its
photo back whole. Only an intact frame keeps a trashed copy out.
- A deletion's record keeps a .pending name until its sidecar is written, so the
trash neither lists, restores nor empties half an entry; a failed sidecar
write undoes the moves, and scans settle any of the three journals.
- Photos never hashed are hashed as they go and get their tombstone; a photo
with neither hash nor original blocks the plan (FrameDeleteBlock.Unhashable).
Sidecars rebuilt from the photos, and sequences restored without one, keep
their tombstones; the index drops a tombstone whose content a frame holds.
- Emptying re-reads and re-measures each entry under its lease before erasing.
- Once the sidecar is written a deletion or restore stands when the index cannot
follow (logged; the next scan resyncs it).
- XMP companions are listed once per directory, case-insensitively; a restore
into a new sequence picks a name its companions can follow, and one that still
cannot is kept in the record as a leftover.
- thumbs.pack is re-keyed with the frames on delete and restore, so the queued
pass reuses the thumbnails; the server checks the fingerprint of thumbnails of
frames never hashed too.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 0bb631dd83d082e2569b98d127d827adc2e7f899)
Sync:
- A server frame that has not been hashed is known by content only once it is
downloaded: one this PC deleted (or holds as its replacement) is now deleted
from staging instead of filed again, which also dropped its tombstone.
- An unhashed local original that turns out to be a photo the server deleted
is not uploaded, and the archive verify then writes the hashes into the
index, so the row settles instead of offering Upload for good.
- A tombstone leaves a photo out of the comparison only when its side no longer
holds that content, so a tombstone left beside a held copy does not keep the
other side's copy missing forever.
Uploads:
- StartUploadRequest.Restore (optional, never sent by sync or older clients)
lets an explicit user upload file a photo deleted from the sequence again,
also after the trash was emptied; the completion repeats it with
?restore=true and the ingest drops the tombstone.
- The completion checks the tombstone again: a photo deleted while its bytes
were on the way is not filed (409 photo_removed, upload cancelled); the
protocol client reports that as not sent.
- A tombstone of content a frame of the target still holds refuses no repair.
- Hidden dot names (AppleDouble "._" files) are refused, as the archive
scanner leaves them out.
Web upload dialog:
- Upload again on rows marked Deleted before; the tooltip no longer promises
a trash restore that may be impossible.
- Sends a capture time: the Exif DateTimeOriginal of a JPEG or TIFF-based file
(minimal in-house reader, capture-time.js), else the file's time, so photos
without Exif keep their order.
- Esc is stopped at keydown during a run (Chromium allows one prevented cancel
per activation); hidden dot files are left out; a completion refused while
another one files the upload waits for it; the same photo picked under two
names waits for its first copy.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit d051bcfc351f5a08500ca864a6508576a95492a4)
- frames/delete carries its own request body limit (about 4.8 MB), so the
documented 100,000 ids fit; the server's 1 MiB stopped at about 26,900.
- Restore tells a damaged or foreign sidecar of the target sequence
(409 sidecar_mismatch) from an entry whose files no longer match its
record (422 trash_mismatch, now a TrashMismatchException); frames/delete
answers sidecar_mismatch instead of 500, and 404 when the sequence left
the index between plan and delete, also on the re-plan.
- With the archive offline, the trash list and the empty plan answer
503 archive_offline instead of an empty trash; a read-only archive still
lists and plans but cannot be emptied.
- The empty request is audited as trash_empty_requested: the job checks
the plan again and may erase nothing, so the entry no longer claims an
erase that has not happened.
- API tests for these paths, a named subset emptied, sequence-entry
restore and sequence_in_library, photos restored into a new sequence,
viewer 403 on bulk routes and admin deletes of another user's photos.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit fa35831d55c44746f7f76e0cff262ed6aecf8e72)
Review fixes for owner review 2, phase 3 (R6 Library on the web panel):
- Trash: the worker can end an emptying before the browser has read the
POST's 202, so its jobState arrived while the page did not know the job
yet; Empty then stayed disabled ("being emptied") and no result showed.
The page now keeps the last state of the jobs that ended and looks its
job up there before following it. Any ended job also reloads the list
(an emptying from another tab or the desktop sends no sequenceChanged),
and a Restore answered 404 shows the trash as it is now.
- Sequence: thumbnail, proxy, verify and analysis jobs send no
sequenceChanged, so tiles and the cover stayed placeholders and the
status chips stale. An ended job now schedules one refresh (not pushed
back by the next): the sequence is read again and failed images are
asked for again under a retry address (shared retryImages).
- Library list: Esc, Ctrl+A or unticking every card left the "Select all"
snapshot in place, hiding Select all and stopping the live refresh from
pruning the selection. It is dropped once no selected sequence lies
beyond the loaded rows; Clear filters clears the selection too.
- The sequences' delete dialog lists at most 500 names (blocked ones
first, with their reasons), like the photos' dialog (shared LISTED).
- Admin.Trash.RestoreSequence.Tip promised a SHA-256 check that a sequence
restore never makes (it moves the folder back); it now says so and names
Verify (en, it; no other culture had the key).
- The upload test's name and comments say what it checks: upload.js is
only imported dynamically, not loaded on click.
Tests pin each change in SystemEndpointTests; the pages were also driven
in a browser against a fake API, where the pre-fix modules fail and the
fixed ones pass.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 78f66082fd85543d619375574c82cc63a233b7a8)
The desktop trash dialog sent the "N files stayed in the trash" sentence
through ShowError. ArchiveFailures.Cause has no arm for it, so after a
partial restore the red line and Narrator said "A file of the archive could
not be read or written." The sentence itself appeared only in the tooltip.
The same thing happened to an entry none of whose files matches its record.
- ArchiveDialogViewModel.ShowMessage shows a sentence that is already
localized. The trash dialog uses it for kept files, and its tooltip names
the files kept (six of them, then "+ N more").
- ArchiveFailures.Cause passes FrameTrash's Archive.Error.TrashMismatch
sentence through. It matches the sentence's text because the engine throws
a plain InvalidDataException. Any other InvalidDataException, such as a
sidecar that belongs to another sequence, still reads as a file error.
- Archive.Trash.List, Tooltips.Archive.Trash and Tooltips.Archive.TrashRestore
changed meaning in English: they now cover photo entries as well as
sequences. They are removed from the 36 cultures other than en and it, so
those cultures fall back to English and `i18n check` lists the keys as
untranslated instead of showing the old sequence-only wording.
- The XAML comments describe what the trash dialog and its error line show
now.
Tests: the dialog restores a photo entry and a sequence entry and checks
which rows are left. A photo entry with one tampered file shows the
KeptFiles sentence and keeps its row. An entry with every file tampered
shows the TrashMismatch sentence.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2524a11445c87d37625b01095ef7c2a84a2ee422)
Second fix round of owner review 2, phase 3 (engine, server, desktop).
- A photo never hashed whose original is missing can be deleted again: it goes
into its trash record without a file and without a tombstone (nothing is left
to name), stays listed until Empty erases it, and a restore keeps it with the
reason "no file". FrameDeleteBlock.Unhashable now blocks only a present
original that cannot be read; the API answers it as 409 photo_unreadable
naming the photo, and every block has its own code and message.
- Deleting a whole sequence first settles an interrupted photo deletion,
restore or ingest of it (ReadLocked under its lease), so no journal or half
entry travels into the sequence's trash entry; it refuses while a restore
into it waits for its busy entry.
- FrameTrash.Settle takes the photo entry's lease and leaves the journal for
later while the entry is busy (an emptying), so it never races EraseAsync;
meanwhile no other restore writes its journal over it and scans do not adopt
its files.
- The hashes computed for frames that stay (to find a twin of a deleted photo)
go into the sidecar and index, and only a frame whose first and last 64 KiB
match a deleted photo's is read whole.
- A restore into a new sequence rewrites its record after each photo filed, so
a crash or a database failure never leaves filed photos listed.
- An upload completion no longer has a window before the commit: the ingest
checks the sidecar's tombstones under the sequence lease a deletion takes
(IngestRequest.RefuseRemoved), unless the upload asked to bring it back.
- A restore reports each kept photo with its reason (no longer matches its
record, could not be moved back, already in the sequence, had no file); the
desktop line and the API message say so in en and it, and the tooltip holds
the whole sentence. The desktop tells TrashMismatchException by its type.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 1858f1f450a35fb8383ede8d80ce5f8de9b7ceac)
The upload dialog's completion helper called `api`, which only exists inside
openUpload, so every web upload failed with a ReferenceError at its last step.
complete() now takes the dialog's api. A new test lexes every admin module and
fails when a top-level function uses api without taking it; it flags the old
upload.js.
During a run Esc is now stopped on the document in the capture phase. The old
listener sat on the dialog, so with the focus on the body (Start disables
itself, a click on the dialog's text) a second Esc closed the dialog and threw
the uploads away. The listener is added when a run starts and removed when it
ends or the dialog closes.
A sequence page refreshes after any ended job, because jobState names no
sequence. That refresh now redraws the header only when the sequence changed,
and the renders only when their list did. Stars, tags and renders are redrawn
through redraw(), so the keyboard focus stays put. restoreFocus finds an
unnamed control by its place, not as the first unnamed one. Failed thumbnails
are retried with a doubling wait and at most 8 tries, counted again once the
sequence changes.
The trash page reads the emptying it follows from /api/v1/jobs/{id} on every
load and after the event socket reconnects (api.events now emits
"reconnected"), so Empty no longer stays disabled when the job's end was lost.
A Restore in flight stays disabled across redraws.
The Library list counts cancelled jobs as ended (shared JOB_ENDED). Comments
are corrected in shared.js and library.js.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 641b9cd96b95d523990d1414c2bdead4138c5f4d)
Owner review 2, R7 asks for renaming and moving after import, on the web panel and the
desktop. This is the engine and the server API both UIs build on.
- FrameNaming (Core/Naming) is the one naming context and unique-name rule of a frame:
imports, uploads and Reorganize now produce identical names (behaviour of the ingest and
the import planner unchanged).
- RenamePlanner takes a file template: each step counts its renamed frames, shows the first
three and the frames version they were planned at, and lists what keeps its name (photos
in place outside originals/, never hashed, missing, unreadable sidecar). Names are given
in index order with _2, _3 as filing does; XMP companions follow their photo.
- MassRenamer renames a step's files under the same leases after its folder moved, checks
the frames version, journals .chronos/rename-files.json and moves files in two phases
through temporary names so chains and swaps never meet; then sidecar, index
(FrameRepository.RenameFilesAsync, both dialects) and journal. A failure puts every file
back; a crash is completed by the next writer or the plan's resume, the index following.
Plans a paused or cancelled job holds are left to that job.
- JobKind.Move gets MoveJobHandler: it plans again and applies only the confirmed plan
(fingerprint and frames versions), with progress and checkpoints per sequence.
- POST /api/v1/archive/reorganize: dry run with the plan and its fingerprint, otherwise a
202 move job; validated templates, audited, sequenceChanged reorganized events.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit aae1c3eb18ea932b4a6251c5e2a282b9295a5785)
Owner review 2, R7 asks to rename and move sequences after import, on the web panel too.
The Library's mass bar gets Reorganize… for the selection (every sequence after Select all
without a filter, else at most a thousand ids), and saving a changed folder or file template
on the Archive page offers it for all sequences in the save toast.
The dialog (reorganize.js) has a switch and a field for the folder, file and title templates,
prefilled from the archive settings; each change asks POST /archive/reorganize for a dry run,
one request at a time, and the table shows every step before and after (title, folder, renamed
files with samples, photos that keep their names and why). Apply confirms with the counts of
sequences, folders and photos, sends the shown plan's fingerprint back, and the toast links to
the queued job; a plan_changed refusal plans again. Server refusals land on the field they name.
Toasts can carry an action; the audit entry archive_reorganized reads as a sentence.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 13939dff9a1e8a23ce7802ac38f2ded7fdbc2a74)
Owner review 2, R7 asks to rename and move sequences after import on the desktop too.
The desktop now uses the engine's Reorganize, the same plan and job as the web panel.
- One Reorganize… dialog replaces Rename… and Move… in the Archive manager and Move… in
the Library. It has three templates: folders, file names and titles. Each one has a
switch and is checked as it is typed. Folders and file names start on, filled from the
archive's settings; titles start off as {title}. Renaming only titles is the Titles
switch alone.
- The dry run stays in the dialog and follows the typing. Each sequence shows its folder,
title and first file names before and after. Sequences carried along with a folder are
marked, and photos that keep their names are listed with the reason. A summary counts
the sequences that change, the files renamed and the names kept.
- Apply no longer changes the archive from the dialog. It queues the engine's move job
with exactly the plan shown (its fingerprint), so the work can be paused, resumed after
a restart and followed in Jobs. The job refuses the plan if the archive changed after
the dry run.
- The Library's Reorganize… works on the selected sequences of one archive. The Archive
screen reads the archive again when a move job ends.
- After Settings › Archive saves a new folder or file template to an archive that holds
sequences, a toast offers Reorganize… for every sequence. Its templates are the ones
changed since; a second change made while the toast is up adds to that toast instead of
opening another.
- Strings in en and it. The keys of the old Rename and Move were removed and pruned from
every translation, so the 36 other languages show the new keys as untranslated instead
of keeping "Move".
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 7bbf451f737a71b768dcd70a77b998daaef851f3)
Integrating owner review 2 phase 4a (R7) onto the reviewed phase 3 code.
- RenamePlanner: a sequence already at its expanded folder, or at the " (n)" of it that
filing or an earlier Reorganize gave it, keeps that folder (in the template's case, unless
another sequence holds that exact name). The planner seeded its claimed folders with the
sequence's own, so "2026-09-28 (2)" was planned to "(3)" and back to "(2)" by the next
run; a second Reorganize with the same templates now plans nothing.
- MassRenamer: each step settles what a crash or a busy trash entry left in its sequences
(SequenceWriter.ReadLocked) and waits, as a sequence deletion does, while a restore from
the trash is not settled (FrameTrash.EnsureSettled), before its folder or any file name
changes: that restore's journal names files by the names they had. Trash records keep
restoring after a Reorganize: into the sequence where it is now, under the record's own
name made free (_2) with its companion following.
- Jobs.Kind.Move and Admin.Job.Kind.Move now mean "Reorganize": their old "Move archive"
translations are removed from the 36 other cultures so they are translated again.
- Tests: a second run plans nothing (planner and archive), companions found alike by the
trash and Reorganize whatever their case, a photo deleted before a Reorganize comes back
beside the new names, a Reorganize waits for a busy restore and settles it first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The v0.1.0-rc.5 release build failed on the shared runner when the last renewal
timer ran 75 ms late: the test now checks that the expiry moved on.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, phase 4a review findings on the renamer.
- File rename recovery is safe to run again from wherever it stopped: once every
file is at its temporary name the journal says phase 2, as Run does, so a second
recovery (after a failure, a crash or a sidecar that could not be written) never
moves a file that reached its new name. A new name something else took meanwhile
is never written over: that photo and its companions go back to their old names,
or to the first free _2, _3, recorded in the journal before they move, and the
frame names where its photo is. A journal is never deleted while a temporary file
of it is still there.
- Every check that can refuse a step runs under the step's leases before anything of
it moves: where its sequences are, strangers inside, its new folder taken since the
plan (a restore, an upload), a sidecar of a newer format, a title edited since the
plan (compare-and-set against the planned from-title, sidecar and index), and its
file renames, compared by a digest of every move at the planned frames version (a
verify that hashes photos does not bump the version). Once the folder moved, every
index row follows it before any file is renamed, and a photo in use or files found
changed keep their names: the step completes.
- The same checks run up front for a held plan, so its retry either fits or is given up.
- A failed move job holds its plan, as a pause does: an archive open no longer
applies the rest unasked; only the job's retry does. File renames a step left
half-way are still completed at an archive open.
- Each sequence changed is told as its step is journaled, so a pause or a failure
never keeps it untold; the plan's journal keeps the tally of every run, so the job
log counts the whole plan.
- A selected sequence deleted while the job waited is named in the log and the plan
refused with the localized stale-plan error, not a raw ArgumentException.
- The dry run renames no file of a newer-format sidecar.
New log lines and error (en, it): title and file names kept, file names kept because
a photo was in use.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 1d1c888120edd709dbb5341c1922bf85085c4857)
Reorganize with the archive's own templates planned renames and moves for
photos just filed, and some templates could strip extensions, hide sequences
from scans or stall a dry run. Owner review 2, phase 4a findings.
- Filing and Reorganize share one context: uploads and imports name every
photo with the sequence's camera and lens (its first photo's, or the
creator's hint), an upload's folder from its first frame in the new
sequence, and a missing capture time from the sequence start instead of
the current time. The planner expands folder and title templates from the
first frame in the sidecar ({name}, {ext}, {iso}...), never today's date.
- Titles expand as text (ExpandText): "Paris: night" stays as typed.
- A sequence whose sidecar cannot be read (torn, another sequence's) keeps
its folder, title and names, listed with why, and so does every folder
around it; the dry run reads every sidecar, nested ones included.
- Kept never gives one folder to two sequences of a plan whatever the case,
and a case-only move onto another folder is refused instead of taken as
done.
- Shared template rules (TemplateRules) for the server's Reorganize and
archive settings and the desktop's fields: a file template must keep the
photo's extension ("{n}{ext}" refused) and tell a session's photos apart;
a folder template may not write a level scans skip (a leading dot,
originals, proxies, exports). Levels a title gives are escaped with "_".
- {ext} comes from the file, or from the original name when the file lost
a photo's extension, so a Reorganize can put it back.
- Unique names cost linear time (UniqueNames) with the same names as before.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 6c734777e01476881a3f34b3188571cc3f7150ab)
A Reorganize step that moves a sequence folder carries its exports/ with it, but only
the sequences and frames rows followed: renders.output_path kept naming the old folder,
so the server answered 404 for the export, Get/Send exports and Reveal lost it, and no
scan or trash restore could repair it. RenderRepository.RebaseFolderAsync now rewrites
the archive-relative output paths of the step's sequence in the same transaction as the
frames (idempotent on resume; absolute outputs and the archive root are untouched).
Writers that read a sequence row before taking its lease wrote into the folder a
Reorganize had moved meanwhile, creating it again (project.json from the editor or a
sync, a thumbnail pack) or failing on its missing sidecar. They now take the folder from
the index row read under the lease (SequenceWriter.FolderAsync): the editor's save
refuses with FramesChangedException and reloads at the new folder, FramesCurrentAsync
reports a moved folder, and the sync apply, project store, thumbnail pass and its
status, decode tiers, analyses, verify, info edits, ingest, duplicate flags, pack
compaction and photo restores write where the sequence is now; a photo deletion planned
before the move is refused as stale.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit be28d8acf0d96012c94a266f8af61e9bbafaa28d)
An all:true dry run reads every sidecar and photo folder of the archive inside
the request, and the confirm planned the whole archive again before answering
202. The server now keeps each dry run's plan for five minutes (eight plans at
most) by archive, selection, templates and a stamp of the archive's index rows:
the same dry run again and its confirmation take the kept plan, and any change
the index records (an upload, an edit, a move, a scan, a verify) gives another
stamp and a new plan. A change made on disk alone is not in the stamp; the move
job still plans again and refuses a plan that no longer matches.
Server tests now cover an all:true apply around a sequence already in place, a
real plan_changed after an upload, a move job paused between two sequences and
resumed, archive_offline, job_unavailable, more than 1,000 ids and the kept
plans themselves; a Data test covers the index stamp.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 71bb53fbf8eb7d0327ea692d046634b12f8d37e9)
Review of owner review 2, phase 4a (R7): the Reorganize dialogs of the desktop and the web panel.
Desktop
- Clicking Apply first takes the focus from the template field, which committed it and started
a dry run identical to the one on screen: Apply turned off under the click. A commit now plans
only when the templates differ from the shown plan (or the last dry run failed).
- The Settings toast's Reorganize… disposed whatever dialog the Archive screen had open, so a
running Delete stopped without being asked. An open dialog now stays and its archive is not
switched; Reorganize says it waits and opens once that dialog closes, with the archive's
templates read again and every part the toasts offered meanwhile.
- Each Settings toast takes its own archive's offer (one pending offer per archive), and a toast
gone early (dismissed, pushed out) lets the next change of that archive raise its own toast:
Toast.Closed now says when a toast leaves the screen.
Web panel
- The Library sends the selected ids up to a thousand. all:true is used only above that, when
the selection is exactly what Select all fetched without a filter and the archive has not grown
since, so a sequence unticked or added later is never reorganized; otherwise the toast asks to
select again.
- The preview's "before" of an untitled sequence is its old name, not the new title twice.
- A dry run of the same request answering during the confirmation no longer drops the confirmed
apply; a plan that really changed is shown and said (Admin.Reorganize.PlanChanged).
- Enter in a template plans at once (the form never submitted on Enter).
- The confirm tooltip and the module header no longer say the moves are verified: moves and
renames are not hashed.
Strings in en and it; the reworded key exists in no other culture.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit bed718fb5af2ef69943fd348690c689259872a34)
A Reorganize with a file template failed its job at the step of a sequence
a camera was still uploading into, and its retry gave the rest up. Photos
changed since the plan now never refuse a step: that sequence keeps its file
names (FilesKept), its folder and title change as planned, the other steps go
on and the job ends with ReorganizeKept. The fingerprint, the job's
confirmation and the check under the leases pin file renames by their digest
instead of the frames version, so photos filed under the names the plan gives
them no longer make a dry run or a queued job stale.
- A step whose folder or files a template names after {title} checks the
title as a retitle does (RenameStep.NamedByTitle): no name comes from a
title edited since the plan.
- Recovery sends a photo that already took its new name back together with a
companion whose new name was taken, so the two never end up apart.
- ArchiveService.OpenAsync logs a NewerFormatException from resuming a plan
and keeps its journal, so a server still boots.
- Once a step's folder moved, every index row of the step follows it even
when a sidecar cannot be read or written; the step then fails for a retry.
- Job log lines and errors give the real reason for files kept busy (in use
or a new name taken) and for a sidecar of a newer format (new Newer
outcome; strings en and it).
- A plan an archive open completes tells sequenceChanged; the docs that
promised more than that are corrected.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit f8554b8af0828ab9b0ff128e694abacdd53e6fd7)
Second fix round of owner review 2, phase 4a (planner findings).
- A sequence keeps a folder that differs from its own in case only while no
other folder holds that exact name (RenamePlanner.ExistsExactly, every level
compared exactly). On a case-sensitive file system a stray "Trip (2)" beside
the sequence at "trip (2)" no longer gives a case-only step that MoveFolder
refuses at every archive open: the plan gives "Trip", and a plan whose
target appeared since is refused under the step's leases before anything
moves (or dropped when it resumes). A change of case in an outer level no
longer looks like two folders on Windows.
- A file name longer than 200 characters is shortened before the ".{ext}" the
template ends with, never through it, so a long title never strips the
photo's extension.
- The archive engine's own settings check applies the template rules the
server and the desktop apply (a folder scans skip, a lost extension, names
that repeat), so archive.json can no longer take such a template.
- The server's invalid_template answer names the rule after the field
("fileTemplate:extension") with the desktop's sentence as its message; both
admin panels show it on the field.
- FrameNaming keeps only the naming overloads production uses.
- Comments about Unreadable say the whole sequence stays as it is.
- Tests pin filing against Reorganize: an upload without a capture time, a
card's second session with {session}, a duplicate skipped mid-session, and a
whole folder of two cameras named with the first one's camera.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 50fe59aec1e180daa1733bcb951892a79dceba6c)
Second review of owner review 2, phase 4a (Reorganize), cross-cutting findings.
- A second index of the archive (a desktop sharing a server's archive, or a folder moved by
hand) moved the sequence row at its next scan but left renders.output_path at the old
folder: the export answered 404 there. The scan now rebases the render rows in the same
transaction when it finds a sequence in another folder.
- The rebase covers every render of the archive under the old folder: the sequence's own
exports always, and another sequence's export saved inside it (through the Export folder
picker) when its file moved with the folder. That check keeps the exports of a sequence
that took the old folder since (a later Reorganize on the other index) where they are. A
change of case only counts as a move.
- The desktop now tells an open editor after each Reorganize step
(ArchiveServiceOptions.SequenceChanged -> AppServices.SequenceReorganized), and the editor
reads its sequence again where it is now, so frames no longer decode blank until the next
save. LocalSequenceSource.LoadAsync also requires the same folder on both row reads, so a
move that commits during the frame listing is never taken as current.
- Writers that wrote without the lease, or trusted a row another index had moved, could
create the old folder again. A proxy sent by a client is now filed under the sequence's
lease into the folder the index has then, and a gone sequence or folder answers 404
(sequence_busy 503 after the lease wait). The server files a render a client or render
node sends under the lease (ArchiveService.UnderLeaseAsync). "Save both" keeps its copy
under the lease. The proxy pass holds the thumbnail lease, as the thumbnail pass does. The
deep analysis opens its checkpoint under the sequence lock only while the folder is still
there, and a pass whose folder another process moved records nothing (the job logs
Advisor.Log.FramesChangedElsewhere). Editor saves and sync applies refuse when the folder
is gone.
- ARCHITECTURE.md no longer claims more than this: a render of another process whose folder
moves while it runs is still not stopped.
- ArchiveVerifier.FlushAsync: corrected the comment. A move keeps each file's stamp, so only a
check that found the file missing no longer applies.
Tests cover the scan path with a later swap into the vacated folder, another sequence's
export inside a moving folder, a photo deletion refused when the folder moved while it
waited for the lease, proxies sent and made after a move, Save both during a move, a deep
analysis whose folder another index moved, a render filed after a move on the server, and
an open editor reloaded by a Move job.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c857b98f795b22956c060f1c5acf4d94b6d1c994)
A kept dry run was keyed on a stamp of every sequence row of the archive,
updated_at and verified_at included, so any upload, ingest status write,
verify or tag edit anywhere invalidated it and the confirm planned the whole
selection again. The plan was also bound to the request, so a proxy cutting
the request off cancelled it and a retry started over.
- The stamp (SequenceRepository.GetStampAsync) now hashes only what the
planner reads from the index: every row's id and folder (collisions and
what a moving folder carries), the planned rows' title, first capture,
camera, lens, photo count and frames version, and the titles of the rows
inside a planned folder. With all, every row is planned.
- ReorganizePlanCache makes a plan on the thread pool with the host's
stopping token, once per key for concurrent requests; a request cut off
only stops waiting, and the same request again waits for the plan or
takes it. Refusals and failures are still not kept.
- A kept plan is dropped by its own timer five minutes after it was made
(and never used past that), instead of staying until the next request.
- The protocol and endpoint docs say that plan_changed answers changes the
index has; one made on disk alone is found by the job, which fails and
changes nothing. The Capacity doc no longer claims a step per sequence.
- Tests: what the stamp follows and ignores, a kept plan surviving an upload
elsewhere and a verify, one plan for concurrent requests and after a
cut-off, the timer, an all:true apply carrying a nested sequence beside a
blocked-only one, the first sequence told before a pause. The
no-archive-module job_unavailable test expected a folder the planner no
longer plans without a sidecar; it now expects the unreadable step.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 7e01a4f85fe4b880ddd98a481fc8591649cec254)
A Reorganize step whose photos changed after the plan kept its file names but still moved its folder and wrote
the title the plan had computed from the old first photo, so a trashed first photo or an earlier photo filed
since left the sequence named after a photo that is no longer first. The plan now journals its folder and
title templates, and under the step's leases each folder move or retitle is expanded again from the settled
sidecar: it is applied only when it gives what the plan gives (the folder itself or its " (n)"); otherwise the
sequence stays as it was (Dropped, "changed after the plan"), or keeps its title and file names when an
interrupted run moved its folder already (TitlesKept). Plans journaled before this change are applied as made.
A Move job that ended failed with sequences kept, or whose held plan was given up, kept its plan:<id>
checkpoint after the plan's journal was gone, so a retry logged "completed when the archive was opened" and
ended done. Such a job now saves the checkpoint "applied": a retry plans again and applies only a plan that is
still the one confirmed. A job that succeeds keeps plan:<id>, so a crash before it is marked done still finds
the plan completed.
Sequences a folder was to carry when that folder stayed (dropped, its title edited, its names no longer given,
or a newer sidecar) were reported as "changed after the plan", and a newer-format carrier failed the job with
ReorganizeKept. They are now a separate outcome, CarriedKept (journaled), logged with the new
Archive.Log.ReorganizeCarriedKept (en+it) and not counted in the job's error, which follows the carrier's own
reason.
When a step's sidecar cannot be read or written after its folder moved, every sequence of the step is told
(sequenceChanged "reorganized") before the failure is thrown, since the retry that would tell them may never
come.
Tests: Core APlanKeepsItsTemplatesSoTheNamesOfAFirstPhotoNoLongerFirstAreTold; Data
AFolderOrTitleNamedAfterAPhotoNoLongerFirstIsNeverGiven, ARetryOfAJobThatKeptSequencesPlansAgain,
ASequenceAFolderWasToCarryIsToldItStayedWithIt, AnArchiveOpensWhenAnInterruptedRenameMeetsASidecarOfANewerFormat,
AResumedStepWhoseFolderMovedKeepsATitleEditedSinceAndTheNamesFromIt, and
AMovedFolderWhoseSidecarCannotBeReadThereHasItsIndexRowFollowAndIsTold, which breaks the sidecar with a
relative symbolic link instead of a read-only file, so it also runs on the Linux runner as root.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 130701afab224d47ea066eb7cc8debb16d1fb432)
Reorganize refused a case-only folder target whenever a folder of that exact
name was on disk. On a case-insensitive file system that folder can be the
sequence's own, when the disk spells it as the template does and the index
does not (renamed in Explorer, or an outer level a change of case left as it
was), so the plan gave a needless " (n)" folder. RenamePlanner.Kept now
refuses only when both exact names exist, the condition MassRenamer.TargetTaken
and MoveFolder already use.
ArchiveSettings.Problem held both templates to the template rules on every
UpdateSettingsAsync, so an archive.json saved before the rules made every
desktop Settings > Archive edit fail. A template the file already holds is now
only checked for being usable; a template the edit gives, and both templates
of a new archive, meet every rule. A broken rule throws TemplateRuleException
(an ArgumentException naming the field), and the desktop toast shows that
rule's sentence instead of "Something went wrong".
Also corrects comments that ignored RenameBlock.Unreadable (the whole
sequence stays as it is) and the ARCHITECTURE Naming row.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit ac7a0c36df83b6d43651caf0225c530466242c97)
Third fix round of owner review 2, phase 4a (Reorganize), cross-cutting items.
- Server render filing now runs under the sequence lease, so it can meet a busy
sequence or an offline archive. Both completions (client render uploads and
render-node results) used to answer 500 and leave the upload stuck in
Committing until a restart. They now answer 503 sequence_busy or
archive_offline, which clients retry. The upload goes back to receiving with
its part file and the node keeps its job (UploadService.ReceiveAgainAsync).
- Save both: when this PC's copy cannot be written (another index moved the
folder), the server's version is no longer applied, even if this index's scan
relocates the row before the apply would run. A copy that has to be dropped is
deleted from where the folder is now, as a best effort.
- Export rebase on a folder move (scan and Reorganize): the sequence's own
export follows the folder unless its file is still at the old path and not at
the new one. A file written into a re-created old folder therefore keeps a row
that finds it, so the file is never stranded.
- A render job refuses to start when its folder is not where the index has it,
which also stops it from re-creating the old folder. Renders fetched by sync
are now filed under the sequence lease into the current folder, or not at all
(new string Errors.Archive.FolderMoved, en and it).
- The proxy pass holds the thumbnail lease one batch at a time (a quarter of
the lease wait), then lets it go for longer than a waiter's poll and reads
the folder and sidecar again. Before, another process's Reorganize, sequence
deletion or pack compaction could wait out its lease wait and fail. Updated
the stale comments on that lease and ARCHITECTURE.md to match.
Tests cover each fix, and each new test fails with its fix reverted. Also
covered: proxy store and pass in a moved folder, RenderStore with the folder
gone, Take server with the folder moved, and an editor save with the folder
moved.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 811509d32a118ed50ad10d47d4b002e534da9d77)
The kept-plan stamp left out whether a planned sequence's photos are hashed.
A verify writes frames.sha256 (and only status and verified_at on the row)
without another frames version, so after verifying never-hashed photos the
same dry run kept answering "verify the sequence first" for up to five
minutes, and its confirmation queued a job certain to fail.
- SequenceRepository.GetStampAsync adds, for every planned sequence, how many
of its photos have their hash in the index (one grouped query over the
archive with all, the selected ids in batches of 500 otherwise).
- ReorganizePlanCache keeps a refusal (nested_target, not_found) as it keeps
a plan: for the same stamp and templates it is the same, and a long plan
that ends refused after a cut-off is no longer planned again on every retry.
Failures are still not kept.
- Planning is bounded: at most two plans are made at once, the others wait for
their turn; a plan still being made 15 minutes after it was asked, let go at
capacity, or when the server stops is cancelled, and whoever waits for it
gets 503 plan_dropped. A read that hangs keeps its turn until it returns but
no longer keeps its waiters.
- The Capacity summary now says what eviction does (the kept plan asked for
first, else the plan being made asked for first); the stamp, protocol and
endpoint docs say that a verify hashing photos is a change the plan reads.
- Tests: a scan's photos, verified, are planned again and renamed by the job;
the stamp follows hashes of planned photos only; refusals kept, failures
not; turns, eviction and deadline of plans being made, a hung read included.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 56582df45453fc555e525f19de7de1803204d12c)
A selected sequence nested in another selected sequence's moving folder moves
out first. When the templates no longer gave it its folder (its first photo
gone, or an earlier one filed), it stayed inside, and the outer step then found
it as a stranger: StaleRenamePlanException at every retry, the plan held forever.
- A moving folder now takes along the sequences of earlier steps that stayed
inside it (their index row still there): locked, moved and recorded with it,
keeping their title and file names. They are reported TitlesKept instead of
Dropped; a carried sequence whose carrier stayed is simply changed (or
TitlesKept when it was to change more than its folder); Newer stays Newer.
RefuseStaleAsync exempts exactly those, so a held plan either fits or is given up.
- MoveJobHandler: a journal not found on an offline archive tells nothing. A
failed job keeps its plan:<id> checkpoint instead of becoming 'applied', and a
retry while the archive is offline fails with "archive offline" instead of
logging ReorganizedEarlier and ending done.
- The Fit.Names warning now says what happens to the folder (moved already,
carried, or not moved to the planned one); stale ApplyAsync, RefuseStaleAsync,
FitAsync and job docs corrected.
Tests: the nested case (fresh run and held retry, three levels), the same through
a held job, a carrier named otherwise with a carried sequence, Fit.Names on a
resumed step whose folder moved (held and not), and an offline retry that keeps
its plan and completes it once the archive is back.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c5ffc87f1a3900442920693763fd04d28cb43aee)
The web panel's archive settings save checked both request templates against
every template rule before the engine ran, so an archive.json saved before the
rules made every save fail, even of the name or proxy size. Only a template that
differs from the stored one is now held to the rules, as ArchiveService already
does, and a TemplateRuleException from the engine (archive.json changed since the
form was read) answers invalid_template with its rule instead of archive_policy.
Exports follow a moved folder correctly in two more cases. Image-sequence exports
are folders, so the rebase now tests Path.Exists instead of File.Exists. An
export left at the old path no longer pins a sequence's row when that path now
belongs to another sequence (its sidecar holds the old folder, or its render row
names the path); the row follows to the new path, so it never names another
sequence's file.
RenderStore throws FolderMovedException when the sequence is not in the folder
the index has. That is transient until this index's next scan, so client render
uploads and render-node results now answer 503 folder_moved, keep the part file
and the node's job, instead of failing them for good with a wrong reason.
Save both and Take server refused because the folder moved now say
Errors.Archive.FolderMoved (try again after the next scan) instead of the
"changed again, choose again" sentence, which repeated until a scan.
Doc wording: the ReorganizeDialogViewModel summary covers a sequence kept whole,
and RenamePlanner.Plan's existsExactly says the own folder is found under at most
one of the two names.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit d898798657197d48f4e19b7f776003eb2fc441b5)
An archive open lists the pending rename plans; one journal that was not valid JSON threw out of
ArchiveService.OpenAsync, so the archive (and the server, at boot) did not open until the file was
removed by hand. It is now logged and left in place; its own job fails with the reason instead of
planning again over a half-applied plan.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Round 4 let every row under the old folder follow when that folder holds another sequence
now. When the scan took the new holder first, its own row (already rebased into the old
folder) then followed the moving sequence too and named that sequence's file, leaving its
own export without a row; a second scan did not repair it. Only the moving sequence's own
rows now follow because the old folder is taken, and a row of the sequence holding the old
folder never follows: its export is in its own folder whatever the other one took along
under the same name. The rebase callback now gets the owner of each row.
Writers that file into the folder the index has for a sequence checked only that the folder
existed. After another index moved the sequence away and another one into that folder, Take
server wrote the server's settings into the other sequence's project.json, Save both wrote
this PC's copy into its .chronos, and a render sent for the sequence was filed among its
exports. SequenceFolders.Holds treats a folder whose sidecar names another sequence exactly
like a missing one, and every such writer asks it: settings sync and conflict resolution
(Errors.Archive.FolderMoved), Save both's copy and its clean-up, server render filing (503
folder_moved, the upload kept), export downloads, render jobs as they start, proxies sent and
proxy passes, the deep analysis checkpoint and the editor's project save. A thumbnail pass
refuses a sidecar of another sequence before it opens the pack.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit b406a4f6a9a7a3121e9e40289663fb62ee31948e)
The phase 4a docs were written before the last two fix rounds landed. They
now describe the code at 8c2b9f1b: a sequence left as it was inside a moving
folder is taken along instead of keeping that folder in place; a held plan on
an offline archive keeps its plan and fails as offline; render filing answers
503 folder_moved; a rebase never moves the rows of the sequence that took the
old folder (with its known limitation); every writer refuses a folder another
sequence holds (SequenceFolders.Holds). Three DECISIONS rows added, six
updated; five fix rounds in STATUS and the request.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 31d479c5f4dd0b7076b39331246815e95895a1fa)
Round 5 stopped clearing "behind" for rows of a third sequence (neither the one moving nor the
one now holding the old folder). Such a row, an export one sequence saved in another's exports
through the Export folder picker, then stayed at its old path whenever the sequence that moved
into the folder brought an export of the same name, and named that sequence's file (Send exports
would upload it). A file at the old path is never "behind" while the old folder holds another
sequence: it is that sequence's, so every row other than the holder's follows its file.
A resumed render job deleted the output its crashed attempt was writing at the absolute path in
the checkpoint. After another index moved the sequence away and another sequence into the folder
it left, and this index scanned, that path named the other sequence's export. The checkpoint now
keeps the sequence's folder when the output was chosen; a pending output there is rebased into the
folder the sequence is in now, one in the sequence's current exports or outside the archive (an
export folder chosen on a client) is discarded as before, and one anywhere else in the archive is
left alone (the entry renders under another name). Older checkpoints, without the folder, only
discard in the current exports.
Download originals put an original flagged missing back at the path read before the transfer,
with no lease and no check of the folder: after another index moved the sequence, it recreated
the folder it left or filed the photo among another sequence's originals. The restores now run
after the transfers under the sequence's lease, in the folder the index has then, which must hold
the sequence (SequenceFolders.Holds), at each frame's path read under that lease. Otherwise
nothing is restored, the copies stay staged for the next attempt and the job fails with
Errors.Archive.FolderMoved after its other work.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit ad46ef68180845de4b9b605a4ce2529a148c6f13)
Owner review 2, R7 asks for mass conversion after import on the web panel and the desktop,
with a choice at every run between Replace and New sequence. This is the engine and the
server API both UIs build on.
- Core/Conversion: ConvertOptions (JPEG 4:4:4 at quality 1-100, default 95; TIFF-16 sRGB
Deflate with the predictor; linear DNG, the archival choice; converted names keep the
stem and take the target's extension in the old one's case). FrameConverter decodes at
the native tier only, encodes with the in-house writers, writes Exif from the sidecar
(capture time to the tick, offset, exposure) and the original (camera, serial, lens,
modes, GPS), hashes the bytes as made, writes atomically and verifies: read back, the
metadata again, a decode by the server's decoders. ExifWriter now writes the exposure
program, metering mode, flash and white balance. ConvertPlanner: convertible frames,
skips with reasons, size estimates per pixel, the plan's space and fingerprint.
- FrameTrash.ReplaceAsync swaps the files of frames in place: same ids and indices, the old
files and their XMP companions into one Replaced trash entry (records, replacement
hashes, a copy of analysis.json), tombstones aliasing old content to new, proxies of the
swapped frames dropped, under .chronos/replace.pending.json, which the next writer undoes
or completes. Restoring a Replaced entry swaps back while every converted frame is
unchanged (the converted files become a Replaced entry in turn), else the originals come
back as a new sequence.
- MassConverter and JobKind.Convert (19): the dry run (busy, offline, unreadable, space
against ArchiveServiceOptions.FreeSpace), stage A converting into
staging/convert-<job>/ in parallel with each source re-hashed and each staged file
appended to journal/convert-<job>.staged, stage B per sequence all or nothing under the
lease at the planned frames version: Replace, or a new sequence through the ingest with
the source's tags, rating, notes and project. Resumes keep verified staged files; a
sequence changed, busy or with a failed photo is left as it was and fails the job at the
end, the journal kept for a retry.
- POST /api/v1/archive/convert: dry run with the plan, its space line and fingerprint, or a
202 convert job; formats the server cannot read at full resolution are skipped as
convert_on_pc; validated, audited (archive_converted), sequenceChanged converted/created.
The server measures the space volume for the check.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 809210d924cfc3f597ecdea26106fb3ff62d3762)
(cherry picked from commit e13d4c0bb1bd9441933b6f3e5b6220e865a7228c)
Owner review 2, R7 asks for mass conversion after import on the web panel too, with what
happens to the originals chosen at every run. The Library's mass bar gets Convert… for the
selection (every sequence after Select all without a filter, else at most a thousand ids,
the same rule as Reorganize, now one helper).
The dialog (convert.js) offers the format (linear DNG, the archival choice, first), the JPEG
quality (shown for JPEG only, 1-100, checked on the field) and the mode, Replace or New
sequence, never preselected, each tooltip saying what happens to the originals. Every change
asks POST /archive/convert for a dry run, one request at a time and debounced while typing;
the table shows per sequence the photos converted, the photos left as they are with why
(what blocks the whole sequence first), and the size before and after, then the totals and
the server's space line. While no mode is chosen the table is planned as New sequence (what
converts does not depend on the mode) and Apply waits; choosing Replace plans again, since the
fingerprint names the mode. Apply confirms Replace by typing the localised word, New sequence
with a plain confirmation, sends the shown plan's fingerprint back and links the queued job;
plan_changed, not_enough_space and nothing_to_convert plan again. Server refusals land on the
field they name.
The trash says what Restore does to a replaced entry (the originals swap back while their
conversions are unchanged) and toasts it; the audit entry archive_converted reads as a sentence.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2a09572e3e67ef95a931333c35cd3bb1e818db71)
(cherry picked from commit 1d71a18fa112a7cb39e3e7ced7d7234230eb4453)
Owner review 2, R7 asks for mass conversion after import on the desktop too, with a choice at
every run between Replace and New sequence. The desktop now uses the engine's conversion, the
same plan and job as the web panel.
- Convert... in the Archive manager's mass operations (the set) and the Library's mass bar (the
selection of one archive; server cards are left out, two archives are refused with their own
reason). The dialog has the format (JPEG, TIFF 16-bit, Linear DNG, the archival default), a
JPEG's quality (1-100, 95) and the mode, which starts unchosen at every open: Apply waits for
it. Each choice has a tooltip that says what becomes of the originals.
- The dry run stays in the dialog and follows the choices: each sequence with its photos and
sizes before and after, the photos that stay as they are with why, the sequences left as they
are (busy, offline, unreadable), a summary and the free space line; a volume without the space
blocks Apply. The mode does not change what converts, so choosing it plans nothing again.
- Apply asks to type the number of photos a Replace replaces, then queues the convert job of
exactly the plan shown; New sequence leaves the originals as they are and asks nothing.
- When a Replace job ends, its toast offers Undo: for each sequence it converted, the newest
Replaced trash entry made while it ran goes back (a sequence changed since gets its originals
as a new sequence). Undo runs once and never from the Windows notification.
- The Library and the Archive screen read the sequences again after a conversion; --capture
renders archive-convert from a sample plan.
- Strings in en and it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 275469284f895fc92e2569339809e18bf59d1d6a)
(cherry picked from commit 76ba41f58983275ae4b1478edd403efb11da7c79)
Phase 4b was built on phase 4a before its review fixes. Integrated on the reviewed 4a, the
conversion now follows the same rules as filing and the other writers.
- Names: a converted file is named as filing names a photo of its sequence (FrameNaming: the
archive's file template, the frame's context in the sequence with its camera, lens, number
and title, {name} the card's, {ext} the target's, a long name keeping its extension).
Replace through ConvertOptions.FileName; New sequence through the ingest itself
(StagedFrame.NamedAs), which numbers and names the copies in the new sequence. Names stay
unique against every file present, those leaving included, so a Replace never moves onto a
file; a test pins a stray file that keeps its bytes.
- Leases: stage A starts from the sidecar settled under the sequence's lease where the index
has it then (SequenceWriter.ReadLocked), and FrameTrash.ReplaceAsync reads the row again
under the lease, so a folder a Reorganize moved meanwhile is followed, never made again.
A Reorganize the archive waits for keeps the conversion off its sequences (pinned).
- Journals: the replace journal is settled with the others. MassRenamer steps, restores into
a sequence and sequence deletions wait for an unsettled replacement as they wait for a
restore, and so do photo deletions, whose frames version the recovery reads
(FrameTrash.EnsureReplaced); a scan settles it and reconciles nothing meanwhile; a restore
settles its sequence's replace journal first, at the folder the index has under the lease.
- The convert job tells each sequence converted or made as it completes, as a Reorganize
tells each step, so an editor open on it reads it again while the rest of the job runs.
- Desktop: JobKind.Convert gets its row in the settings' job priority list. A click on Apply
that commits the quality no longer starts the same dry run again under the click (as 4a
fixed for Reorganize).
- Panel: a dry run answered during the confirmation with the same plan no longer drops the
confirmed Apply; a different plan is shown with Admin.Convert.PlanChanged (en, it).
- Tests: TrashDialogTests.EmptyQueuesTheJobOfTheConfirmedPlanOnly waits for the command to
end before running it again (a running AsyncRelayCommand ignored the second Execute).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2e0d1d6dcc10575734970bb9c77749f00777c859)
Phase 4b review, codec findings. A Replace makes the converted file the
photo, so a conversion must not lose what the original held, and the dry
run must promise only what the job will do.
- Linear DNG from a conversion is scene-referred: the pixels are stored in
linear ProPhoto primaries (colours outside sRGB stay positive) and
divided by the power of two that brings their peak under the white
level (at most 4 stops), with BaselineExposure giving it back and
ColorMatrix1/ForwardMatrix1 describing that space. Highlights a RAW
develops above 1 and its wide-gamut colours now read back as written.
Exports keep the clipped linear-sRGB DNG.
- A conversion reads with the managed decoders first for every format they
read natively (RAWs developed at float precision, as on the server) and
with WIC only for what they cannot. A RAW only WIC's Raw Image Extension
develops (8 bits) is refused for TIFF-16 and linear DNG and planned out
as "eight_bit"; JPEG still converts it. Providers say so through
IImageDecoderProvider.DevelopsRawAt8Bits.
- The original's colour space is kept: a JPEG (APP2) or TIFF (tag 34675)
carries its ICC profile, with the values unchanged; a linear DNG gets the
values converted through a matrix/TRC profile; a gray profile converts
to sRGB. Exif Adobe RGB (uncalibrated + R03) and HEIF nclx P3 get an
in-house profile. A space nothing here can keep (CMYK, a lookup-table
profile into a DNG, uncalibrated without R03, HDR nclx) is planned out
as "color_profile". New in-house ICC parser/writer and header reader
for JPEG, PNG, TIFF, HEIF/AVIF and WebP.
- The planner asks every file, whatever tier was recorded (unknown before
the light analysis, or by another host), with the conversion's decoders,
headers only and eight at a time; a RAW the server cannot develop is
"convert_on_pc" in the plan instead of failing its sequence. Photos a
target cannot hold (a JPEG side above 65535, more samples than one
buffer) are planned out as "too_large", and an overflow fails its photo
rather than the job.
- A photo that fails reads in the job log as one catalog sentence by cause
(Archive.Convert.Failed.*), the file named once; the exception's English
text goes to the diagnostics log only.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 0ca1e91ea09946d7a55f45695ee58e1a0ff5f779)
The convert job planned every sequence again when it ran and checked only the frames
version, so a verify, a repaired upload or a tier change between the dry run and the job
let it replace photos the confirmed plan had listed as staying unchanged.
- Each sequence of a convert job now carries the digest of the photos it converts, each
with its SHA-256 (ConvertSequencePlan.Digest, also in the plan's fingerprint). Under the
sequence's lease, its sidecar settled, the job plans it again and goes on only while the
digest matches; it then pins those photos (convert-<job>.pins), so photos that come in
or are verified later stay as they are, a retry included. Stage B checks under the lease
that every pinned photo still holds the content converted instead of holding the frames
version, so a sequence still receiving uploads converts what was confirmed.
- A resumed job settles the journals a crash left in a sequence (a half-done replacement
among them) before it plans, and reports a sequence its replacement completed as
Converted, never Nothing or a partial swap.
- The passes a converted or new sequence needs are queued as soon as its outcome is
journaled; the journal records the statuses they follow from and whether they were
queued, so a pause, yield, stop or crash no longer loses them.
- Staged conversions of a blocked or failed sequence are kept for the retry, which
re-verifies and takes them; maintenance keeps a convert job's staging while the job is
queued, running or paused, and removes its journal and staging once the job is done or
gone from the history.
- A dry run counts the sequences of a queued conversion as busy, so the same conversion
cannot be confirmed twice.
- New sequence copies are owned by the source's owner, else by the requesting user's id
(never the user name); a staged copy that vanished fails the sequence instead of leaving
its photo out; the job log states how many photos stayed in the source alone.
- Free space is measured where the conversion writes: the server takes the tighter of the
space path's volume and the archive's own (Unraid cache), the desktop asks Windows
(GetDiskFreeSpaceEx), which also measures UNC archives; the job checks again before each
sequence and each photo, scaling estimates by the files staged so far, and stops before
the volume fills with what it staged kept.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 2d7d461c33b9f257bf57793cc7cf331d0425c14e)
Owner review 2, phase 4b, fix round 1 (trash, undo, recovery, sync and ingest).
- Replace journal: records a phase (moving, written, undoing) and the name each swapped
frame is filed under. Recovery decides "sidecar written" by what the sidecar lists, not
by the frames version any writer moves; a failed rollback stays undoing and its failure
now stops the writer (as a photo deletion's recovery does). The ingest settles restores
and replacements first, so an upload can no longer complete a swap that never happened.
- Emptying a Replaced entry re-verifies each replacement where it is now: in the sequence
through later conversions (a second conversion no longer strands the first originals),
or, when the conversion was deleted, its copy in the trash. The dry run marks such
entries "conversion deleted" (fingerprinted, shown on the desktop and the panel), and
the confirmed emptying may then erase them instead of keeping them forever.
- Undo of a conversion takes exactly the entries its job made (the job id is recorded on
the entry), never entries found by time window.
- Project positions translated by photo use the sidecar's photo of every frame still
there, so positions on a converted frame stay put when another frame went meanwhile.
- Sync aliases are equivalence classes: an original converted on both sides is one photo;
link-by-content, proxy counting and proxy upload follow aliases; a download into a
frame missing here swaps the other encoding into that frame instead of adding a frame.
- The ingest answers a converted photo's original (a card or folder imported again, a
download) as a duplicate of its conversion and keeps the alias tombstone.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 3341a2f845753fc4c5bcba51a3b645f126c95eaf)
The convert endpoint planned the whole selection inside the HTTP request, again for
every mode, quality keystroke and confirmation, with no limit: behind a proxy an
all-sequence conversion could never get past its dry run or its apply.
- ReorganizePlanCache becomes PlanCache, shared by Reorganize and Convert: one plan
per key made apart from the request, two at once across both kinds, eight kept,
15-minute timeout, 5-minute lifetime, 503 plan_dropped. Keys are typed records
(ReorganizePlanKey, ConvertPlanKey) that also say which exceptions are refusals.
- A conversion plan is keyed by archive, a convert stamp of the index
(SequenceRepository.GetConvertStampAsync: the Reorganize stamp plus, per planned
sequence, the photos' count, sizes, formats, pixel sizes and missing, corrupt,
preview-only and undecodable flags), the sequences and the target with the
quality that counts. Not the mode: the request's mode and options are set on the
kept plan, and the free space is measured again at every request through the
engine. A plan made while the volume was away is not kept (503 archive_offline).
- New sequence holds the converted copies alone: the dry run says the skipped
photos are not copied into it (Archive.Convert.NotCopied.*, Server.Convert.OnPcNew),
the panel's totals, column and confirmation give the count, and so does the
desktop's summary.
- Panel: the preview is asked in Replace's neutral words; a dry run cut off by a
proxy is asked again while the totals show how long it takes, plan_dropped is
retried once; an apply the server let go plans again, a changed one shows
Admin.Convert.PlanChanged, and one with no answer is not resent (its job may be
queued).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit f0b1e379ce7c08b6d3459ab25ca6214c8f366f6c)
Phase 4b and its first fix round were written on phase 4a before its rounds 4-6. Moved onto the
released 4a, the conversion now follows 4a's rule for writers into a sequence's folder
(SequenceFolders.Holds), and the parallel fixes meet:
- The job leaves a sequence another index moved away (its folder missing, or holding another
sequence's sidecar) as Blocked with Errors.Archive.FolderMoved, nothing settled, staged or
replaced there; the retry after this index's scan converts it where it is. It read the
sidecar there and reported the reader's technical text.
- New sequence reads the source's project under the source's lease, where its sidecar was just
read as its own, and writes the new sequence's project under that sequence's lease only into
a folder that holds it. It read the project from the folder the row named afterwards, without
a lease, and wrote through the store without the check.
- Download originals (resolved in the cherry-pick of the trash and sync fix, tested here) swaps
a copy fetched in another encoding into its missing frame after the transfers, as round 6
restores originals, and only once the sequence is found in the folder the index has;
otherwise the copies stay staged and the job fails with FolderMoved after its other work.
The swap ran inside the transfer loop and failed the job at the first refusal.
- The New sequence wording of the three skip reasons the codecs fix added (Archive.Convert.
NotCopied.EightBit, ColorProfile, TooLarge, en and it): the server and the desktop look them
up by reason.
- The server's free space test sets the staging folder's figures too: the job fix measures the
tighter of the archive root's and the staging folder's volumes.
Tests: a conversion of a sequence another index moved (its folder taken or empty), and a
download whose missing frame takes the server's conversion where the sequence is now.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, phase 5a (R8): editing moves out of the library into a workspace on a fast disk, and a
sequence gets several projects, each with a linear version history pushed and pulled like git.
- Core: ProjectSettings keeps members a newer Chronos wrote (Extra) and reads a newer settings format
read-only; ProjectContent is the portable form of a version (every frame position parked by photo,
canonical text, SHA-256 content hash); ProjectBundle format 2 adds the workspace section, and a file
without it is still written as format 1. JobKind.WorkspaceCopy = 20 (19 kept for Convert).
- Data: migration 0009 (projects, project_versions, the render's project columns); ProjectService on
ArchiveService.Projects keeps projects as sidecars first (.chronos/projects/<id>/), then the index,
under the sequence lease: create, rename, delete into the projects' trash, history, push with
fast-forward, idempotent repeat, divergence and hash checks. Main is made from the sequence's settings
and mirrored both ways, so every older code path keeps working; outside writes become "external"
versions, a mirror a crash cut short is completed or merged. Full scans and rebuilds take the projects
back from their sidecars.
- ProjectMerge moves from the App to Data/Projects, merges pending frames photo by photo and replays
unpushed commits on a moved head.
- Workspaces: WorkspaceStore, WorkspaceSync (checkout, save, commit, push, pull with replay and merge,
conflicts settled by keep mine / take server / save both, restore, status) and the WorkspaceCopy job
(proxies copied hash-verified and resumable; originals refused until phase 5c).
- Renders of a project version place its positions on the frames and record the project and version.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c4c1802884e403db8759ed0501f770a67a047f20)
Owner review 2, phase 5a (R8), desktop package: editing moves out of the library. A sequence of this PC's archive
now opens in Edit as a project of the workspace (%LOCALAPPDATA%\Chronos\workspace, .\data\workspace when portable),
with this PC's archive as its home; the editor writes the workspace's working state, never the library.
- WorkspaceHost composes WorkspaceStore and WorkspaceSync over Settings > Workspace's folder: checkout and the
WorkspaceCopy job, status, Save version with the sync after it (Sync automatically, on by default), sync (pull,
then push), conflicts, restore, history, new / rename / delete project, and Remove local copy, which refuses
while work is unsent unless the user sends it first or discards it, reads back the home's head and base and
checks their hashes, and keeps discarded work in <workspace>/.trash; versions past Kept versions are pruned only
once the home returns them with the same content.
- WorkspaceSequenceSource: frames and pixels of the media (proxies), the working state saved atomically under the
project's lease and merged against the basis, the home's deep report while its frames are the media's, renders
at the home with the portable settings recording the project and the version.
- Edit: the project opened last for the sequence, else "Open in workspace" (Main made from the sequence's settings,
another project or a new one; proxies) checks out, copies and opens once the copy is done. The picker lists the
workspace's projects with their state above the library. The title's project menu: Save version (Ctrl+S, note),
Sync, History (compare, restore as one undo step), New project, Rename, Delete project, Remove local copy; a
conflict dialog only on real conflicts (keep mine, take the library's, save both, later); Update media when the
library's frames moved. .chronos files: format 2 opens its project, format 1 gives its settings to Main.
- Settings > Workspace: folder (shown, Open), Sync automatically, Kept versions. Strings in English and Italian.
- A capture (sample data without an engine) keeps editing the library.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit da47a580ba9db3ce2a1db2f11c30cf7344c8b394)
Phase 5a was written on an early phase 4a state. On top of phase 4b it now
keeps the rules every writer of a sequence's folder follows, and keeps
project versions intact through Reorganize and conversions:
- ProjectService writes project sidecars, project.json and the settings
only under the sequence's lease and only in a folder that holds the
sequence (SequenceFolders.Holds). A folder another index moved away, or
one another sequence was moved into, is refused with
SequenceFolderMovedException: reads answer from the index, so no
project is taken for gone, nothing is written into the other sequence's
folder and the old folder is never created again. The home reports it
as out of reach. Full scans and rebuilds reconcile projects the same
way, and a failure there is logged instead of failing the scan.
- Stored versions park positions by photo and now follow the encodings a
Replace conversion (or its undo) joined through the sequence's Replaced
tombstones (PhotoAlias, HomePhotos): Main's mirror, renders of a
version and workspace media place them on the converted frames.
ProjectContent.Rebind/SameChoices name parked photos as the frames hold
them now, so a conversion or a hash since is no "external" Main version
and no spurious "Modified" in a workspace, and merges see one photo.
- The workspace copy job only reads the archive: it no longer runs the
archive's proxy pass, makes missing proxies in the workspace, reads
only a folder that holds the sequence, starts again when the folder
moved or files were renamed during the copy, resumes from a checkpoint
of its frames version, and refuses a workspace folder inside any
library before it writes anything (Errors.Workspace.InsideLibrary).
The working state keeps its positions by frame where frames stay.
- ArchiveProjectHome looks for a project or version the index does not
know yet in the sequence's sidecars first (an index taken back from a
backup, a sequence back from the trash), instead of calling it gone.
Tests cover the moved and taken folder, conversions in the archive and in
the workspace, the copy refusing a workspace in a library, resuming on
other frames, the alias lookup and the rebinding.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Round-2 fixes for the codecs part of owner review 2, phase 4b (mass
conversion), so the dry run never promises a conversion that then fails
or writes wrong pixels.
- The managed TIFF reader refuses samples it does not render (CMYK,
CIELab, palette, LogL, RGB of fewer than three samples, float
min-is-white) before reading pixels, instead of decoding them as the
gray of their first plane. The conversion chain then asks WIC on a PC;
the server leaves them to a PC. Impossible strip/tile counts are
refused as data, not as an OverflowException that escaped the chain.
- A conversion's managed provider reads JPEG, PNG and TIFF headers in
its probe (ReadsHeaders): what its decoders refuse there (compression,
sample format, photometric, MaxSamples, MaxPixels, arithmetic coding)
is not planned as convertible on the server, and is asked of WIC on a
PC. The probe gives the real size, so TooLarge sees it.
- Float TIFFs are linear light (SourceColor.IsLinear): a JPEG or TIFF
carrying their profile gets codes from the profile's own curves, a DNG
gets them through the matrix only (no curve, no clip, highlights
kept). IsSrgb is decided by the numbers for matrix/TRC profiles, so a
linear profile named sRGB is converted, not taken as sRGB. The TIFF
profile is read from the image the decoders read.
- TooLarge is a bound: the target's limits and what the server's
decoders read back, which every converted file must (JPEG 2^28 pixels,
TIFF-16 and DNG 2^29 samples), and the incompressible worst case
against the 2 GB array. A MemoryStream overflow is TooLarge, never a
generic file failure.
- Colorants that convert nothing (a white without positive cone
responses, a non-finite or singular matrix) are dropped when a profile
is parsed: the photo is carried into a JPEG or TIFF and planned out of
a DNG as colour_profile, instead of throwing in BradfordAdaptation at
every retry.
Tests: header probes, refused photometrics, the size bound against the
verifier's header reads, float TIFF colour, a fuzz of damaged profiles,
and a Windows test converting a CMYK TIFF through WIC.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 18cf9133087aada2db06c8310d2c69ff804c0115)
A conversion job could still do something its confirmed dry run did not show,
or refuse what it should have converted:
- An upload landing between the confirmation and the sequence's turn made the
sequence Changed at every retry. Each ConvertSequence now names the photos
the plan converts (Photos, their frame ids); the job takes those from its
re-plan, checks their content against the confirmed digest and leaves photos
that came in since as they are. A photo the plan did not list is never
converted, whatever changed on disk or in the index since the dry run.
- A file another program held during the dry run was planned as Missing and
then converted or not depending on the re-plan. It is now its own reason
(inaccessible, "held open or cannot be opened"); a truncated file reads as
undecodable. At job time a confirmed photo that cannot be opened leaves the
sequence Blocked for the retry; a held photo the job does not convert does
not hide a real change.
- The same sequences could be converted twice (two dialogs or tabs, a lost
answer, no dry run at all). MassConverter.QueueAsync checks the queued,
running and paused conversions and queues under one lock, in the caller's
context (the desktop's enqueue shows a toast on the UI thread); a job's own
re-plan treats sequences of conversions queued before it as busy.
- The per-photo space check reserved a full batch of photos even when fewer
were left, so a job whose preview had the space could stop at every retry.
It now reserves the photo and those after it that may convert at once.
- New sequence now says in the dry run, the panel's totals and confirmation,
and a new desktop confirmation, how many photos each new sequence lacks;
only sequences that are copied use those words.
- On the server, a confirmation takes only the plan kept for the index as it
is now (503 plan_dropped otherwise, never a plan made inside the request),
and busy sequences and free space are as they are at every request. The
panel's Apply asks the dry run again first, with Close still available,
and confirms only the same fingerprint.
- Maintenance keeps another host's conversion staging as long as its journal
and purges both together; the unstaged-copy failure and blocked sequences
are logged in catalog sentences.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit fefd9c34ebfeed1f9e84161610ef286026d38355)
Owner review 2, phase 4b, fix round 2 (trash and sync).
- Emptying a Replaced entry decided "conversion deleted" from this host's index
alone, so a conversion another host made, or one this index had not read yet,
could be taken for deleted and its originals erased without re-hashing it. The
survey now reads the archive: the sequence's sidecar where the index or the
entry says it is, in the trash, or found by walking the archive's folders. Its
Replaced tombstones are followed and every conversion it holds is re-hashed. A
conversion counts as deleted only when the sidecar shows it (a Deleted
tombstone, or the frame gone while every frame is hashed and no photo of the
folder is unlisted), when the sequence is in the trash, or when no sidecar of it
exists and this index has no row either. Whatever the archive cannot tell, or a
converted frame whose file changed since, keeps the entry, and the job log says
why (changed after the plan, sequence busy, conversion no longer matches,
conversion not located).
- The erase weighs a Replaced entry under the entry's and the sequence's leases
and settles the sequence first (an undo waiting for that entry's lease
completes), so the entry it reads again and fingerprints is the one it erases.
Read before the settle, a consumed entry's folder vanished under the erase.
- Each sidecar is indexed once per survey: one conversion's entry (every frame it
swapped) is weighed in one pass, not one pass over the sidecar per photo.
- The desktop Empty confirmation names every entry whose conversion was deleted
first, with why, wherever the trash lists it; the detail scrolls when long. The
panel lists them first as well.
- Download originals queues the passes a frame swapped to another encoding
cleared (light analysis, the deep analysis it had, thumbnails, proxies), as any
replacement does.
- The job log lines of uploads and downloads are resources (en, it).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 27d9a512183e64da9a3d7fa69a267470ca3ce744)
Four English strings changed meaning in phase 4b (the trash's kept entries and
the empty plan's tooltip); their old translations were dropped first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The docs now describe mass conversion after import as the code at 48a0ce3e does it:
Replace or New sequence chosen at every run, the dry run and the convert job of
exactly the confirmed photos, the scene-referred linear DNG, the replaced trash
entries with their Undo and emptying, and sync and ingest counting every encoding
of a photo as one. Four earlier DECISIONS rows are marked superseded in part.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit c746fe689c7bf16a3b5c28ea7694d91cf423f4a9)
To select the sequence edited last, the picker reads pages until it is listed. When the
list had asked for a page as it scrolled, LibraryPager.LoadMoreAsync answered nothing at
once while that page was in flight, and the loop asked again without ever yielding the UI
thread that page needed to finish: a core spun at 100% and the picker never settled
(EditSectionTests timed out under load and kept the test process alive). The loop now
waits for the page in flight (LibraryPager.WhenLoadedAsync) and stops when a page brings
nothing.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, phase 4b, fix round 3 (codecs).
Chronos's decoders never read an ICC profile: they take code values through
the sRGB curve and float samples as they are. Round 2 wrote a float TIFF's
values with its profile's own curves, so after a Replace the renders,
thumbnails, analyses and deflicker of an Adobe RGB, ProPhoto or gamma-1.0
float TIFF saw other pixels (up to 2.7 EV darker, shadows lifted). Every
converted file now holds the values the decoders read from the original, as
they read them back, and says truthfully what they are:
- A JPEG or TIFF-16 keeps the codes of code values and carries the original's
profile. Float values are written as sRGB codes with a profile made for
them: the original's colorants and media white with the sRGB curve. A gray
profile's codes are kept, its curve carried as an RGB profile (they were
converted to sRGB before, which changed them too).
- A Linear DNG, whose matrices Chronos develops it with as well, takes only
values that are sRGB's as the decoders read them; any other profile is
refused as color_profile instead of converted to colours Chronos would then
show differently.
- A profile with colorant tags that convert nothing is never sRGB by its name.
- A float file with NaN or infinite samples fails as damaged data instead of
being written black (and spending a DNG's headroom).
The plan and the decoders behind it:
- TooLarge and WorstBytes answer any size, int.MaxValue sides included,
without a product that wraps around; the worst case saturates.
- A frame another host flagged unreadable (the server, for a CMYK or CIELab
TIFF its reader refuses) is asked again with a small decode where the
conversion has other decoders (WIC on a PC), so a PC still converts it.
The too_large sentences say "or Chronos reads back" (en, it).
- WIC's TIFF decoder decodes an unknown compression as zeros, does not undo
the floating-point predictor of Photoshop's 32-bit files and reads 32-bit
integers as floats, all without an error: such TIFFs are left to the
managed reader, on the desktop as in conversions, never black or noise.
- A conversion's WIC probe reads the headers (decoder, first frame's oriented
size, pixel format), so the size bound applies to what only WIC reads; a
read error stays a read error (inaccessible), never a verdict.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Stage A's space guard reserved, before each photo, only that photo and the
ones after it, so at the end of a sequence it counted a single photo while
up to twice the parallelism were still converting: a volume filling
meanwhile could go into the reserve. It now reserves the photo and every
photo started whose converted file has not landed yet (a file lands whole,
by a rename, before it is verified), so nothing in flight is missed and
nothing landed is counted twice, at the end of a sequence as anywhere.
The confirmed photo ids (about 21 MB for a million photos) lived in the
job's parameters, read by every dry run's busy check, by each sequence turn
of the conversion and by the job lists. They are now written whole, under a
job id chosen before the job is queued, into convert-<job>.photos beside
the journal, and go with it; the row keeps each sequence's digest, so the
job still converts exactly the photos confirmed (without the file, the
whole plan made again must match). The busy check reads only ids, kinds and
targets (and a verify's parameters), never the asking job's row; a
conversion's turn reads only its creation time; the server's job list and
dashboard and the engine's queue peeks read jobs without parameters.
A retried New sequence conversion could make a second copy. The journal now
names the copy as soon as its photos are filed; a retry finishes that copy
whatever changed in the source since, never remakes one deleted since, and
needs no space again for what it holds; and a source another conversion
copied in the same format after this one was confirmed is done with, with
no copy made (new outcome Superseded, with its job log line).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A conversion counted as deleted when no frame of the sidecar held it, no
tombstone ended its chain and every frame was hashed. A sidecar rebuilt by
adoption meets that after a routine verify although it never knew the
conversion, so the originals were erased, the dry run calling them the last
copy, while the damaged conversion was still in the folder. A sequence found
nowhere and missing from this index counted as gone in the same way, even
when the walk had only skipped its folder (photos without a sidecar), and its
live conversion was never hashed.
A conversion is now deleted only on positive evidence: a Deleted tombstone
ending its chain in the sequence's sidecar, the sequence in the trash, or the
trash's record of erasing it (.chronos/trash/.erased/<id>.json, written
before a deleted sequence's folder goes while a replaced entry of it stays,
swept once none does). Anything else keeps the entry, and its job log line
says what settles it: verify the sequence (a frame never hashed), scan the
archive (a sidecar missing or unreadable), rebuild the index (a row the
archive does not bear out), or restore the entry to keep its photos.
Also:
- a dry run or an emptying walks the archive once for every sequence that
moved, and again only when a folder it found no longer holds it;
- a download queues the passes a frame swap cleared whatever stops the job
(JobContext.EnqueueFollowUpAsync with a token), as a restore does;
- the confirmation's detail takes Tab and scrolls from the keyboard when it
is longer than its card.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- A frame flagged corrupt, like one whose file is missing, is one no verify can
hash (a verify does not hash a file whose size differs from its record): a
replaced entry of its sequence is kept with "restore it", never with an
advice to verify that would never settle it.
- Erasing a deleted sequence leaves no record that its conversions went with
it while the sequence also lives (this index has it, or a folder's sidecar
names it: a folder copied back, a second deletion of the same id), so a
later emptying whose walk misses that folder keeps the originals.
- A copy another conversion made since this one was confirmed supersedes it
only once that conversion is done; while it is not (it failed while filing
the copy), a retry is left as it was with a reason (new string
Archive.Convert.CopyUnfinished, en and it), neither making a second copy
nor calling the sequence done with.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A workspace copied before the home hashed or converted a photo named it
differently from the versions the home made since, so a pull merged the
same photo as two: frame edits were silently undone and Keep mine placed
the library's value. Before replaying, the workspace media now learn the
home's hashes (same frame id, size and capture time) and conversion
aliases, so every side names each photo alike. Rebind also gives a
renamed entry the occurrence a placement looks for, so positions on
burst photos keep applying once hashed, and folds entries of one photo
(in Rebind and in the merge's keyed form) instead of keeping one.
Settings of a newer Chronos are no longer merged member by member with
this one's: ProjectMerge refuses when both sides changed. A workspace
pull keeps its local versions and working state untouched and records a
conflict of format that only Save both settles (into a new project of
this format); with nothing local it takes the newer head read-only.
Main's catch-up leaves a newer head and settings written meanwhile as
they are.
When Main's catch-up merge overrides values another writer stored, that
writer's settings are kept as an External version before the Merge one,
so nothing is lost from the history.
Unknown members inside Auto values, camera keyframes and curve points,
and on pending entries once placed, are kept like ProjectSettings' Extra.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Six new job-log and dry-run sentences (damaged pixels, a copy another
conversion has not finished, superseded, and three reasons a replaced entry
stays in the trash), and four whose meaning changed (the too-large reasons and
"kept, restore it"), whose old translations were dropped first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A project record that could not be read once, or a missing .chronos/projects, marked
projects deleted for good and made a second Main; an index meeting Main with no mirror
state took its own stale settings column as an outside change and reverted the pushed
head; a newer-format or unreadable head made every project call fail or rewrote the
record's head over the real history. Now:
- Deletion is never inferred from absence or a read failure: an unreadable record holds
its project back (listed as indexed, nothing written for it, no second Main), a row
marked deleted is revived when its live record says so, and projects the archive has
no folder for are written back from the index.
- Appends re-read the record under the lease and refuse when its head is not the
index's; Main is only made when the sequence has none anywhere.
- An index with no mirror state decides from project.json and the record's new
mirrored member (older records: the head's ancestry), never from its own column.
- A newer-format Main head is listed and pulled but never mirrored, merged or built on;
pushes must parse strictly and fit the one 64 MB version limit (TooLarge otherwise).
- Duplicate version numbers and name/Main clashes are contained per project, so a scan
or rebuild never stops.
- Delete moves the folder first, then writes the deleted record in the trash.
- The home's read-back for workspace pruning and Remove local copy reads the version
files (IProjectHome.HoldsAsync), not the index.
- A read-only archive is read without writing: its projects open from the sidecars and
a sequence with no Main gets one in the index only, written back once writable.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The docs now describe mass conversion as the code at 74ccde72 does it, so
nothing in them still states round 2's behaviour as the rule.
- Colour: a conversion never changes what Chronos reads from a photo. JPEG
and TIFF-16 carry the profile (float values get one made for them, gray
codes are kept); a linear DNG takes only values that are sRGB's as read
and refuses Adobe RGB, Display P3/HEIC, ProPhoto and gamma-1.0 sources as
color_profile, which TIFF-16 and JPEG still convert. NaN or infinite
pixels fail as damaged.
- Decoding: a frame another host flagged unreadable is asked again on a PC,
WIC is never used for TIFFs it reads as black or noise, its probe reads
the size, and sizes are weighed without overflow.
- Job: the confirmed photo ids sit beside the journal in
convert-<job>.photos, the space check counts every photo still being
written, a New sequence retry finishes its copy, and a source another
done conversion copied since is Superseded (CopyUnfinished while it is
not done).
- Trash: a conversion is deleted only on the archive's own word (a
tombstone, the trash, or the erasure record in .chronos/trash/.erased/,
never written while the sequence also lives); kept entries say what
settles them, a corrupt frame counting as one no verify can hash.
- CHANGELOG rc.7 folds this into its entries and adds the WIC TIFF and
Edit picker fixes; DECISIONS gains 17 rows dated 2026-11-03 and marks the
five round 2 rows they supersede in part; STATUS and ARCHITECTURE follow.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A push now moves the base before its local file reads as sent; a replay
journals itself in sync.json, writes the replayed versions, then the base
(the commit point), and only then sets the old ones aside and adopts the
local commits the home already held; a conflict met past such commits moves
the base onto them first. A save-both journals its copy and the ids it sends
under, so a retry completes the same copy instead of making another. The
next push, pull or resolve finishes or undoes whatever a cut left, so no
version is orphaned and no false conflict appears.
The editor reads the working state and the media index under the project
lease; workspace.json is written whole and moved into place (an empty one is
made again); project files may hold 64 MiB and one that would be larger is
refused before it is written, so large projects check out. The workspace copy
checks the drive's free space before and during the copy, keeps the folder in
its checkpoint and stores a reset when a pass starts again, and runs at High
level in the priority queue. Renders record a version only when the index
holds it with the settings rendered; an unsent version renders as the project.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Review 2, phase 5a, fix round 1 (desktop and the engine side of Resolve and Restore).
- Resolve applies Keep mine / Take the library's only to the conflict the dialog listed:
when the head or what differs moved since, the new conflict is recorded and asked again;
Sync re-works a pending conflict instead of re-showing a stale list. Take the library's
first saves uncommitted changes as a version, and the editor takes it as one undo step
(toast Undo, Ctrl+Z) that brings back only the settings both changed.
- Restore saves unsaved changes as a version also while a conflict waits; a restore that
changed nothing, or was undone, no longer marks the next version as a Restore.
- The editor's saves and merges of a workspace project merge positions photo by photo
(portable form) and ask where both sides changed a setting, never deciding for ours.
- Read-only after a pull is signalled, and no save that can never be stored is left behind.
- The chip is read again after edits; a background conflict waits for the open dialog;
Send first and Delete show the conflict they met; Discard changes needs the typed name.
- Open project... reaches the library's other projects (Save both's sibling, also from
its toast); copies whose project or sequence is gone read Not in library and can be
removed from the picker's Workspace rows; a delete whose local copy stays says so.
- A workspace folder inside a library is refused before anything is written.
- Conflict and Compare lines name heroes, exclusions and keyframes; History shows the PC
name alone, never the program's prefixes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Taking the server's values now saves unsaved changes as a version first
(desktop fix), while a conflict of format refuses that choice (merge fix):
the save is skipped for a conflict of format, so a refused choice leaves
the local versions as they were. A project that moves onto a newer
Chronos's head with nothing of its own now adopts the home's copies of
the local versions the home already held, as a replay does, since the
replay no longer writes over unsent files before the base moves
(workspace fix). The recovery test of a conflict met past a held version
checks the versions before the one Take the server's saves first.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A pull onto a newer Chronos's settings made the editor throw: ProjectHistory.Replace
rebased every undo and redo snapshot through ProjectMerge, which refuses to merge a
newer format when both sides changed, so any non-empty undo stack broke the reload
after a sync that had succeeded. Replace now drops the steps instead when either side
(or a step) is of a newer format: the project is shown read-only and undo never brings
back values from before the newer settings.
The media learnt the home's hashes and conversion aliases only inside a replay, so a
status or Save version before that compared a SHA-named base with photo-named media
and read a false Modified or saved a version that only re-keyed photos. Now:
- ProjectContent.SameChoices also compares the texts as placed on the frames, hashed
or not (Bound), so status and commit without a home agree with the base;
- a status asked of the home teaches the media its names (written under the lease, or
when the lease is free), and so does a checkout of a project already here;
- WorkspaceStatus.MediaOutdated reports frames moved at the home, or names the media
could not learn yet, and the project menu offers Update media for it (tooltip text
updated in en and it).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The sidecars stay the truth of a sequence's projects in the cases round 1's
checkers found still open, and no version or setting is lost on the way:
- An index-only Main meeting a Main another index made is written back as
another project, and Main passes to theirs in one transaction through a
free temporary name, so ux_projects_name and ux_projects_main never fail
(the SqliteException used to escape ListAsync and leave the index and the
sidecars disagreeing). A refusal is logged; the next reconcile settles it.
- The reconcile takes Main from the records, in step with the index, when
another index passed it on: exactly one Main per sequence, names from the
records where free.
- A project folder with versions and no record, of a project no index row
names (a creation cut before its record), no longer holds the sequence
back forever: it is left as it is and indexed once its record arrives.
- A record behind the index (a projects folder put back from an older
backup) is made whole from the index: its missing versions and the record
are written again, at every catch-up and before any append, rename or
delete. Only a record ahead of the index or naming another version is
refused, with a message that says so.
- An index meeting Main walks the chain down to the version the record names
as mirrored (a bound, since that record write may lag project.json), so a
lagging record never makes an External that reverts a newer push. When the
record names a mirrored ancestor, settings written since merge with the
unmirrored versions, as for an index that knows its mirror.
- The catch-up merge's External + Merge pair is resumable: an External head
whose parent is a push no mirror wrote is finished into its Merge version
next time, by this index or one rebuilt from the sidecars.
- A project deleted at the home has no head there, so a workspace copy of it
reads Gone, never In sync; Remove local copy without discard says the
project was deleted in the library.
- DatabaseExceptions are contained per sequence in the archive scan's project
reconcile and in ProjectService reads.
Tests: SQLite (PostgreSQL-ready) for each scenario, including a cut between
the two catch-up versions, a 40,000-exclusion version through save, push and
rebuild, and the App's Remove local copy of a project deleted at home.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
A Save both, a recorded conflict and a damaged version file could each leave
a local version out of the chain or a copy half-made at the home. This round
makes every one of these end with nothing lost and nothing half done.
- Save both retry: a journaled copy somebody else sent a version to (or one
deleted since) is left as it is, and a new copy takes every local version.
A divergence met at the copy while sending also makes a new copy, once.
- Keep mine, Take server, or a pull that settles a conflict after a Save both
was cut short first send the rest of the journaled versions to that copy,
if it is still this workspace's. The journal is cleared at the commit point.
- A conflict of format met past local versions the home already stored
(their answer lost) now moves the base onto them, like any other conflict.
The conflict, the base and the chain then name one version. A save-both
journal follows the base when it moves.
- A conflict recorded before stays while the home holds no version after
the base. A base that has reached the conflict's head clears it.
- Take server no longer replays or sends the version it saves first when,
replayed, that version holds only the server's values. It stays in
versions/.replaced for the undo. The test checks the exact history again.
- Version files after the base that cannot be read, or that do not follow
from it, are listed (WorkspaceProject.UnreadableVersions). The new state
WorkspaceState.Damaged shows them. Commit, push, pull and resolve refuse to
go past them. A damaged file whose version the home holds takes the home's
copy at the next sync, and the damaged file is kept aside. Remove local
copy counts these files as unsent.
- PushOutcome.TooLarge raises its own WorkspaceSyncException message. The
desktop says Errors.Workspace.VersionTooLarge for it and for
ProjectVersionTooLargeException when a local commit is too large.
- The editor maps LeaseUnavailableException from opening a busy project to
Errors.Workspace.Busy.
- The copy job no longer deletes, during the pass, a proxy that the editor's
current media name. RemoveStale removes it after the commit. A resumed run
does not keep such a file as a frame whose photo changed.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Phase 5a fix round 2 of owner review 2 (desktop):
- Take library's no longer commits the working state first, so a take that
leaves only the library's values sends no empty version; the working state
it replaces is kept aside in versions/.replaced, outside the chain.
- Conflicts list this side's value as the working state holds it, so one
answer settles them instead of asking again for the newer value.
- A conflict of format (library saved by a newer Chronos) offers only Save
both and Later, says why in its tooltip and shows no raw format numbers.
- Conflict lines count the photos a setting differs on ("Excluded frames
(3)") instead of dropping the duplicates.
- A read-only library is named as such, not as offline; checkouts from it
stay editable and their versions wait in the workspace.
- A workspace folder refused inside a library offers Choose folder, and
Settings > Workspace gets Change...: a plan (projects left, projects found)
is confirmed before the folder changes; nothing is moved.
- Open in workspace shows the copy's size and the drive's free space, and
warns when the copy would not fit with its 0.5 GB reserve.
- A cancelled first copy removes the half media it wrote.
- A copy whose project.chronos cannot be read is listed as damaged instead of
hidden, and goes only through Remove local copy > Discard, after a plan.
- Pruning keeps a version whose archive file is damaged (test added).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Taking the server's values no longer saves the working state as a
version first (the desktop fix), so a take refused by a home that
holds no versions after the base leaves the local versions as they
were. The recovery test that relied on that pre-commit now saves the
unsaved stack change itself before pushing it.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, R8. Round 2's checkers left five desktop problems:
- A workspace copy whose project.chronos a newer Chronos wrote (a format
this one does not know) was listed as damaged and offered for Discard.
It is now listed as "Newer Chronos" with its own tooltip, named from
what of its file still reads. It never opens, is never checked out
over, and Remove local copy refuses it with a sentence that says why.
- Discard of any copy moved only the files Chronos knows. It now moves
every file and folder of the copy aside (only the media are deleted)
and removes the folder only when nothing else came into it.
- Discarding a damaged copy asked to type its folder's GUID. It now asks
for the name the copy is still known by (its file, else the library's
index; the project's name, else the sequence's title), else for the
number of its files. The heading never shows the id.
- A conflict at a path where the working state had gone back to the base
value listed the local version's value. The conflict now lists the
working state's value in every case. Where the working state already
holds the library's value there is nothing to ask: that path takes the
library's value in the replayed versions too, so they agree.
- EditorSession.ReloadAsync, ResolveConflict and TakeOverAsync threw
NewerSettingsException on every reload when an edit was not stored
yet and the stored project became a newer Chronos's. The edit is now
kept in versions/.replaced (outside the chain, never sent), a toast
says so, the pending save is dropped and the newer settings are shown
read-only. When the edit cannot be kept aside, the editor stays as it
is and nothing is dropped.
The SequenceViewModel wiring now has a view-model test: the copy's facts
in Open in workspace, the refused-folder toast and its Choose folder
action, and the picker for a newer copy and a damaged one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The catch-up merge of a push whose mirror a crash cut short with settings
written meanwhile was two appends (External, then Merge), resumed by a purely
structural test that also fired on ordinary histories (two outside edits in
a row, a second index with an older mirror) and reverted the latest edit.
It is now one Merge version on the head in which the settings written
meanwhile (the settings in force, which older clients wrote) win where both
changed; the head's values stay in its version. A merge that adds nothing to
the head makes no version, so a cut before its mirror is finished next time
by the same index or a rebuilt one without any marker. The structural resume
is gone. An index meeting Main with a lagging record merges project.json the
same way, so a newer outside edit is no longer reverted by an older push.
Versions the catch-up records as mirrored are named in Main's record too
when project.json holds them, so records no longer lag behind externals.
Duplicate Main claimants (an index that met the sequence before Main's
record arrived) are settled from the records: the oldest claimant with a
version is Main in every index, the others are ordinary projects, and their
records say so when the archive takes writes.
A live project folder whose record is missing while the index holds the
project gets its record (and missing version files) written again from the
index instead of being held back forever. A record behind the index no
longer gives the index its old name. MirrorAsync reads the version leniently
and skips a newer one, as the other branches do.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
- A take of the library's values cut past its commit point settles its conflict
(replay journal marks Settles); a later stale choice finds nothing to settle,
and one cut before it keeps the conflict so the next choice is applied.
- A local version that changes nothing once replayed on the head is not sent
nor written as a Merge; its file stays in versions/.replaced.
- Save both journals its intent (name, base, time) before the home is asked,
so a cut after the copy was made reuses that copy on retry.
- A project deleted at the home reads as Gone from pull, push, resolve and
save both, logged once, without retry loops; versions and working state stay.
- Save both keeps the restore recorded in sync.json.
- The copy job writes a photo's new bytes under a name of its own while the
editor's media still name the old file, switching at the commit; a cancelled
first copy removes its own half media under the lease (VM hook removed).
- Status reads the version files once, re-reads the home's frames only when
its stamp moved, reports damage only when confirmed under the lease, and
waits once for a busy lease before calling the media outdated.
- versions/.replaced is pruned after a sync that ended well (30 days, newest
20 kept, never a file a journal names).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Conflict in WorkspaceFallbackTests: keeps desktop's new newer-copy test
and drops ACancelledFirstCopyLeavesNoHalfMedia, which the sync branch
removed along with WorkspaceHost.RemovePartialMediaAsync (the cancelled
first copy's clean-up now runs in the copy job, tested in Data).
ReplayAsync auto-merged with both intents: desktop's working-state
conflicts and silent paths, and sync's skip of no-change versions,
Settles journal flag and PruneReplaced.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Phase 5a fix round 4, projects engine.
- The reconcile reads the projects' trash before the live folders, so a
deletion wins over what a sync tool has left of the live folder. A lost
record is never written again while the trash holds a folder of that
project; a trashed record that cannot be read holds the project back.
- A lost record is written again from the index only once the folder has
looked the same, file by file, on two reconciles two minutes apart, so a
record a sync tool is still bringing (a rename, a newer head) wins.
- IndexAsync's "behind" is the rule the heal uses: the record's head must
be a version the index holds below its head. A record on another chain
keeps its name.
- A record written before what the index knows (its Updated time is
older, e.g. a backup made before a rename) never gives its name, and the
heal writes the index's name back. A record's Updated time never goes
back, so a newer rename from a PC whose clock is behind is still taken.
- A mirror never writes project.json over settings written there since
this index last knew what it held (another PC, an older client): they
are merged first (theirs win where both changed) or kept as an external
version, then the result is mirrored.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, phase 5a (R8), fix round 4.
A project the library no longer has now reads as Gone with no conflict to
answer. The conflict stays recorded in sync.json, so Save both on a deleted
project says Gone once and offers its copy. It no longer reopens the conflict
dialog. Keep mine and Take the library's first check that the home still has
the project. Neither is merged onto the last version a deleted project had,
so the working state and the unsent versions stay as they were.
Old files in versions/.replaced are pruned only after a push that ended well,
never after one that stopped at a conflict. A file an earlier build set aside
kept the time its version was written. It now counts as set aside no earlier
than when this build first knew the folder (versions/.replaced.since), so an
upgrade does not prune it by an old mtime. The Merge mark goes on the replayed
version whose own change met a setting the conflict listed. A version that
only rides along with a working-state conflict stays a commit.
A first copy cancelled while paused or failed, which no handler runs, now has
its partial media removed under the project's lease, as a running one does
(ICancelledJobHandler). The space estimate counts a proxy held under its
<id>-<sha16>.jpg name. The frames stamp carries a weighted SQL checksum of
the hashes, so a hash replaced in place (a Verify) makes the workspace read
the frames again.
Desktop: a removal that cannot move a file puts back what it moved, so the
copy stays whole and listed, and the failure is said. The Removed toast names
a damaged copy as it is known, never by its folder id. One copy that cannot
be listed no longer hides the others. A Main this Chronos cannot read (newer
or damaged) is refused at once with the reason, and a damaged one offers
Remove local copy. Save version is off on a Gone project, and Send/Delete
there say the project was deleted in the library.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner review 2, phase 5a, fix round 5.
- A cancelled workspace copy clears its partial media only under the project's
lease, after checking again that the job is still cancelled, that no other
copy of the same root and project is queued, running or paused, and that no
copy in this process is writing. The engine now waits for a paused job's run
to end before calling the cancel handler, so the clean-up is never skipped.
- The clean-up never recreates a project folder that was removed meanwhile
(the lease no longer creates the folder). The next list removes a project
folder that holds only lease files nobody holds, older than the lease.
- A Main this Chronos cannot read (newer or damaged) refuses the open at once
only when nothing else can be offered. Otherwise Open in workspace lists it
disabled, with the reason as its tooltip. The refusal's action tooltip is
now Remove copy.
- The removal plan counts a conflict the same way the sync status does: a
conflict that a settling replay took past its commit point is not work
left.
- A healed record is stamped after both the record's time and the index's, so
the next rename made elsewhere is taken.
- A trash folder holds back the rebuild of a lost record only when it is this
sequence's deletion: its record names this sequence or cannot be read, or it
has no record, is within a one-day grace and holds no version of another
project. What was seen of folders that are gone or have a record again is
forgotten.
- When a deletion wins, version files pushed into the live folder before the
deletion arrived are moved beside the deleted record in the trash, never
deleted.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Phase 5a was cut from an earlier phase 4b commit (e3cbe30b). This merges the
final 4b head 11d2c67e (squashed into main as efa87f68): fix rounds 2-3 of
the mass conversion and the replaced-photo trash, the residuals, the 4b
strings in the 36 other languages, and 4b's docs, so 5a builds on the code
that was released.
Conflicts:
- JobRepository: 5a's ListPendingAsync (the workspace copies of a sequence)
and 4b's ListHoldsAsync (what running and paused jobs hold, without the
parameters) are both kept.
- ARCHITECTURE: 4b's rows and paragraph kept whole, 5a's additions
(projects, workspaces, the Edit picker, the WorkspaceCopy job) laid onto
them; both paragraphs kept.
The resx files merged cleanly: the 36 other cultures hold 4b's
translations, and 5a's new keys stay untranslated there. JobKind values are
unchanged (Backup 16, Cleanup 17, EmptyTrash 18, Convert 19,
WorkspaceCopy 20).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The 241 strings phase 5a added (workspace, projects, versions, sync and
their errors and tooltips) were English and Italian only. Each language
gets them, with the extra plural forms it needs. The new terms
(Workspace, Project, Main, Versions, Workspace copy) are added to
GLOSSARY.md and to each language's glossary.tsv, taken from the strings
themselves, so later phases reuse the same words.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PostgreSQL stores sequences.settings_json as jsonb, which reorders keys
and drops whitespace, so the exact text match with project.json failed
on the PostgreSQL integration jobs. The other mirror tests already
compare with JsonNode.DeepEquals.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Alby96
merged commit 9b24cf74fc into main2026-11-04 09:22:14 +01:00
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
Owner review 2, R8, phase 5a (
docs/requests/2026-10-26-owner-review-2.md). To be released asv0.1.0-rc.8.What changes
Workspace. Edit no longer edits inside the library. A sequence opens as a project in a workspace folder on a fast disk (
%LOCALAPPDATA%\Chronos\workspace). The first open asks Open in workspace: you pick the project (Main, an existing one or a new one) and the media (Proxies). A hash-verified, resumable Workspace copy job (JobKind.WorkspaceCopy = 20) then copies the proxies.Projects. A sequence can have several projects, each with a linear version history. The histories are stored as sidecars in
.chronos/projects/, which a scan or a rebuild reads back.0009_projects.sqladds theprojectsandproject_versionstables and two columns inrenders.Sync like git. The editor's project button has a state chip and these actions:
Only settings changed on both sides ask you to choose: Keep mine, Take library's or Save both.
Settings › Workspace: Folder, Sync, Kept versions. Update media appears when the library's photos changed after the copy.
Renders from Edit run at the library with the project's settings and record the project and the version.
Every new string (241 keys) is in en, it and the 36 machine-translated languages. The new terms are added to
GLOSSARY.mdand to eachglossary.tsv.How it was checked
Review: one review round found 55 findings. Five fix rounds followed, each with an independent checker, until the last check passed.
Phase 4b merge: the final phase 4b head (
11d2c67e, released as rc.7) is merged in with a real merge.mainis recorded with-s ours; its tree equals11d2c67e.Build:
dotnet build -c Releasegives 0 warnings.Tests:
Core.Windows and App ran with the usual local exclusions.
Checks:
i18n check(0 errors, 0 warnings),xaml-lint,package-guardanddotnet formatare all clean.Not in this phase
[0.1.0-rc.8]lists the known limitations.Docs: BRIEF (amended 2026-10-26, R8), DECISIONS (2026-11-03), CHANGELOG, STATUS, ARCHITECTURE, and the request file (with the 4b commit cell set to
efa87f68).🤖 Generated with Claude Code
Owner review 2, R3: the panel can add photos to an existing or a new sequence without the desktop app. upload.js is a dialog the library pages open (openUpload({ api, sequence, onDone })): file picker or drag and drop (folders are counted and left out: whole-folder import stays on the desktop), per-photo state, a total bar, Cancel that deletes the started uploads, and a leave-page guard while sending. Each photo is hashed in a same-origin module worker with an in-house incremental SHA-256 (8 MiB reads; crypto.subtle cannot hash in pieces), which runs the FIPS 180-4 known answers and a crypto.subtle cross-check before its first hash and refuses to hash on any mismatch; the server verifies the hash again. Chunks go through api.putBytes with the session's CSRF header, two files and two chunks at a time, retrying no answer, 429 and 503; quota, space and permission refusals stop the run with the server's message, and a photo deleted from the sequence shows as deleted before. server/info now lists the photo extensions the archive files, so the dialog offers and sends only those. The CSP already allows the worker (worker-src falls back to script-src 'self'); tests pin that, the module walk follows the worker, and a browser-shaped upload runs end to end through the cookie session. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit c64c60ab8bb41c102182e284177ac04a56bf1058)The phase 3 packages land together, so the panel's pieces must stay in step: - Admin files are served with Cache-Control: no-cache and their content ETag (If-None-Match lists, W/ tags and * honoured). With max-age=3600 a browser that loaded the panel before an upgrade could run new modules next to cached old ones for up to an hour; now it revalidates each file and only what the upgrade changed is sent again. - The Library's Upload and a sequence's Add photos open upload.js, which now ships with the panel: the test requires the module (no 404), the dynamic import and the openUpload({ api, sequence, onDone }) calls. - Bulk jobs over more than 1000 sequences queue one job per 1000; the toast now says how many were queued, also when a later chunk failed. - The live refresh re-reads every loaded row, a thousand per request, instead of dropping rows beyond the first 1000 back to Load more. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>Review fixes for owner review 2, phase 3 (R6 Library on the web panel): - Trash: the worker can end an emptying before the browser has read the POST's 202, so its jobState arrived while the page did not know the job yet; Empty then stayed disabled ("being emptied") and no result showed. The page now keeps the last state of the jobs that ended and looks its job up there before following it. Any ended job also reloads the list (an emptying from another tab or the desktop sends no sequenceChanged), and a Restore answered 404 shows the trash as it is now. - Sequence: thumbnail, proxy, verify and analysis jobs send no sequenceChanged, so tiles and the cover stayed placeholders and the status chips stale. An ended job now schedules one refresh (not pushed back by the next): the sequence is read again and failed images are asked for again under a retry address (shared retryImages). - Library list: Esc, Ctrl+A or unticking every card left the "Select all" snapshot in place, hiding Select all and stopping the live refresh from pruning the selection. It is dropped once no selected sequence lies beyond the loaded rows; Clear filters clears the selection too. - The sequences' delete dialog lists at most 500 names (blocked ones first, with their reasons), like the photos' dialog (shared LISTED). - Admin.Trash.RestoreSequence.Tip promised a SHA-256 check that a sequence restore never makes (it moves the folder back); it now says so and names Verify (en, it; no other culture had the key). - The upload test's name and comments say what it checks: upload.js is only imported dynamically, not loaded on click. Tests pin each change in SystemEndpointTests; the pages were also driven in a browser against a fake API, where the pre-fix modules fail and the fixed ones pass. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 78f66082fd85543d619375574c82cc63a233b7a8)The upload dialog's completion helper called `api`, which only exists inside openUpload, so every web upload failed with a ReferenceError at its last step. complete() now takes the dialog's api. A new test lexes every admin module and fails when a top-level function uses api without taking it; it flags the old upload.js. During a run Esc is now stopped on the document in the capture phase. The old listener sat on the dialog, so with the focus on the body (Start disables itself, a click on the dialog's text) a second Esc closed the dialog and threw the uploads away. The listener is added when a run starts and removed when it ends or the dialog closes. A sequence page refreshes after any ended job, because jobState names no sequence. That refresh now redraws the header only when the sequence changed, and the renders only when their list did. Stars, tags and renders are redrawn through redraw(), so the keyboard focus stays put. restoreFocus finds an unnamed control by its place, not as the first unnamed one. Failed thumbnails are retried with a doubling wait and at most 8 tries, counted again once the sequence changes. The trash page reads the emptying it follows from /api/v1/jobs/{id} on every load and after the event socket reconnects (api.events now emits "reconnected"), so Empty no longer stays disabled when the job's end was lost. A Restore in flight stays disabled across redraws. The Library list counts cancelled jobs as ended (shared JOB_ENDED). Comments are corrected in shared.js and library.js. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 641b9cd96b95d523990d1414c2bdead4138c5f4d)Owner review 2, R7 asks to rename and move sequences after import on the desktop too. The desktop now uses the engine's Reorganize, the same plan and job as the web panel. - One Reorganize… dialog replaces Rename… and Move… in the Archive manager and Move… in the Library. It has three templates: folders, file names and titles. Each one has a switch and is checked as it is typed. Folders and file names start on, filled from the archive's settings; titles start off as {title}. Renaming only titles is the Titles switch alone. - The dry run stays in the dialog and follows the typing. Each sequence shows its folder, title and first file names before and after. Sequences carried along with a folder are marked, and photos that keep their names are listed with the reason. A summary counts the sequences that change, the files renamed and the names kept. - Apply no longer changes the archive from the dialog. It queues the engine's move job with exactly the plan shown (its fingerprint), so the work can be paused, resumed after a restart and followed in Jobs. The job refuses the plan if the archive changed after the dry run. - The Library's Reorganize… works on the selected sequences of one archive. The Archive screen reads the archive again when a move job ends. - After Settings › Archive saves a new folder or file template to an archive that holds sequences, a toast offers Reorganize… for every sequence. Its templates are the ones changed since; a second change made while the toast is up adds to that toast instead of opening another. - Strings in en and it. The keys of the old Rename and Move were removed and pruned from every translation, so the 36 other languages show the new keys as untranslated instead of keeping "Move". Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 7bbf451f737a71b768dcd70a77b998daaef851f3)Reorganize with the archive's own templates planned renames and moves for photos just filed, and some templates could strip extensions, hide sequences from scans or stall a dry run. Owner review 2, phase 4a findings. - Filing and Reorganize share one context: uploads and imports name every photo with the sequence's camera and lens (its first photo's, or the creator's hint), an upload's folder from its first frame in the new sequence, and a missing capture time from the sequence start instead of the current time. The planner expands folder and title templates from the first frame in the sidecar ({name}, {ext}, {iso}...), never today's date. - Titles expand as text (ExpandText): "Paris: night" stays as typed. - A sequence whose sidecar cannot be read (torn, another sequence's) keeps its folder, title and names, listed with why, and so does every folder around it; the dry run reads every sidecar, nested ones included. - Kept never gives one folder to two sequences of a plan whatever the case, and a case-only move onto another folder is refused instead of taken as done. - Shared template rules (TemplateRules) for the server's Reorganize and archive settings and the desktop's fields: a file template must keep the photo's extension ("{n}{ext}" refused) and tell a session's photos apart; a folder template may not write a level scans skip (a leading dot, originals, proxies, exports). Levels a title gives are escaped with "_". - {ext} comes from the file, or from the original name when the file lost a photo's extension, so a Reorganize can put it back. - Unique names cost linear time (UniqueNames) with the same names as before. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 6c734777e01476881a3f34b3188571cc3f7150ab)A Reorganize with a file template failed its job at the step of a sequence a camera was still uploading into, and its retry gave the rest up. Photos changed since the plan now never refuse a step: that sequence keeps its file names (FilesKept), its folder and title change as planned, the other steps go on and the job ends with ReorganizeKept. The fingerprint, the job's confirmation and the check under the leases pin file renames by their digest instead of the frames version, so photos filed under the names the plan gives them no longer make a dry run or a queued job stale. - A step whose folder or files a template names after {title} checks the title as a retitle does (RenameStep.NamedByTitle): no name comes from a title edited since the plan. - Recovery sends a photo that already took its new name back together with a companion whose new name was taken, so the two never end up apart. - ArchiveService.OpenAsync logs a NewerFormatException from resuming a plan and keeps its journal, so a server still boots. - Once a step's folder moved, every index row of the step follows it even when a sidecar cannot be read or written; the step then fails for a retry. - Job log lines and errors give the real reason for files kept busy (in use or a new name taken) and for a sidecar of a newer format (new Newer outcome; strings en and it). - A plan an archive open completes tells sequenceChanged; the docs that promised more than that are corrected. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit f8554b8af0828ab9b0ff128e694abacdd53e6fd7)Second fix round of owner review 2, phase 4a (planner findings). - A sequence keeps a folder that differs from its own in case only while no other folder holds that exact name (RenamePlanner.ExistsExactly, every level compared exactly). On a case-sensitive file system a stray "Trip (2)" beside the sequence at "trip (2)" no longer gives a case-only step that MoveFolder refuses at every archive open: the plan gives "Trip", and a plan whose target appeared since is refused under the step's leases before anything moves (or dropped when it resumes). A change of case in an outer level no longer looks like two folders on Windows. - A file name longer than 200 characters is shortened before the ".{ext}" the template ends with, never through it, so a long title never strips the photo's extension. - The archive engine's own settings check applies the template rules the server and the desktop apply (a folder scans skip, a lost extension, names that repeat), so archive.json can no longer take such a template. - The server's invalid_template answer names the rule after the field ("fileTemplate:extension") with the desktop's sentence as its message; both admin panels show it on the field. - FrameNaming keeps only the naming overloads production uses. - Comments about Unreadable say the whole sequence stays as it is. - Tests pin filing against Reorganize: an upload without a capture time, a card's second session with {session}, a duplicate skipped mid-session, and a whole folder of two cameras named with the first one's camera. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 50fe59aec1e180daa1733bcb951892a79dceba6c)Phase 4b was built on phase 4a before its review fixes. Integrated on the reviewed 4a, the conversion now follows the same rules as filing and the other writers. - Names: a converted file is named as filing names a photo of its sequence (FrameNaming: the archive's file template, the frame's context in the sequence with its camera, lens, number and title, {name} the card's, {ext} the target's, a long name keeping its extension). Replace through ConvertOptions.FileName; New sequence through the ingest itself (StagedFrame.NamedAs), which numbers and names the copies in the new sequence. Names stay unique against every file present, those leaving included, so a Replace never moves onto a file; a test pins a stray file that keeps its bytes. - Leases: stage A starts from the sidecar settled under the sequence's lease where the index has it then (SequenceWriter.ReadLocked), and FrameTrash.ReplaceAsync reads the row again under the lease, so a folder a Reorganize moved meanwhile is followed, never made again. A Reorganize the archive waits for keeps the conversion off its sequences (pinned). - Journals: the replace journal is settled with the others. MassRenamer steps, restores into a sequence and sequence deletions wait for an unsettled replacement as they wait for a restore, and so do photo deletions, whose frames version the recovery reads (FrameTrash.EnsureReplaced); a scan settles it and reconciles nothing meanwhile; a restore settles its sequence's replace journal first, at the folder the index has under the lease. - The convert job tells each sequence converted or made as it completes, as a Reorganize tells each step, so an editor open on it reads it again while the rest of the job runs. - Desktop: JobKind.Convert gets its row in the settings' job priority list. A click on Apply that commits the quality no longer starts the same dry run again under the click (as 4a fixed for Reorganize). - Panel: a dry run answered during the confirmation with the same plan no longer drops the confirmed Apply; a different plan is shown with Admin.Convert.PlanChanged (en, it). - Tests: TrashDialogTests.EmptyQueuesTheJobOfTheConfirmedPlanOnly waits for the command to end before running it again (a running AsyncRelayCommand ignored the second Execute). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 2e0d1d6dcc10575734970bb9c77749f00777c859)Phase 5a fix round 2 of owner review 2 (desktop): - Take library's no longer commits the working state first, so a take that leaves only the library's values sends no empty version; the working state it replaces is kept aside in versions/.replaced, outside the chain. - Conflicts list this side's value as the working state holds it, so one answer settles them instead of asking again for the newer value. - A conflict of format (library saved by a newer Chronos) offers only Save both and Later, says why in its tooltip and shows no raw format numbers. - Conflict lines count the photos a setting differs on ("Excluded frames (3)") instead of dropping the duplicates. - A read-only library is named as such, not as offline; checkouts from it stay editable and their versions wait in the workspace. - A workspace folder refused inside a library offers Choose folder, and Settings > Workspace gets Change...: a plan (projects left, projects found) is confirmed before the folder changes; nothing is moved. - Open in workspace shows the copy's size and the drive's free space, and warns when the copy would not fit with its 0.5 GB reserve. - A cancelled first copy removes the half media it wrote. - A copy whose project.chronos cannot be read is listed as damaged instead of hidden, and goes only through Remove local copy > Discard, after a plan. - Pruning keeps a version whose archive file is damaged (test added). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>