A merge's Verify stage journals a second version before filing it. When the copy then failed or read other bytes (the file rewritten by an editor or a sync tool, a drive dropping out before an edit), every retry read new bytes for that journalled frame and stopped with changed, keeping the journal, so the merge failed the same way until cancelled. - When the kept sequence does not hold the journalled bytes, nothing was filed: the frame leaves SecondVersions and VersionShas and is verified as on a first visit, which files the photo as it is now. - When it holds them (filed, then the exclusion failed), they are left out of Main and the merge stops and drops its journal, so the next run plans again instead of a cancel leaving them in Main for good. Refs #73 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
575 KiB
575 KiB
Decisions
One line per decision: date · decision · alternative · reason.
| Date | Decision | Alternative | Reason |
|---|---|---|---|
| 2026-10-02 | The prototype dump docs/reference/chronos-prototype.md was not supplied; algorithms are implemented from the brief's descriptions and the cited literature, with the §20.4 thresholds as acceptance tests. |
Wait for the dump | Not available in the repository or uploads; the brief fully specifies behaviour and gates. |
| 2026-10-02 | Custom WPF theme dictionaries (Chronos.Ui/Themes) implementing DESIGN.md tokens instead of Application.ThemeMode Fluent. |
Fluent theme + overrides | DESIGN.md fixes exact colours/sizes; Fluent is still flagged experimental (WPF0001) and would need restyling of most controls anyway (§2.1 permits in-house dictionaries). |
| 2026-10-02 | Added shared WPF library src/Chronos.Ui (theme, icons, controls, Loc markup extension) used by App, Uploader and Setup. |
Duplicate resources per app | One visual system for three programs. |
| 2026-10-02 | Added tests/Chronos.Core.Windows.Tests for WIC / Media Foundation / DXGI tests. |
Put them in App.Tests | Keeps engine interop tests independent of the WPF app. |
| 2026-10-02 | Localization areas extended with Common, Jobs, Uploader, Setup. |
Fold into Shell |
Smaller, owned files; same key scheme. |
| 2026-10-02 | Resources live in i18n/<culture>/<Area>[.<culture>].resx, embedded into Chronos.Core (satellite assemblies), base name Chronos.Core.i18n.<Area>. Keys marked <comment>invariant</comment> need no translation. |
Raw XML loader | Uses ResourceManager as the brief requires; satellites bundle into single-file publishes. |
| 2026-10-02 | Program icons (ICO) are generated at build time into artifacts/icons by Chronos.Tools make-icon, invoked from Directory.Build.targets. |
Commit generated ICO files | Brief forbids committing generated binaries and raster sources. |
| 2026-10-02 | In-house CRC-32 (Chronos.Core.Hashing.Crc32). |
System.IO.Hashing | That assembly is a NuGet package, not part of the shared framework. |
| 2026-10-02 | Windows projects target net10.0-windows (platform version 7.0) without a Windows SDK projection TFM; Windows 10 APIs are reached by P/Invoke/COM. |
net10.0-windows10.0.19041.0 |
Avoids the CsWinRT projection; toasts use the in-window toast host plus tray balloon. |
| 2026-10-02 | Test projects use an explicit TestMain entry point. |
Top-level statements | Avoids the Program type clash with the server's top-level program. |
| 2026-10-02 | SQLite P/Invoke binding lives in Chronos.Data with a library resolver (winsqlite3 on Windows, system libsqlite3 elsewhere for tests/dev); the Linux server still refuses SQLite at configuration time. |
Binding in Core.Windows only | Lets repository tests run on Linux CI against both dialects. |
| 2026-10-02 | Client preferences needed before the database opens (language, theme, window placement) are stored in settings.json next to the database. |
Settings table only | Language and theme must apply before the first window appears. |
| 2026-10-02 | Server Windows-service hosting will use an in-house advapi32 P/Invoke host. | Microsoft.Extensions.Hosting.WindowsServices | That assembly is a NuGet package, not part of the shared framework. |
| 2026-10-02 | Admin panel files are embedded resources served by an in-house middleware with ETags and SPA fallback. | ManifestEmbeddedFileProvider | Its manifest generator ships in a NuGet package. |
| 2026-10-02 | Container health check runs Chronos.Server --healthcheck (in-process HTTP probe). |
curl/wget in the image | Keeps the runtime image free of extra tools. |
| 2026-10-02 | Container drops privileges with setpriv to PUID:PGID; /data is chowned, /archive only checked for write access. |
Recursive chown of the archive | The archive may hold terabytes on NAS shares. |
| 2026-10-02 | Release workflow publishes to RELEASES_REPO (default <owner>/chronos-releases) when the RELEASES_TOKEN secret exists, otherwise to this repository. |
Fail without the token | First releases work before the public repository is set up. |
| 2026-10-02 | Release notes are generated by Chronos.Tools changelog from git log piped on stdin. |
Tool spawning git | Keeps the tool free of external process calls. |
| 2026-10-02 | CI dotnet format gate checks whitespace formatting. |
Full style/analyzer verification | Analyzer rules already fail the build (warnings as errors); style preferences stay suggestions. |
| 2026-10-02 | Test runner exits 0 for a project with no tests and 2 when a filter matches nothing. | Always 2 | Empty projects during bootstrap are not failures; mistyped filters are. |
| 2026-10-02 | COM via [ComImport] + explicit ReleaseComObject; flat APIs via LibraryImport. |
[GeneratedComInterface] |
Deterministic release keeps files unlocked; the apps are not trimmed. |
| 2026-10-02 | WIC decodes to 64bppRGBA and linearises with the exact sRGB LUT (128bpp float only for float sources). | Always 128bppPRGBAFloat | WIC's integer→float gamma is not the exact sRGB curve and premultiplication darkens edges. |
| 2026-10-02 | Exif orientation is applied in managed code while de-interleaving. | IWICBitmapFlipRotator |
Microsoft documents quadratic behaviour of the flip-rotator over scanline decoders. |
| 2026-10-02 | Volume watcher uses a hidden top-level tool window plus 3 s polling. | Message-only window | Message-only windows do not receive broadcast WM_DEVICECHANGE. |
| 2026-10-02 | Camera RAW is "native" via WIC only when the Raw Image Extension package is installed. | Decoder CLSID alone | The in-box RAW codec shares the CLSID but only reads embedded previews. |
| 2026-10-02 | HEVC/AV1 decoder presence is detected with MFTEnumEx. |
Store package names | Also covers OEM and hardware decoders. |
| 2026-10-02 | Math code lives in src/Chronos.Core/Math with namespace Chronos.Core.Mathematics. |
Chronos.Core.Math |
That namespace would shadow System.Math in every Chronos.Core.* file. |
| 2026-10-02 | CCT = McCamy refined to the nearest Planckian point (Krystek, CIE 1960 uv), valid for |Duv| ≤ 0.02. | Plain McCamy | McCamy alone misses the 100 K gate above ~9000 K. |
| 2026-10-02 | Deflicker keeps (1 − strength)·ρ·S of a frame's deviation (ρ own Tukey weight, S window surviving fraction). | Blend by S only | S alone barely isolates outliers. |
| 2026-10-02 | LOWESS uses the k nearest valid samples with bandwidth = farthest distance + one spacing. | Fixed half-width | Constant sample count at sequence edges. |
| 2026-10-02 | Clock jump = backward step > 3× median interval or a ±1 h offset from cadence (DST); counts as one interval. | Any whole-hour step | Scheduled multi-hour pauses look the same. |
| 2026-10-02 | Time zone for solar labels: recorded offset → camera−GPS clock (15 min) → longitude/15 with a "time zone estimated" finding. | No day phases | Usable labels, honestly flagged. |
| 2026-10-02 | Holy-grail step is "received" when the detrended median jump ≥ 50 % of the metadata step (same sign); metadata amplitude is redistributed with smoothstep ramps lengthened until ≤ 0.3 EV/frame. | Measured amplitude | Flicker makes the measured jump noisy. |
| 2026-10-02 | Flicker fundamental = first autocorrelation peak within 80 % of the strongest; window ∈ [15, 151], odd. | Strongest peak | Avoids harmonics at fractional periods. |
| 2026-10-02 | Optical flow: dense pyramidal Lucas–Kanade with box filters, neighbour-flow correction, σ = 1 px pre-blur; grid step 4/2/1 px for Draft/Balanced/Best. | Farnebäck | Separable, SIMD-friendly, stable and as accurate on smooth motion. |
| 2026-10-02 | Phase correlation: Gaussian-shaped peak + log-parabola sub-pixel fit, both patches in one complex FFT. | Foroosh sinc fit | Exact for Gaussian peaks, half the FFT work. |
| 2026-10-02 | Stabiliser: noise-corrected texture gate, exhaustive pairwise similarity hypotheses (≤ 36) + weighted LS, path smoothed by Gaussian-weighted local linear regression (σ = 12). | RANSAC / plain Gaussian | Deterministic with nine patches; keeps intentional pans. |
| 2026-10-02 | Interpolation chooses velocities by forward–backward consistency with per-sample flow-agreement weights (τ = 3 px). | Super SloMo combination | Better at motion boundaries (36.8 vs 33 dB). |
| 2026-10-02 | Virtual-camera zoom is interpolated geometrically; trail length L ↦ decay 0.01^(1/L). | Linear zoom / half-life | Even perceived speed; the trail is gone at its stated length. |
| 2026-10-02 | Motion estimation, sharpness and noise use sRGB-encoded luminance. | Linear light | Shadows keep texture weight; less exposure dependence. |
| 2026-10-02 | Archive presets use 0.30 bpp (≈60 Mb/s at 4K24 HEVC 10-bit); share presets use the brief's per-codec defaults (0.10/0.07/0.05). | 0.07 bpp everywhere | An archive must survive later re-encoding; star fields are the hardest content. |
| 2026-10-02 | All metadata fallback chains (time, ISO, serial, lens, rating, size) live in MetadataBuilder.Build; parsers only collect candidates. |
Fallbacks inside each parser | One place for priority rules; parsers are order-independent. |
| 2026-10-02 | MetadataReader.Read(path) throws when the file cannot be opened; malformed content becomes warnings (with a parser-fault safety net the fuzz tests require to stay unused). |
Swallow everything | An unopenable file is not malformed input. |
| 2026-10-02 | HEIF irot/imir override Exif orientation (imir axis 0 = top↔bottom). |
Exif first | HEIF decoders apply the transforms themselves; both would rotate twice. |
| 2026-10-02 | Main image size comes from the container's own size field (SOF, IHDR, ispe, VP8X, RAF crop record, RW2 borders, CR3 CMP1) before raster IFDs. | Always the largest raster IFD | That is what each container defines and what decoders output. |
| 2026-10-02 | Only MPF large-thumbnail entries count as previews; XMP date-only values are never used as capture times. | Every secondary image / midnight | Gain maps are not previews; midnight would be invented. |
| 2026-10-02 | Media Foundation interop uses [GeneratedComInterface] with explicit release; threads entering MF call Win32Com.EnsureInitialized() (MTA unless already STA). |
[ComImport] like WIC |
Hardware encoders stall when sample references wait for GC; source-generated COM does not initialise apartments, so it is done explicitly. |
| 2026-10-02 | MP4: 16-byte free+mdat placeholder rewritten to a 64-bit header past 4 GiB; negative composition offsets shifted to ctts v0 plus an edit list; parameter sets moved into avcC/hvcC; fast start on by default. |
Always 64-bit mdat / ctts v1 | Small files stay maximally compatible; wider player support. |
| 2026-10-02 | GIF: Wu-criterion median cut, frame differencing against the source last drawn, identical frames merged by holding one back. | Plain median cut / diff against dithered output | Max palette error 37 → small; 945 KB → 52 KB at equal PSNR; exact delays. |
| 2026-10-02 | AVI always carries OpenDML indexes plus idx1 (1 GiB RIFF segments). | idx1 only | Files beyond 2 GB stay playable. |
| 2026-10-02 | MF encoder capabilities: software H.264 ≤ 4096×2304, hardware assumed 4096² (H.264) / 8192² (HEVC/AV1); an unsupported size fails at media-type negotiation and the next encoder is tried. | Querying limits | MF has no reliable capability query. |
| 2026-10-02 | Full-size JPEG IDCT is a port of libjpeg's accurate integer IDCT (bit-identical to djpeg); reduced-size (1/2–1/8) decoding uses float IDCTs with triangle chroma upsampling. | SIMD float IDCT everywhere | Float produced rare ±3 differences after YCbCr; reduced sizes gain 6.7 dB with triangle upsampling. |
| 2026-10-02 | Codecs throw only InvalidDataException for bad structure or unsupported features; damaged scan data yields a partial image plus warnings. |
NotSupportedException for features | One exception type for callers and fuzzing. |
| 2026-10-02 | Linear DNG export: raw image in IFD0, lossless-JPEG tiles, ColorMatrix1 + ForwardMatrix1 for Rec.709 D65; source camera Make/Model kept when Exif is supplied. | Preview IFD + SubIFD raw | Simplest valid DNG; LibRaw renders test patches back exactly. |
| 2026-10-02 | Resampler keeps negative/overshoot values in linear light. | Clamp to 0–1 | Ringing stays within each kernel's exact bound; clamping happens at encode. |
| 2026-10-02 | Codec fixtures (each < 12 KB) are generated by tests/fixtures/codecs/make-fixtures.sh with libjpeg-turbo/libtiff dev tools and committed. |
Fetch at test time | Reference outputs must be stable; the tools are not build or runtime dependencies. |
| 2026-10-02 | Installer payload "TPK1": deduplicated, deflate-ratio-bounded entries after the setup stub; footer aligned to 8 bytes and found before an Authenticode table so signing works before and after packing. | Spec fields only | Every offset is bounds-checked; signtool can append without breaking the payload. |
| 2026-10-02 | Setup runs asInvoker and relaunches itself elevated (runas) only for all-users installs; the unelevated parent starts Chronos afterwards. |
requireAdministrator | Chronos never runs elevated. |
| 2026-10-02 | Uninstaller self-removal via a %TEMP% copy started with /CLEANUP; running programs are only asked to close (never killed; silent mode exits 5). |
MoveFileEx alone / kill | Per-user installs have no admin rights; user data safety. |
| 2026-10-02 | Setup has its own Program.Main (silent and cleanup modes run without WPF) and is published with single-file compression (70 MB stub). |
App.xaml-generated Main | Reliable exit codes; smaller installers. |
| 2026-10-02 | SQLite: one in-process async write lock with BEGIN IMMEDIATE, shared-cache in-memory mode for tests, fixed-width ISO-8601 UTC text with microseconds and lower-case UUID text. |
busy_timeout alone / epochs | Writers queue instead of failing; text order equals time order on both dialects. |
| 2026-10-02 | PostgreSQL: parameters typed by OID, results in text decoded by OID, named prepared statements (128 LRU), session settings pinned in the startup packet, cancel = CancelRequest then socket abort after 5 s, transient retry once for idempotent reads only. | Untyped params / tracking ParameterStatus | Predictable decoding, no "could not determine data type", a dead server never hangs a caller, writes never repeat. |
| 2026-10-02 | Migrations: all pending ones in one transaction under pg_advisory_xact_lock. |
One transaction per migration | Atomic and safe when several servers start together. |
| 2026-10-02 | Case-insensitive search/sort via lower-cased search_text/title_key columns (and COLLATE "C" on PG). |
ILIKE / NOCASE | Identical results on both dialects. |
| 2026-10-02 | Job claim: UPDATE … WHERE id = (SELECT … FOR UPDATE SKIP LOCKED) RETURNING on PG; immediate transaction on SQLite. |
Advisory locks | Exclusive under concurrency, as specified. |
| 2026-10-02 | One JobEngine in Chronos.Data runs every long operation for both the client and the server: handlers per JobKind, progress persisted at most every 5 s, a failed persist (job no longer running) stops the handler, a shutdown leaves jobs running so the next start requeues them from their checkpoint. |
Per-feature background loops | One queue, one cancel/pause/resume path and one crash-recovery rule everywhere. |
| 2026-10-02 | Job throughput is a moving average over windows of at least 2 s. | Average since start | ETA follows speed changes (cache warm-up, network) without jitter. |
| 2026-10-02 | Visual controls (card grid, filmstrip, charts, preview, curve editor) keep their layout and math in WPF-free classes; colours are theme brush keys re-resolved on theme switch; filmstrip, preview and time-axis charts never mirror in RTL (category charts lay out from the reading side since 2026-10-06, inside an element that stays left to right). | Math inside controls / brush properties | Testable on Linux; view models hold no brushes; time axes and images must not flip. |
| 2026-10-02 | VirtualizingWrapPanel does its own keyboard navigation and recycling; the focused container is kept alive. |
ListBox navigation | Direct targets, wrapping across rows; focus survives scrolling. |
| 2026-10-02 | Library card slot 236 × 208 with a 16:9 thumbnail. | Mockup's 150 px thumbnail | DESIGN §4 specifies 16:9. |
| 2026-10-02 | Uploader sessions: key = 8 hex chars of the source folder's SHA-256 + first-frame time; leading test shots (first group < 8 frames) join the next session; watch-folder files always use automatic sessions. | Group by time only | Simultaneous cameras stay apart; unattended files never land in a sequence chosen for a manual drop. |
| 2026-10-02 | Uploader: a watch file counts as processed only after the server confirms it; offline, rejected-token and changed-certificate failures do not use up the three retries; a changed certificate signs the user out. | Mark at enqueue / count every failure | Clearing the queue loses nothing; an outage does not exhaust a large batch; never upload to an unverified server. |
| 2026-10-02 | Delete-after-upload also requires size and write time unchanged since hashing. | Server confirmation alone | BRIEF rule 8. |
| 2026-10-02 | Uploader settings are an in-window panel; single instance via a per-session mutex and a current-user named pipe; native tray menu (TrackPopupMenuEx). |
Dialog / WM_COPYDATA / WPF ContextMenu | §12.1 allows modals only for login and destructive confirmations; works while hidden in the tray; dismisses reliably. |
| 2026-10-02 | Network watch folders are polled (default 5 min); local folders every 60 s plus FileSystemWatcher hints. |
Watcher everywhere | SMB change notifications are unreliable. |
| 2026-10-02 | The Dockerfile uses BuildKit's built-in frontend (no # syntax=docker/dockerfile:1). |
Pinned external frontend | Every feature used is built in; the build no longer depends on Docker Hub (a 502 there failed CI). Base images come from mcr.microsoft.com. |
| 2026-10-02 | SQLite sessions run every blocking call on the thread pool (ThreadPoolHop) and cancel through a per-connection flag polled by sqlite3_progress_handler (every 1000 VM instructions) in addition to sqlite3_interrupt. |
Callers offload themselves / interrupt only | A repository awaited on the UI thread never freezes it; an interrupt that lands before sqlite3_step starts was silently lost and the query ran to the end. |
| 2026-10-02 | Deep analysis persists per-frame shifts from the nine-patch Stabilizer and smooths the path itself; per-frame data is stored as columns (~80–110 bytes/frame) with a JSON-lines checkpoint that drops a torn last line. |
Stabilizer.Solve / row objects |
Solve cannot resume from a checkpoint; the report stays small for 100k-frame sequences. |
| 2026-10-02 | Sky/land mask from a pre-pass over 15 sampled frames before the main pass. | Segment after the pass | Cloud coverage and per-region luminance need the mask during the pass. |
| 2026-10-02 | Scene distance: chi-square on histograms smoothed by ⅛ EV and levelled to the same mean; flow statistics use brightness-levelled images and forward–backward-consistent vectors only; noise is median-based (Immerkær). | Raw chi-square / raw flow / mean noise | Flicker and exposure steps no longer read as scene changes or motion; stars no longer inflate noise. |
| 2026-10-02 | Shake and motion thresholds are judged in output pixels (stabilise above 0.3 px RMS). | Source pixels | That is what the viewer sees. |
| 2026-10-02 | Automatic output stops at 4K UHD; no automatic stacking advice. | 8K / temporal-median denoise | 8K stays a manual choice; a median erases moving stars and stillness cannot be verified reliably. |
| 2026-10-02 | Apply records a missing-data reason only where no advice exists; Optimise returns modules to Auto and only adds to the user's hero, exclusions, offset or output cap; a preset's own choices are stored as manual values, content-derived values stay Auto. | Overwrite | Manual values stay in force; re-analysis does not undo a chosen preset. |
| 2026-10-02 | Advisor namespace is Chronos.Core.Advice (class Advisor). |
Chronos.Core.Advisor |
A class named like its namespace needed an alias in every Chronos.Core.* caller. |
| 2026-10-02 | (Superseded by the 2026-11-04 baselines row: the baselines are captured on the development PC and the ci-screenshots branch is gone.) CI also force-pushes each same-repository PR run's screenshots as one commit to the ci-screenshots branch (separate job, only it has contents: write). |
Artifact only | Artifacts need an authenticated download; a branch can be fetched with plain git for visual review. The branch never merges and holds a single commit. |
| 2026-10-02 | Export fps is the encoded grid; Timing.FrameRate is the playback rate (source frames per video second, default = export fps). Durations are quantised to output periods on rounded 90 kHz boundaries; whole frames are sampled at the period centre. |
One fps / free durations | Presets keep their meaning, Interpolated can synthesise slow motion, AVI and image sequences stay exact. |
| 2026-10-02 | Adaptive timing is proportional up to 3× the median interval; longer gaps show for 3 + log2(r/3) frames (max 5); pauses ≥ 20× median and ≥ 120 s become a 0.2 s cut. Interpolated fills gaps of up to 3 missing/excluded frames. | Fixed clamps | Bursts stay faithful and long gaps cannot stall the video. |
| 2026-10-02 | A non-monotonic time-remap curve is repaired (sorted, clamped, made non-decreasing) with a warning; virtual-camera keyframes are keyed to source frame positions. | Reject the curve / output frame index | The remap is always monotone; keyframes stay on the content when timing or fps change. |
| 2026-10-02 | Per frame: exposure → one warp (stabilisation⁻¹ ∘ camera ∘ crop) to output size → flow, synthesis and blur in output space → stacking → knee. Stabilisation zooms by 1/max(crop scale, 0.75), warning below 0.75. Modules run only when Auto resolves true. | Flow in source space / no zoom | A single resample; flow sees stabilised content; borders stay hidden. |
| 2026-10-02 | Blur fraction = BlurFraction(target × speed, real) / steps, speed clamped to 4, no blur across cuts. | Fixed fraction | The look survives speed changes. |
| 2026-10-02 | Encoding overlaps processing by one frame; image sequences encode up to one frame per core into a hidden .tmp folder renamed at the end, named <name>/<name>_000001.ext. |
Strictly sequential / frame_%05d |
1080p PNG 1.0 → 2.5 fps; crash-safe and editor-friendly. |
| 2026-10-02 | JPEG/MJPEG use 4:4:4 at quality ≥ 90, else 4:2:0; HEVC/AV1 → H.264 fallback rescales the bit rate by bits-per-pixel; size capped to the highest level, then the encoder maximum; managed bit depth moves to the shallowest supported depth ≥ the request; linear DNG tiles are sized to the frame (≤ 256 px). | — | Predictable quality and sizes; small DNGs are ~3× smaller. |
| 2026-10-02 | Auto<T> carries HasAdvice; Resolve falls back only when there is no advice. |
Treat default as "no advice" |
A value type's advised 0/false was indistinguishable from "no advice". |
| 2026-10-02 | i18n check also treats any C# string literal shaped Area.Group.Name with an existing area as a used key. |
Marker functions such as LocKey(…) |
Reason and warning keys travel as data; 53 render/export keys had no resources and the check did not notice. |
| 2026-10-02 | Sidecars store sequence and frame ids, original name, UTC offset, time source, verifiedAt and session keys; compact JSON with numeric flags and named enums that read as Unknown; a sidecar with a newer schemaVersion is read but never rewritten. |
Ids only in the DB / string enums / rewrite | A rebuild returns the same ids; unknown bits survive; data safety. |
| 2026-10-02 | Frames stay in capture order: ingest inserts in place and renumbers later frames; thumbnails carry a source fingerprint and proxies an Exif capture time so stale ones rebuild themselves. | Append in arrival order / mapping file | Parallel uploads arrive out of order. |
| 2026-10-02 | Ingest batches one sidecar write per sequence for concurrent commits, protected by a write-ahead journal; "new sequence with title" uploads map to a session key of user + title. | One write per file / new sequence per call | Large sidecars are not rewritten per frame; a crash between move and sidecar write recovers; parallel uploads with one title share a sequence. |
| 2026-10-02 | Import sessions split per camera body and file format; the session key hashes body, format and first capture time; duplicates offer Skip or Import again, never overwrite. | Body only / random key / overwrite | RAW+JPEG would double every frame; an interrupted import continues its sequence; originals are never replaced. |
| 2026-10-02 | Card erase re-hashes both the card file and the archive copy and refuses files touched since the dry run; adoption reads light metadata only and Verify fills the hashes. | Trust import-time hashes / hash during adoption | User data rule 8; adoption stays fast. |
| 2026-10-02 | Index rows without a sidecar are kept and reported as orphans (only Rebuild or an explicit fix removes them); scan stamps are 100 ns ticks; a copied sequence folder gets new ids; index edits win over the sidecar when the index's settings version is ahead. | Auto-delete / timestamps / shared ids / sidecar always wins | A temporarily missing folder loses nothing; microsecond DB precision would make every scan see changes; duplicate ids corrupt the index. |
| 2026-10-02 | Writers coordinate through lease files (2 min, renewed every 40 s, stale leases renamed aside); thumbnail passes take their own thumbs-<id> lease. |
OS file locks / the sequence lease | Locks are unreliable over SMB and across processes; long thumbnail passes must not block ingest. |
| 2026-10-02 | One thumbs.pack format: the archive's ThumbPack (frame index + source hash, append-only entries, index + footer, walk-back recovery). The decode workstream's second pack format and proxy builder were removed; its LRU ThumbnailCache stays for the UI. |
Keep both | Both wrote TTPK files with incompatible layouts to the same path. |
| 2026-10-02 | Native RAW: the sensor saturation point only marks clipping (never rescales); white balance before demosaic, colour matrix after; highlight recovery lifts clipped channels to the unclipped mean then fades to grey; camera matrices match the exact model name; CR2 black level from masked columns; Sony as-shot WB falls back to daylight. | Per-frame white adjustment / prefix match / SR2 decryption | Per-frame rescaling would flicker a timelapse; D750 ≠ D7500. |
| 2026-10-02 | Frame-window spill stores 32-bit floats; DNG DefaultScale stretches the axis with the larger factor; ForcePreview uses an embedded JPEG preview only when it is at least the requested size. | Half floats / shrink / always preview | Renders stay bit-identical under memory pressure; full resolution; no blurry thumbnails. |
| 2026-10-02 | A job engine claims only kinds it has handlers for (intersected with Kinds when set) and starts no workers without any; crash recovery requeues the node's numbered workers (node#0, node#1, …). |
Empty filter = every kind / exact node id | A host without a render handler must leave render jobs to render nodes; with several workers the old exact match never requeued crashed jobs. |
| 2026-10-02 | (Partly superseded by the 2026-10-26 system schedules rows: the rescans are the desktop's archive-scan schedule.) Desktop: the archive engine uses WIC first, then managed decoders; the last archive is reopened at start (relinking a moved one, finishing interrupted renames) and incrementally rescanned every 10 minutes; Welcome and Library create/adopt through the archive engine and queue a full scan; failures become a toast. |
File-system watchers / no periodic scan | BRIEF §7: polling by mtime/size plus manual rescan. |
| 2026-10-02 | Desktop thumbnails: widths rounded up to 64 px, LRU of 2000 items, at most cores/2 (2–6) decodes, "no image" cached but failures not, a decode is cancelled when its card scrolls away; job list updates batched to ~10 Hz keeping the latest per job. | Fixed size per card / update per event | Fewer decodes, bounded memory, a free UI thread during fast renders. |
| 2026-10-02 | Server sign-in in the client: an unknown certificate fingerprint is confirmed before any password is sent, a changed certificate never receives the saved token, the token is stored only DPAPI-encrypted. | Trust on login | BRIEF §14.2. |
| 2026-10-02 | The client update check reads the latest non-draft, non-prerelease GitHub release of ChronosReleasesRepo and only opens its page; Clear cache deletes only folders carrying a .chronos-cache marker, after confirmation; --capture runs on a temporary data folder with fake server, encoders and update check. |
Download updates / clear any folder / real data | No external processes; never delete user data; CI never touches user data. |
| 2026-10-02 | The server registers the archive engine in ArchiveModule (ingest, asset locator, job handlers through IJobHandlerProvider) and opens its archive through ArchiveService.AdoptAsync; ServerHost.Build keeps the registration callback so tests can substitute fakes, and still refuses to start without ingest and locator. |
Hard-wired registrations / DB row only | Tests stay isolated; the archive always has .chronos/archive.json, so scans and ingest work from the first start. |
| 2026-10-02 | Admin cookies are Secure: cookie sign-in over plain HTTP only from loopback, /admin over HTTP from other hosts redirects to HTTPS; CSRF token derived from the session token's hash, cookie WebSocket upgrades must be same-origin. |
Drop Secure / random double-submit cookie |
BRIEF §14.2; a planted cookie pair cannot forge the token. |
| 2026-10-02 | Sign-in rate limit and lockout live in memory and apply to unknown names too; the generated first admin password goes to an owner-only file deleted once an admin sets a password; minimum password length 10; admin-created users must change their password; resets give a temporary password. | DB columns / log the password / email links | No user enumeration; secrets never logged; no mail infrastructure. |
| 2026-10-02 | API errors are localised through Accept-Language (fallback CHRONOS_LANG); ETags on sequences, manifests and originals (SHA-256) with If-Match doubling as the expected settings version. |
English only / version in body only | Every user-visible string is a resource; standard HTTP caching and concurrency. |
| 2026-10-02 | Deleting a sequence moves its folder to <archive>/.chronos/trash/<id> (with dry run); upload completion is synchronous and idempotent, survives client disconnect, and a failed ingest returns the upload to receiving (503). |
Erase files / async commit job | User data rule 8 and undo; clients need the frame id at once and retries stay safe. |
| 2026-10-02 | Quota = used + pending uploads + new size, checked at start and at commit (render outputs not counted); the duplicate short-circuit matches a hash anywhere, preferring the target sequence; at most 8 concurrent chunk uploads per user (429), bodies capped at 1 MiB except chunks. | Committed bytes only / per-sequence only / request-rate limiter | Parallel uploads cannot slip past the quota; the brief's wording; simplest effective limit. |
| 2026-10-02 | Render jobs never run on the server engine: render nodes claim them by codec and resolution, report failures, and a job fails after losing its node 5 times. | Managed rendering on the server | No server render handler yet. |
| 2026-10-02 | Server settings page writes only edited keys to server.json; environment-fixed settings are locked; restart-only keys are flagged. Windows service: LocalSystem, automatic start, name ChronosServer. Admin panel: strict CSP (SVG charts, no inline styles); light and dark themes (2026-10-06, toggle in the header). |
Rewrite the whole file / theme toggle | Secrets never written; DESIGN.md wins over the mockup toggle. |
| 2026-10-02 | Migrations are numbered without gaps (0001 initial, 0002 archive index, 0003 server uploads). | Keep 0005 | Parallel workstreams picked numbers to avoid collisions; renumbered at merge. |
| 2026-10-02 | xaml-lint checks keyed value resources against the property type (GridLength for column/row sizes, Thickness, CornerRadius, Double). |
Rely on Windows smoke tests | A Double used as a column width compiles and only fails when the template loads on Windows; the lint now fails on Linux too. |
| 2026-10-02 | Languages with more plural forms add key.few / key.many beside the English key.one / key.other; i18n check accepts them, compares their placeholders with English other and lets any plural form omit the count. |
One English-shaped key set for every language | "Rendered once" style forms cannot cover Russian 21 or Arabic 3–10 otherwise. |
| 2026-10-02 | Translations go through i18n missing (TSV out) and i18n import (TSV in) against i18n/GLOSSARY.md plus a per-language glossary.tsv; each language is translated and then reviewed by a second pass. |
Edit resx by hand | Same path for machine translation and community corrections; keys, placeholders and budgets are validated in one place. |
| 2026-10-03 | ProjectSettings.FromJson lays the JSON over the serialised default project: objects merge, arrays and scalars replace, a null never replaces an object. |
Deserialise directly | The source-generated reader turns missing members into null/0, so a partial or empty settings JSON lost whole sections. |
| 2026-10-03 | Light analysis is queued by the engine after an import and after a scan that indexed something (Background priority, skipping sequences already queued); deep analysis after an import is queued by the import post-action of the card profile. | Screens queue analyses | The advisor's recommendations exist without user action (§1.1) and nothing is queued twice. |
| 2026-10-03 | Analysis jobs log a failing sequence and continue; the checkpoint next;i,j makes a retry analyse only the failed ones; an offline archive stops the job at once. Sequence presets are written to the job log, advice fills Auto values only. |
Fail the batch at the first error / apply presets | One bad sequence does not block a library-wide analysis; presets are a user choice. |
| 2026-10-03 | Render jobs whose every output is managed (AVI MJPEG, image sequences, GIF, APNG) run on the server engine. MP4 jobs wait for render nodes, matched by codec and per-encoder size, at least the node timeout and while an online node can encode them; then the server writes MJPEG/AVI at the same size and frame rate and says so in the job log (§14.7). A job the server started resumes only there. | Never render on the server / fall back immediately | A restarting node keeps its jobs and no job waits forever. Replaces the 2026-10-02 row "Render jobs never run on the server engine". |
| 2026-10-03 | Selective claims (ISelectiveJobHandler.AcceptsAsync) look at the first 100 queued jobs of selective kinds per claim; other kinds keep the atomic claim. |
Scan the whole queue | Bounded cost per claim; documented limit. |
| 2026-10-03 | POST /jobs splits a batch into one job per preset; a render node fails a batch job instead of rendering only the main preset; a node registering again requeues jobs its previous run abandoned. Proxies have no hash: fetched whole on retry; originals are resumed and SHA-256 verified. |
Nodes render batches | One output per job keeps progress, retries and uploads simple. |
| 2026-10-03 | A render on the server ignores the client's export folder and always writes to the sequence's exports/. |
Honour the folder | The server never writes outside its archive. |
| 2026-10-03 | Sync state lives in a client-side sync_links table (one row per server sequence, linked to its local copy); server-only sequences appear on the Server screen and, since 2026-10-06, in the Library as remote cards. |
Columns on sequences |
One local copy per server; server-only rows need a home. The server-connected Library mode stays with the Library. |
| 2026-10-03 | Uploads create the server sequence by sending the first original under the session key chronos-sync:<localId>; every original is re-hashed before sending and a mismatch fails the job. |
POST /sequences |
The server cannot store uploads into an empty sequence created that way; originals are sacred. |
| 2026-10-03 | Sync conflicts: any field changed differently on both sides is a conflict settled against the versions shown (Keep mine / Take server confirm the differing settings; Save both takes the server's and keeps this PC's settings as .chronos/project.this-pc-<time>.json). A later change refuses the choice and compares again. |
Tag union and newest-wins merge | §14.5 asks for last-writer-wins with an explicit prompt; a union brings removed tags back. |
| 2026-10-03 | Sync timing: full comparison every 2 min, server events batched for 1 s, failures back off from 5 s to 5 min. "Keep proxies offline" refreshes stale caches only for sequences this PC opened with proxies, after a free-space check. "Sync projects automatically" defaults to on. | Every server sequence / polling only | Bounded disk use; the brief says "synced sequences"; the mockup shows the option on. |
| 2026-10-03 | Renders keep their id on both sides and are offered for transfer only once the originals agree; render downloads are size-checked (the server keeps no render hash). Uploads on metered networks pause through the OS network cost API when the option is on. | Hash renders | No server field exists; uploads are hash-verified by the server. |
| 2026-10-03 | Not built: "Free local space" (deletes originals; needs an archive-engine offload state), the footer user count (admin-only data) and "changed by" in the conflict detail (no API field). | Build them in the sync layer | Data-destroying or privacy/API choices for the owner (§0.2.7). |
| 2026-10-03 | Update Download fetches the package for this copy (setup, or the portable zip for a portable copy), verifies it against the release's SHA256SUMS and shows it in Explorer; the user runs it. Files go to %TEMP%\Chronos\updates\<tag>, .part resumed with Range, 60 s idle timeout, Cancel; without the package or SHA256SUMS, Download opens the release page. |
Start the installer as §18 says | §8.6 allows only open-URL, explore-folder and SHFormatDrive; the stricter rule wins. |
| 2026-10-03 | (Partly superseded by the 2026-10-26 log defaults row: the 4 MB are the Diagnostics logs setting.) Diagnostics bundles (desktop and GET /api/v1/server/diagnostics, ManageArchive, audited): environment, codecs and encoders, scrubbed settings or configuration, recent failed jobs (50/100), newest 14 logs (last 4 MB each); never photos. Secret-named JSON values are removed; in text a secret runs to ; or end of line. |
Remove whole lines / omit settings | Err towards removing too much while keeping bundles useful. |
| 2026-10-03 | Public releases repo content, GitHub Latest and GHCR :latest follow the newest stable release; the image is pushed after the Windows tests and :latest moves after the GitHub release exists; public content is updated last. Stable notes start at the previous stable tag. |
Tag :latest in the docker job |
No downgrade for compose/Unraid users and nothing public before a release exists. |
| 2026-10-03 | Perf gates (opt-in, weekly perf.yml): Library open through a new connection pool with warm OS cache; filters as the median of 5 runs; rebuild at one fifth of §1.1 (400 × 250 real photos, 120 s budget) on SQLite and PostgreSQL. No perf migration was needed. |
Drop OS caches / full 500k files | Portable on CI runners while still catching plan and index regressions. |
| 2026-10-03 | fixtures --allow-missing prints a warning annotation per missing sample and exits 0; without it, 1. Chronos.Tools.Tests covers tool behaviour CI relies on. |
continue-on-error | CI shows the gap instead of a silent pass. |
| 2026-10-03 | Editor: the corrected-frame preview is built in the App layer (RenderPreparation corrections, then geometry, exposure and the knee), measured at 128 px; the preparation is split into a measuring pass and re-solves so slider steps never re-decode; analysis decodes are kept as Half within 1/16 of available memory (64–512 MB). | A Core single-frame entry point | Preview speed without touching the render engine. |
| 2026-10-03 | (Partly superseded by the 2026-11-03 workspace editor saves row: a workspace project's save merges photo by photo, and a setting a sync and the editor both changed is asked, not won by the editor.) Editor autosave 400 ms after the last change with a three-way JSON merge (the editor wins on members both sides changed); a failed save stays pending and retries from 2 s doubling to 60 s; closing with an unsaved failure asks through a destructive modal. Undo takes adopted outside changes; a drag, click or key press is one step. | A Save button / dropping the change | Data safety; §12.1 allows modals for destructive actions. |
| 2026-10-03 | Editor 1:1 and wheel zoom render at the source's long edge, Fit at the view's size; labelled preview tools (icon + text) with full screen, play and the crop view icon-only; the shot-data pill moves above the tools when they do not fit at 1200 px. | Render only the visible region | Decoders decode whole frames; simplest correct option. |
| 2026-10-03 | Export tab: preset grid columns = width / 200 px; Output label column fixed at 96 px with ellipsis and tooltip; Optimise all skips Stack; render follow-ups are a toast with Show in folder plus the history line's show-file link. User presets ("Customise") are not built; the Export "Sync" box is (2026-10-06: ExportSettings.SyncToServer, off by default). | Fixed 4 columns / placeholder controls | The fixed grid clipped at 1200 px; user presets need a preset store and render-path resolution. |
| 2026-10-03 | Exposure measuring tool switches Luminance / Flicker (frame-to-frame log-luminance change before and after correction) / Waveform (luma per column band of the corrected preview); the Time tab shows a plan chart beside the remap curve; the Camera free crop is four margin sliders (≤ 45 % each, ≥ 10 % of the frame left). | One chart per tab | §12.3 measuring needs and Editor.html. |
| 2026-10-03 | (Partly superseded by the 2026-10-26 conversion after import row: import still copies byte for byte and has no Convert row; converting is a separate, explicit step after import, which keeps the erase gate and the originals.) Import omits the Convert row and the profile "New" button: card profiles are born on first insertion and shared through camera profiles (settings row followed by the cards of that camera; a card without settings joins automatically). | Conversion at import / card-less profiles | A converted file breaks the hash-verified erase/format gate and immutable originals; a profile needs a card identity (§13 "rules shared by all cards of that camera"). |
| 2026-10-03 | Import sessions merge in the session table and split per photo in Show plan (merges only into the earlier session of the same body and format). Folder and Server destinations run in the screen with a partial result on failure; a server 4xx (not 401/403) fails only that file. Automatic import always goes to this PC's archive. | New job kinds / abort on any error | No job handlers exist for those destinations; §13 lists errors per file; the archive is the gated destination for erase/format. |
| 2026-10-03 | Format gate: every photo on the card must be verified by the job's own import records; non-photo files are listed in the typed confirmation, not blocking; the card is re-listed right before SHFormatDrive, behind a typed confirmation of the card name; a card that leaves needs a new check. | Count only DCIM photos / block on any file | Sony and Canon cards always carry camera files; §8.6 and DESIGN §4. |
| 2026-10-03 | (Partly superseded by the 2026-10-26 Reorganize job row: a plan its job paused, cancelled or failed is left to that job, not completed at the next open.) Archive manager: Overview (tree, tiles, charts, mass operations on the tree selection narrowed by a Camera/Status/Tag filter) and Maintenance (health with one fix per line, recent runs, duplicates, orphans); duplicates/orphans searches and retag run in-screen, cancellable and logged; rename apply is journaled and completed at the next open; Maintenance adds a database backup. No Merge/split yet (Delete… and Trash… exist since 2026-10-06, through the engine's trash). | Engine jobs for every action / Archive.html's single page | No result store for read-only reports; deleting or moving frames needs engine operations (the trash lives in the server). |
| 2026-10-06 | Radio buttons that bind TwoWay are grouped by their shared panel, never by GroupName (kept only for chips in item templates, which bind OneWay). | GroupName on every group | WPF shares a GroupName across every window not yet connected to the screen, so the installer capture (one window per stage, each with its own view model) cross-wired Just me / All users into an endless loop; the same applies to views built in tests and captures. |
| 2026-10-06 | Reading direction is set by ChronosWindow (constructor plus Loc.CultureChanged while shown, applied through the Dispatcher). UiLanguage keeps only a Window.Loaded class handler for plain windows such as FullScreenPreview. The Uploader's WindowDirection and Setup's own code are removed. | Keep three mechanisms (UiLanguage loop plus class handler, Uploader WindowDirection, SetupWindow code) | One place covers the client, Uploader and Setup windows created before or after a language switch. The class handler is still needed for the one non-ChronosWindow window. |
| 2026-10-06 | Toasts are announced with a UIA notification event on the host: errors use ImportantAll (assertive), other notices use All (polite). | LiveSetting on each toast container plus LiveRegionChanged | A toast is a new element, not a text that changes, and the host's peer is always in the UIA tree, whereas an item container's peer may not be. |
| 2026-10-06 | The job bar's live region announces ShellViewModel.JobAnnouncement (job name when it starts, the idle line when the queue empties). JobBar gets a StatusBar peer so the region has a peer. | Announce the job bar text | The bar text changes every second (counter, speed, time left), which is too noisy for a screen reader. This matches the integration rule 'announce states, not progress ticks'. |
| 2026-10-06 | The render job label arrow is chosen at creation by Loc.IsRightToLeft (Jobs.Target.Render / Jobs.Target.RenderRtl, both invariant). | A translatable '{0} → {1}' key that RTL translators change to '←'; or storing title and preset separately | This is the same pattern Import.Session.Time/TimeRtl already uses, it is right in RTL without waiting for translations, and it needs no schema or wire change. The label was already in the creation language through the preset name. |
| 2026-10-06 | Field.Error (an attached string with a read-only HasError) is the shared error state for inputs without a validating binding. PasswordBox triggers on it and on nothing else. | A Validation.HasError trigger on PasswordBox | PasswordBox.Password is not a dependency property, so Validation.HasError can never become true there. The Uploader and the login dialog needed a settable state. |
| 2026-10-06 | The TextBox template no longer applies Padding (TextBoxBase pushes it into PART_ContentHost, confirmed by reading the IL of TextBoxBase.AttachToVisualTree). The leading icon takes Padding as its margin, and fixed 22/24 px offsets apply only when an icon is present. | Keep the Grid margin and cancel the host's padding | The host's Padding is set by the control at every template apply and cannot be overridden from XAML. The placeholder and the text now start at the same x. |
| 2026-10-06 | The Arabic smoke test checks mirroring through FlowDirection values plus one TranslatePoint position check on the rail. | Only pixel or screen-coordinate checks | FlowDirection is what WPF mirrors by. The integration branch's capture fix shows the window content carries the mirror, so TranslatePoint to the window reflects it. |
| 2026-10-06 | The nav rail's RadioButtons keep GroupName 'Rail' (the two lists live in separate item templates) but bind IsChecked one way. | Group by panel as the integration decision says | Panel grouping cannot span two ItemsControls. A one-way binding keeps a shared GroupName from writing another window's selection back into the shell, which is the case the integration rule exists for. |
| 2026-10-06 | Common.CurveReadout is invariant ('{0} → {1}'). | Translatable so RTL languages could use '←' | The curve readout is drawn in a left-to-right island (numbers on an LTR axis), where '←' would point the wrong way. |
| 2026-10-06 | Heatmap month labels: initials only when all 12 abbreviated names start with a cased letter and contain no digit, otherwise culture-formatted month numbers 1-12 | A localized resource list Archive.Chart.MonthInitials, or hard-coded per-culture overrides | Correct for every shipped and future culture with no translation work. It also avoids non-Gregorian month names (fa uses Persian months) and needs no fallback for languages not yet translated. |
| 2026-10-06 | Keep IsEnabled=False on the content behind a dialog and give ListBoxes a template that does not repaint when disabled (the kit's Template.ListBox since the follow-up) | IsHitTestVisible=False plus keyboard containment instead of disabling | Screen readers and access keys still treat the content as disabled. Rows and buttons dim themselves, so the list does not dim twice. |
| 2026-10-06 | (Superseded by the kit follow-up: the charts draw labels in TextMuted and empty cells in Stroke; the aliases are gone.) Fix the chart-label contrast and invisible future months through token aliases scoped to the chart grid and the heatmap (Brush.TextFaint -> Color.TextMuted, Brush.Card -> Color.Stroke) | Edit BarChart/HeatmapStrip (owned by the shared group) or only report the defect | Smallest local equivalent that fixes a major contrast defect now, with no new colours. It follows theme switches through DynamicResource and becomes inert once the kit is fixed. |
| 2026-10-06 | Index health duplicates line: after a duplicates search it shows the groups found (warning with a Mark copies fix); before any search it shows the flagged-copy count ('No copies flagged' / 'n duplicate frames' with Show) | Only reword the line to flagged copies, or hide it until a search has run | The line can never be a green tick while the Duplicates card lists groups, and it keeps the flagged-copy information that already existed. |
| 2026-10-06 | All orphan kinds use the Warning glyph (▲ amber) | Add a neutral/info StatusKind in the shared kit | Every orphan line is an actionable issue with a fix button, and Warning is readable in both themes without a kit change. |
| 2026-10-06 | Archive failures become a toast with the action's title, one localized cause sentence from ArchiveFailures.Cause and a Retry action that re-runs the same command; relink Retry re-opens the folder picker | Open logs as in Shell.ReportError, or retry with the same folder | BRIEF 0.2 rule 6 asks for one sentence plus one action. Retry fits these I/O failures. Re-picking the folder covers both 'drive is back' and 'wrong folder'. |
| 2026-10-06 | (Partly superseded by the 2026-10-26 desktop Reorganize row: Rename is now Reorganize, whose Apply queues a job; the rule stays for the other dialogs.) Dialog failures appear as an error line (✕ Error StatusGlyph, raw text in its tooltip) with no separate Retry button; Apply stays the retry, and a failed apply re-runs the dry run | Add a Retry button to the Rename and Retag dialogs | DESIGN allows two dialog buttons at most. Re-planning shows what is left after a partial or stale apply. |
| 2026-10-06 | Cancel is the default (Enter) button in the Rebuild, Rename and Retag dialogs | No default button, or Apply as default | DESIGN: the safe action is left and default. Enter in the text fields is already handled by EditBehavior. |
| 2026-10-06 | Rebuild counts show '—' with the reason (offline sentence or failure cause) in the tooltip when they cannot be counted | Remove the two count rows when they cannot be counted | The dialog keeps the same shape, and the reason sits next to the value it explains. |
| 2026-10-06 | Rename the Overview/Maintenance segment to 'Health' (new key Archive.View.Health; it: 'Stato') and keep the toolbar's 'Maintenance ▾' | Rename the toolbar menu to 'Tools ▾', or change the English value of Archive.View.Maintenance | BRIEF 12.5 names the toolbar menu Maintenance. A new key makes the missing translations visible in i18n check instead of leaving stale ones. |
| 2026-10-06 | Paths inside sentences are wrapped with the existing Formatting.LeftToRight (LRE/PDF); path-only elements get FlowDirection=LeftToRight with start alignment | LRI/PDI isolates as the review suggested, or Import's BidiText.Ltr | Reuses the app-wide facility already used by Settings, Welcome and Server, and gives the same result for these strings. |
| 2026-10-06 | In RTL the tree swaps its arrow keys, and the year tooltip uses a second key (Tooltips.Archive.YearRowRtl) chosen at runtime | One direction-neutral tooltip using arrow glyphs | Matches WPF TreeView behaviour. Translators of RTL languages get a sentence that already names the right keys. |
| 2026-10-06 | Chart values reach screen readers through AutomationProperties.HelpText built from the bar and month tooltips | Wire ItemActivated/CellActivated to filter the set, or add an automation peer per bar | Not every chart has a matching set filter (format, month). HelpText needs no kit change and keeps the chart's own name. |
| 2026-10-06 | The heatmap scale moves into the card header as '0 ▭ max' (Accent bar with an opacity-mask gradient) and MaxCellSize rises to 32 | Right-align the kit's own scale under the grid | Matches Archive.html and lets the grid use the card's width. |
| 2026-10-06 | The set filter button's accessible name is 'Set filter · ', built from existing keys | AutomationProperties.ItemStatus or HelpText set to the set text | Narrator reads the name first and always, and no new key is needed. |
| 2026-10-06 | A 409 whose settings were changed to different values on both sides opens an explicit prompt, and nothing is sent until the user chooses. Keep mine is destructive and overwrites the server's values. Take server is the safe default (also on Enter or Esc): it applies the server's values as one undoable step, and Ctrl+Z brings the editor's values back. Members changed on one side only still merge silently. The local editor keeps editor-wins for changes made by this PC's own analysis jobs. | Editor-wins merge plus a toast offering to take the server's values; or document editor-wins | BRIEF §14.5 asks for last-writer-wins with an explicit conflict prompt when both sides changed. Editor-wins would silently overwrite another client's change. A modal is allowed for confirmations (§12.1). The safe default loses nothing because the editor's values come back with Ctrl+Z. |
| 2026-10-06 | The Export Sync checkbox sits on its own row under Save to (12 px). | Beside the folder ComboBox as in Export.html | The 194 px field column minus the 10 px scrollbar cannot hold the folder plus 'Sincronizza' or longer translations without clipping. Rules against clipping and for +40 % text width win over the mockup's placement. |
| 2026-10-06 | Export Sync is off by default, stored per sequence in the project's export settings, and travels inside the render job. | On by default, as Export.html shows it checked | BRIEF §14.5 says renders are uploaded on request. Uploads can be large. |
| 2026-10-06 | A render that finishes while the server session is down still queues its send, for the saved session's server. The send waits for credentials and fails visibly on the Jobs screen if they never come back. | Drop it, or keep a separate pending-send store | No silent loss and no new storage; the sync job already waits for credentials. |
| 2026-10-06 | Server sequences whose cached frames are not the server's (different ids or order) open read-only, or trigger a proxy download and then open. Frame changes while the sequence is open make it read-only, with a toast that offers Get proxies. | Edit against the stale list, or block opening outright | Project settings name frames by position (exclusions, hero, keyframes, remap curve). |
| 2026-10-06 | An account without the Edit right opens server sequences read-only. It may still pick a preset to render, without changing the project. | Refuse to open, or let it edit and fail on save | Viewing and rendering are separate rights on the server. |
| 2026-10-06 | The server's job progress shows beside the title in the editor header (glyph, 6 px bar, Cancel), and a failed or cancelled job raises a toast with Retry. | Feed server jobs into the shell's job bar and Jobs screen | The job bar and the Jobs screen list this PC's engine jobs only. BRIEF §11.5 requires cancel to be always available. |
| 2026-10-06 | For a server sequence, Save to, the Encoder row, the encoder name and notices, and the Jobs history link are disabled or hidden, each with a tooltip saying why. Renders are one server job per preset. | Show this PC's encoder and folder | DECISIONS 2026-10-03: the server always writes to the sequence's exports/ and splits batches per preset; the server or its render node picks the encoder. |
| 2026-10-06 | Save-both copies are listed and restored by a Restore settings split button under the Export history line. A restore is one undoable step, and its toast Undo only acts while the restore is still the latest change. | The header menu or the Frames tab | This is the least intrusive place: it is next to render history, it shows only when copies exist, and none of the mockups has room for it elsewhere. |
| 2026-10-06 | Additive API: GET /api/v1/sequences/{id}/analysis/report (Read permission), and UpdateSequenceRequest.HeroFrameId. Settings sent alone move hero_frame_id when heroFrame changes. | Ship the deep report inside the manifest, or have the client resolve the hero frame only | The manifest stays small, and the Library thumbnail follows the hero whoever edits it (the editor, or sync of a local copy). |
| 2026-10-06 | The checkbox's inner gap between box and text stays at the theme's 8 px. | Change the shared CheckBox template to 6 px | The template is shared by the whole app and lives outside this workstream. |
| 2026-10-06 | Render quick action renders the project's export as stored now: the editor's preset, else the advisor's recommended export preset that analyses store as an Auto value, else the default. Sequence-preset bundles (Night sky and others) are not applied by it. | Apply SequencePresets.Generate(...)[0] (a whole bundle of timing, exposure and motion settings) when the project has no explicit export. | The Auto ExportPreset is what the Export tab marks as recommended. Applying a bundle silently would override settings the user never saw (BRIEF §10.4: the advisor never touches manual choices; presets are one click by the user). |
| 2026-10-06 | A remote card's Render and Analyse are posted to the server (POST /api/v1/jobs render or deep-analyse) with the sequence's own project. The tooltip names no preset. | Download the server manifest for each card to name the preset in the tooltip. | Rendering happens where the originals are (BRIEF §14.6–14.7), and a manifest download per tooltip is costly. |
| 2026-10-06 | Delete runs in an in-window dialog shared by the Library and the Archive manager: a dry run with progress, a typed confirmation, a move into the trash with progress, Cancel between whole sequences, and an Undo toast. It is not a Jobs-screen job. Restore runs per entry from Maintenance › Trash… or from the toast. | An ArchiveJobs delete job with checkpoints on the Jobs screen. | The typed confirmation must sit between the dry run and the move, and Undo needs the result at once. It matches the rename dialog, and each sequence moves atomically. |
| 2026-10-06 | The typed confirmation for Delete is the number of sequences that move (Latin digits). | Typing a word such as DELETE or the sequence title. | It is language neutral and shows the user read the count (DESIGN §4 typed confirmation). |
| 2026-10-06 | Trash layout: /.chronos/trash/[-stamp] plus a .json record (index row and renders). Restore re-indexes from the sidecar with the same ids, into the old folder or 'folder (n)'. A folder without its sidecar is adopted under the same id with the record's title, tags, rating and notes; a missing hero frame is dropped. | A trash in the database only, or erasing the files. | BRIEF §0.2 rule 8: nothing is erased, and sidecars stay authoritative. |
| 2026-10-06 | Delete is refused per sequence for an offline archive, the archive root, folders holding other sequences, busy sequences, a foreign sidecar or a missing folder. Busy covers running or paused jobs on the sequence, plus archive-wide Scan, Rebuild, Import, Maintenance and Verify-all on its archive. Sequences with no folder and no frames lose only their rows. | Block only on jobs that name the sequence. | Archive-wide jobs name the archive, not the sequences, and an import's target folders are known only to its plan. |
| 2026-10-06 | Server DELETE maps refusals to codes: 503 archive_offline, 409 sequence_busy (busy, stale plan or lease), 409 archive_root / contains_sequences / sidecar_mismatch / folder_missing / folder_in_use, 404 when the sequence vanished. | A single 409 sequence_busy for every refusal. | Clients show the right sentence, and an offline archive is a retryable service state. |
| 2026-10-06 | (Superseded by the 2026-10-26 desktop Reorganize row: Move… is Reorganize…, still for the sequences of one archive, applied by a job.) Move works on the sequences of one archive at a time, as a new folder layout through MassRenamer with a dry run. | Cross-archive move (copy, verify, then trash the source). | The task names the engine's existing move and rename facilities, and there is no engine operation for a cross-archive move. |
| 2026-10-06 | Saved views are app-scope settings rows (library.view.) listed in a menu next to the layout switch (show, save, rename, delete with Undo). They are not a chip row. | Chips under the toolbar. | Width at 1200 px: the filters already wrap. |
| 2026-10-06 | The timeline is year bands with photos per month above the virtualised card grid, which stays visible. A month (click, or Enter from the keyboard) narrows to its year and scrolls to its first card once. | Replace the grid with a separate timeline list. | It reuses the virtualised grid and keeps the cards in sight (BRIEF §12.2 'timeline (year/month bands with density)'). |
| 2026-10-06 | Origin filter: All origins / On this PC / Only on server. 'Only on server' means server sequences without a copy here; local copies that came from the server count as 'On this PC'. Remote cards count in the Year and Camera choices and in the timeline. | Filter by Sequence.Origin, which would mix local copies into 'Only on server'. | A remote card is what the user cannot open without proxies (BRIEF §4.4 mixed mode). |
| 2026-10-06 | Remote card identity: a Sequence with Origin=Server and SyncState=RemoteOnly built from the server listing. Thumbnails come from the proxy cache, else the server thumb of the hero frame (or first frame, read as one row and remembered). Remote cards do not scrub. | Download the full manifest per card. | It is cheap, and the proxy cache is reused once opened. |
| 2026-10-06 | Status filter adds Rendered, Not rendered and Synced (index columns rendered_count and sync_state). | Keep only the analysed/proxies/verified/warnings states. | Main.html shows 'Status: not rendered', and the brief's saved-view example needs it. |
| 2026-10-06 | Rate and Tags… change only their own field from the current sidecar or index values (EditSequenceInfoAsync). | Write back the whole info from the Library's copy of the row. | The copy can be stale after an editor save or a settings sync; writing it back would undo those and bump the settings version. |
| 2026-10-06 | Quick actions show on hover, on selection and while the keyboard is in the card or row, so Tab reaches them. The selected card's details panel also offers Render. | Hover only. | Keyboard access (DESIGN §4); the editor's frame rows do the same. |
| 2026-10-06 | The Delete confirmation names at most 6 moves and 3 refusals (each with a '+ n more' line), in the UI font and reading direction (ConfirmRequest.IsDetailMonospaced=false). Fingerprints keep the mono, left-to-right detail. | A scrolling detail list. | It stays within a 768 px work area, and names are not fingerprints. |
| 2026-10-06 | Archive dialog templates and their reviewed styles live in one shared dictionary (Archive/ArchiveDialogs.xaml) merged by ArchiveView and LibraryView. | Duplicate the templates in LibraryView. | Delete, Move and Tags… run from both screens, and one copy keeps the Archive review's fixes in both. |
| 2026-10-06 | Delete, Restore, Rate and saved-view failures read as one localized sentence through ArchiveFailures.Cause. The engine's text goes to the log or the tooltip. | Show ex.Message in the toast. | BRIEF §0.2 rule 6, as the Archive manager's review established. |
| 2026-10-06 | The web admin gets a dark theme: DESIGN dark tokens via light-dark(), following the OS setting, with a header toggle remembered per browser | Keep light-only as DESIGN.md §1 and DECISIONS 2026-10-02 say | BRIEF §14.8 says 'light/dark' and the Admin.html mockup has the Switch theme button; CLAUDE.md: the brief wins over the notes, and the mockup wins on looks |
| 2026-10-06 | Tables are ARIA tables whose rows are CSS subgrids; fitColumns() measures the table and hides secondary columns level by level until the rows fit | The mockup's fixed tracks (… 210px) or fixed container-query breakpoints | Fixed widths cannot hold +40% translations (German row actions are about 330 px) or the side-panel state; measuring works for every language and width |
| 2026-10-06 | Self reset is blocked twice: the UI shows Change password on the caller's own row and the server answers 409 'self' | Hide the button in the UI only | A reset revokes every token, the caller's included, so any client could lock the last admin out; the existing 'self' code and message already guard delete and demote |
| 2026-10-06 | The sign-in log uses one audit query with a comma-separated action filter (AuditRepository.ListByActionsAsync) | Two client-side queries merged by time | A single cursor keeps 'Load more' paging correct |
| 2026-10-06 | plural() uses Intl.PluralRules folded to Chronos.Core's categories (two→few; zero→many in Latvian, else other) | Port the C# PluralRules table to JavaScript | Same results as the desktop for the shipped languages with far less duplicated code |
| 2026-10-06 | Settings and archive validation messages are built in the panel from the field label (Admin.Common.Invalid), with a specific message for missing PEM files | Per-setting localized messages from the server (Server area resx) | The server's details already name the field; this keeps the change inside the panel and gives one sentence plus one action |
| 2026-10-06 | The settings Save button moved into the sticky page header, like New user on the Users page | Offset the toast stack above page actions | Toasts can never cover it, and it stays reachable while editing a long form |
| 2026-10-06 | Old single-form count keys stay in the catalogs unused, and new .one/.other keys were added | Rename or rewrite the existing keys | The rules forbid renaming or deleting keys; other cultures keep working until the integrator removes them |
| 2026-10-06 | Empty-state buttons: Clear search; Show all (filtered jobs); Scan (empty jobs, empty charts and format table); a Users link (no render nodes); Refresh (activity, audit) | Leave the sentences without a button | BRIEF §0.2.6 asks for one sentence plus one button; each one is the most useful next step |
| 2026-10-06 | Progress bars mirror in RTL (they fill from the reading start); charts keep a left-to-right axis; paths, templates, logs, IPs and fingerprints stay left to right | Mirror everything, or nothing | Follows the brief's RTL rules: time-axis charts and paths do not mirror, progress follows the reading direction |
| 2026-10-06 | The side panel width is clamp(300px, 26vw, 340px) | A fixed 340 px (mockup) or 320 px (DESIGN) | It keeps the mockup's 340 px at 1440 and gives the table about 28 px more at 1200 |
| 2026-10-06 | Mirror category charts by placing their contents with FromStart inside an element that stays FlowDirection=LeftToRight. This applies to horizontal BarChart rows (labels, bars, values, grid ticks) and StackedBar segments. | Let BarChart and StackedBar inherit RightToLeft so WPF mirrors the whole element. | With the element mirrored, text drawn by DrawText would come out mirrored, and every number label would need a counter-transform. FromStart is already how legends are placed, and the Arabic test's 'every DrawingElement is LTR' rule still holds. |
| 2026-10-06 | Vertical BarChart, HeatmapStrip, SeriesChart, TimelineBands, Filmstrip and CurveEditor stay left to right in RTL. | Mirror every chart that has categories. | The brief rule is that time axes stay LTR. Vertical bars and heatmaps run along days, years or months; horizontal bars and stacked shares have no time axis. |
| 2026-10-06 | Keyboard activation for BarChart, StackedBar and HeatmapStrip exists only while a handler is attached to the chart. Arrows move the item (heatmap in rows and columns, stacked bar by visual side), Home and End jump, Enter and Space activate. The item gets a 2 px Accent outline, a readout and the automation ItemStatus, and the element's system focus rectangle is off. | Gate only the hand cursor and leave the charts mouse-only. | A chart that does something on click but cannot be used from the keyboard fails WCAG 2.1.1. A chart nobody activates stays out of the tab order, as before. |
| 2026-10-06 | Detect handlers by recording the delegates added and removed through the CLR event accessors (TrackActivation). | Read the routed-event handler store by reflection, or add a public IsInteractive property. | The handler store is internal. Accessors cover XAML attributes and += in code. An extra property would duplicate what attaching the handler already says. |
| 2026-10-06 | Move the shared hover-readout, click, cursor and keyboard handling for item charts into DrawingElement as virtual item members (ItemCount, ItemAt, ItemBounds, ItemText, Navigate, Activate). | Copy the cursor and keyboard code into each of the three charts. | The three charts had the same mouse code; one implementation keeps cursor and keyboard behaviour consistent. Visuals without items (filmstrip, curve editor, series chart) are unaffected because the base does nothing when ItemCount is 0. |
| 2026-10-06 | The ListBox template is a keyed ControlTemplate (Template.ListBox). ListView is BasedOn a new template-less ListBox.Base, and the card grid style takes the template through DynamicResource. | Put the Template setter straight into the implicit ListBox style, which ListView was BasedOn. | ListView would then inherit a template without the GridView header row. Visuals.xaml cannot StaticResource into Controls.xaml. |
| 2026-10-06 | Empty heatmap cells use Brush.Stroke. | A new no-data token. | Stroke differs from the Card and Surface fills in both themes, the Archive workaround already used it, and DESIGN forbids new colours. |
| 2026-10-06 | SeriesChart tick labels and TimelineBands captions also move to TextMuted. | Change only BarChart and HeatmapStrip, as the item lists. | They are the same 11 px data labels, with the same AA failure (2.7:1 in light). Editor.html shows chart text in the muted colour. |
| 2026-10-06 | ShellViewModel.Notify takes an optional isError, and the Uploader's private ShowToast does the same. | A separate NotifyFailure method. | Some outcomes decide the flag at run time (format Failed versus Formatted, eject Ejected versus InUse or Failed, server job Failed versus Cancelled). One parameter handles those without branching at the call sites. |
| 2026-10-06 | Count as failures: refusals that leave the user's action undone (cache folder not owned, card changed before format, 'Choose a sequence first', conflict changed). Keep as notices: 'Nothing found', a cancelled server job and the editor's 'frames changed, read-only' toast. | Mark only exceptions as errors. | An assertive announcement fits anything the user asked for that did not happen. Empty results and cancellations the user asked for are not failures. |
| 2026-10-06 | Editor.Optimise.ChangeRtl copies the existing TimeRtl/RenderRtl pattern exactly ('{0}: {1} ← {2}', no bidi marks). | Put RLM marks around the arrow so values made of Latin letters keep their order. | The task fixed the value and the pattern. The Latin-run caveat applies to all three RTL keys and is reported as one remaining issue. |
| 2026-10-06 | TextBox.Number goes back to the default Padding. Import TextBox.Small (4,0) and the Import session-title box (8,0 at 26 px) stay compact. | Reset every override to the default. | The Number override (8,0) existed only to undo the old double padding. The other two are deliberately compact: four digits fit in 42 px, and 8 px plus the 2 px text margin lines up with the 26 px row buttons. |
| 2026-10-06 | Icon-only accessible names longer than three words (rail toggle, archive year expander) get new two-word keys. The sentence stays as the tooltip. | Keep binding the name to the tooltip. | The item asks for names of at most 3 words from a resource; the tooltip carries the explanation. |
| 2026-10-06 | The culture-switching optimise-line test lives in EditorSmokeTests ([Serial]), not EditorTextTests. | Keep it next to the other EditorText tests. | Test classes run in parallel, and switching Loc culture would race with English assertions in other classes. |
| 2026-10-06 | Fix the tests, not the sync engine: wait for the comparison an event starts to finish, signalled by SyncService.Changed, and assert on that settled state | Poll with a deadline until the final state holds (settings arrived AND error cleared), or make the engine's two writes atomic | The engine is correct: Changed is its documented end-of-comparison contract, and the Server screen reloads on it. Waiting for Changed is deterministic and keeps every assertion. A regression fails immediately, not after a 30 s timeout. It also checks that the state is consistent when Changed fires. Atomic writes are impossible across the index and project.json. |
| 2026-10-06 | KeepingProxiesOffline waits for the agent's own background download job to reach Done | Poll the row status until ProxiesOnly | Done is the engine's last write after the handler stored the cache and the link. Polling the status would turn the assertion into the wait condition. |
| 2026-10-06 | FailedComparisonsAreRetried waits for the agent's Changed raised with a non-null Snapshot (TaskCompletionSource with RunContinuationsAsynchronously) | Reorder the agent's writes so LastError is cleared before Snapshot is stored | Changed is the agent's contract, and SyncHost reads both values on it. Continuations must run off the agent loop, otherwise the test would end up disposing the agent from inside its own loop. |
| 2026-10-06 | Log download: reuse FileResponses.Serve (fixed-length, range-capable FileSlice) with the length listed at request time | Copy the log to a temp file first, or stream to EOF without a Content-Length | It reuses an existing facility, keeps Range resume working, has no extra I/O, and the response stays self-consistent while the logger keeps appending. |
| 2026-10-06 | The regression test fills its server's log with about 2 MB up front, then logs one line about every 1 ms through the server's FileLoggerProvider only, on a LongRunning thread | A tight logging loop through ILoggerFactory (my first two versions) | The engine log sink is process-wide, so a console or file-lock flood stalled another test's job engine. The throttled version still reproduces the bug in 10 of 10 runs against the old endpoint. |
| 2026-10-06 | Heartbeat test: count the claims the server answered with a DelegatingHandler, then wait for a later beat with a 30 s deadline | Keep the sleeps and widen the 400 ms window | It removes the timing assumption both ways (a false failure on a slow runner, and a false pass on the claim's own touch). It also proves no claim moved the beat. |
| 2026-10-11 | Fields of a meta line are joined with Loc.Separator: " · " in left-to-right languages, " · " between right-to-left marks in right-to-left ones (Loc.SeparatorOf(culture) for texts built in another language) |
Unicode isolates (FSI/PDI) around each field, or a left-to-right island for every meta line | WPF's bidi predates the isolates; without a strong right-to-left character before it, a number after a Latin field ("Canon EOS R5 · 2 h") joins the Latin run (rule W7) and splits its own field; islands would read the fields in left-to-right order. |
| 2026-10-12 | Table cells holding a value with the language's unit (sizes, speeds, times left) follow the reading direction at the end of the cell, like their header, and size columns fit their content; bare numbers (percentages, counts) stay left-to-right islands, right-aligned | Every number cell left to right | Once sizes use the language's units, a left-to-right cell put the unit after the number on screen, so Arabic and Hebrew readers met the unit first ("18,6 كيلوبايت"), and the longer words were cut off. |
| 2026-10-12 | Fields shown in a left-to-right island are joined with Loc.IslandSeparator (" · " between left-to-right marks in right-to-left languages); charts format text with European digits |
The reading-direction separator everywhere; the culture's digit substitution in charts | In the preview's frame data a localized time ends in a right-to-left mark ("6:03:41 م"), so the next field's number read as part of it and swapped places with the dot; with the UI culture, chart text after Arabic words drew Arabic-Indic digits while every text block shows European ones. |
| 2026-10-11 | LocalizedViewModel.OnLanguageChanged is the hook for texts kept in objects: the editor makes its tabs' charts, Auto chips, markers and info line again; Jobs refreshes rows, chips and the job bar; Archive reads again; Import rebuilds its session table and device list |
Re-create every section after a language switch, or ask for a restart | BRIEF §16 switches language without restart; a running job's bar line and an open editor's legend otherwise stayed in the old language until their next change. |
| 2026-10-11 | Desktop sizes use the Common.Size.* formats, like the Setup and the Uploader |
Hard-coded B, KB, MB, GB, TB, PB | Several languages write the units in their own script or words (КБ, bayt, كيلوبايت); every UI string is a resource. |
| 2026-10-11 | CI artifact uploads continue on error with short retention (test results 7 days, Windows programs 3); screenshots reach the screenshots job through the Actions cache | Keep failing jobs on a full artifact storage, or push the screenshots from the build job | A full storage quota failed jobs whose checks had passed; the cache has its own limit, and the build job keeps its read-only token. |
| 2026-10-12 | A restore staged in Settings › Advanced runs on the files before the index opens. The staged copy must pass PRAGMA quick_check (before migration), then open and migrate in a scratch copy. The index it replaces is kept as a VACUUM INTO copy among the daily ones, or, when it cannot be read, copied whole with its WAL as chronos-replaced-<stamp>.db outside the rotation. The staged file is renamed over the index, which consumes it. |
Swap the open index after a fresh backup; move a broken index into the rotation; delete the staged file after the swap | A restore exists for an index that no longer opens. A broken copy in the rotation would push a good daily copy out. A separate delete that fails would apply the same copy again at the next start. |
| 2026-10-12 | Settings › Rendering › Parallelism Auto is the job engine's default, half the logical cores (BRIEF §14.6), with each job's own decode and analysis thread counts. A value the user sets is the number of workers and also caps those threads. The memory budget is this PC's total: each job's frame window gets budget ÷ workers. | Auto = cores minus four (mockup tooltip) driving the workers and capping every job | Cores minus four left a 4-core laptop with one worker, so one render blocked scans, thumbnails and sync. The brief fixes the default (behaviour: brief wins). Dividing the budget keeps concurrent renders within it. |
| 2026-10-12 | Reset all and Import settings change only this PC's settings. The open archive's archive.json changes only through its own Archive rows, and Archive › Reset section first asks, naming the archive. | Push this PC's values into the open archive after a reset or an import | archive.json is shared with the server and other PCs: resetting one PC must not replace an admin's naming or proxy policy for everyone. |
| 2026-10-12 | Settings › Archive edits only the archive registered at this PC's archive folder. When the folder changes, an archive already there is registered (as at start) and gets an incremental scan. With none there, the rows edit the defaults of new archives. | Fall back to the first archive of the index | Edits otherwise landed in another archive's archive.json. |
| 2026-10-12 | Proxy and thumbnail sizes outside the Settings presets (the admin panel's 3840, any valid size in archive.json) join the list with their number. | Show the nearest preset | The row must show the archive's real policy. |
| 2026-10-12 | When an archive's settings are edited, a blank or overlong name in its archive.json becomes the folder's name (the root for a drive root) or is shortened to 100 characters, as at creation. A name the edit sets is still checked as given. | Refuse every edit until the archive is renamed | Desktop archives created at a drive root before names were checked carry an empty name, which failed every Settings › Archive edit. |
| 2026-10-12 | PUT /api/v1/archive/settings answers 409 archive_busy while another process holds the settings lease, and 409 archive_manifest for a damaged, newer-format or foreign archive.json. | 409 sequence_busy and an unmapped 500 | The admin reads what is wrong; the old message spoke of a sequence. |
| 2026-10-12 | Archive › Maintenance › Restore database… opens Settings › Advanced, where the restore lives. | A second restore flow on the Archive screen | BRIEF §12.5 lists restore under Maintenance and §6.2 under Settings › Advanced: one flow reached from both places. |
| 2026-10-12 | Background priority raises the interface thread to AboveNormal while Chronos is the active app, instead of lowering the jobs. | Lower the job threads' priority | Jobs run on shared pool threads whose priority cannot be set per job. |
| 2026-10-12 | The quality profile maps to the render preparation long edge (Best 1024, Balanced 512, Fast 256), the read-ahead (8 for Best, else 4) and the optical-flow quality of projects that set none. | Change the spill policy per profile | Best 'doubles sampling' and Fast is for previews, as the tooltips say; spilling stays governed by the memory budget. |
| 2026-10-12 | (Superseded by the 2026-10-26 index backup row: the copies are the Backup jobs of the index-backup schedule; the daily loop is gone.) Index backups: a VACUUM INTO copy at start when the newest is a day old, then checked hourly, the newest three kept, on the desktop and on a server using SQLite. PostgreSQL servers use PostgreSQL's own tools. |
A fixed nightly time | A desktop is rarely running at night, so a fixed time would rarely fire; the brief's 'nightly ×3' is met as 'daily ×3'. |
| 2026-10-12 | Maintenance vacuums the SQLite index only when at least 10 % of it is free pages; the dry run reports the reclaimable size. | Vacuum on every run | Rewriting a large index for a few pages holds every writer for nothing. |
| 2026-10-12 | Settings › Formats Install opens the Microsoft Store page of the missing extension (ms-windows-store:), falling back to its web page. | Download or bundle codecs | No external processes except OS dialogs (BRIEF §8.6); the Store is the OS route for HEIF/HEVC/RAW extensions. |
| 2026-10-12 | Settings › Archive rows show and edit the open archive's archive.json and also seed the archives this PC creates later. The rescan interval is a PC setting. | Keep separate 'defaults for new archives' rows | One set of rows matches Settings.html; the archive is the source of truth (BRIEF §7). |
| 2026-10-12 | (Partly superseded by the deployment guidance row below: a proxy is listed by its own fixed address, never a Docker subnet or gateway; Docker's port publishing relays IPv6 clients and the host's own connections from the gateway.) TLS mode proxy honours X-Forwarded-For/Proto/Host only from CHRONOS_TRUSTED_PROXIES (new variable, also in server.json: IP addresses or CIDR networks), by default loopback only. The admin panel shows a Not via proxy chip (Dashboard, Settings) when a page did not come through a trusted proxy over HTTPS, and a cookie sign-in refused for that reason answers proxy_untrusted, naming the variable. |
Trust every peer (as before), or default to loopback plus the RFC 1918 and ULA networks | BRIEF §14.2 keys the 5/min sign-in limit and the audit address on the client IP. Home-network clients reach the HTTP port directly from private addresses (Docker's port publishing keeps them), so trusting private networks let exactly them choose their own address. A proxy in another container is listed by its own fixed address. |
| 2026-10-12 | CHRONOS_PUBLIC_HTTP_PORT and CHRONOS_PUBLIC_HTTPS_PORT (optional, 1–65535) name the host ports a container's ports are published on. The admin panel's HTTP→HTTPS redirect and the LAN beacon use them, otherwise the bound ports. LAN discovery from a container needs host networking (documented, with PostgreSQL then published on loopback). |
Drop the redirect, or always advertise the bound ports | The Unraid template lets users remap ports (8443 is often taken), and the redirect and beacon otherwise named the container's internal port. |
| 2026-10-12 | Windows data folder: a protected DACL (SYSTEM, Administrators, the server's account; nothing inherited), re-applied at start. The folder and everything in it must be owned by those accounts and contain no symbolic link or junction, checked before the ACL is touched; otherwise the server refuses to start and names the entry. server.json is read only after its owner is checked on the open handle. Secrets (initial-admin-password.txt, tls/server.pfx) are deleted and created anew with an explicit private DACL; elsewhere they get mode 0600. On Windows this replaces the 'owner-only file' wording of the 2026-10-02 sign-in row. |
Reset foreign owners to Administrators, or keep %ProgramData%'s inherited ACL | A folder or file another user created keeps its owner's WRITE_DAC whatever the DACL says, and its contents (server.json, chronos.db, server.pfx) are theirs, so resetting the owner would launder them. A link would carry the ACL rewrite and the server's writes elsewhere. |
| 2026-10-12 | --install-service registers the LocalSystem service only from a program folder (and, under dotnet, a host folder) inside %ProgramFiles% or %ProgramFiles(x86)%, where no ACL entry gives change rights to an account other than SYSTEM, Administrators, TrustedInstaller or the registering administrator. Otherwise it exits 1 with a localized reason. |
Register from anywhere, or only warn | A SYSTEM service runs whatever sits at its image path. A per-user install or a zip unpacked elsewhere would hand SYSTEM to any program of that user (CWE-732). |
| 2026-10-12 | Windows archive: a folder the server creates (default C:\ChronosArchive) gets a protected DACL: SYSTEM, Administrators and the server's account change it, Users read it. A .chronos folder the server creates is private. An existing archive that other accounts can change (owner or ACL) is left as it is and logged as a warning at every start. |
Inherit C:\'s ACL (Authenticated Users: modify), or rewrite existing archives' ACLs |
Whoever can write where the SYSTEM service stages and moves uploads can put a junction in place of a folder and redirect those writes (CWE-59). An existing archive's ACL is its owner's choice: adopted archives often belong to a desktop user. |
| 2026-10-12 | Container entrypoint: an archive root that PUID:PGID cannot write is given to them (that folder only, chown without -R) when it is empty or owned by root, as Docker creates a missing bind source. Any other unwritable root, and any existing .chronos folder or subfolder they cannot write, stops the container with a one-line error and is never chowned. The data folder is ${CHRONOS_DATA_PATH:-/data}. This amends the 2026-10-02 row '/archive only checked for write access'. |
Recursive chown, or a warning followed by a crash loop | A fresh install never became healthy. The archive may hold terabytes, so its contents are never chowned. |
| 2026-10-12 | Screenshot diff (Chronos.Tools screenshots diff): a pixel differs when one RGBA channel moves by more than 8 of 255; a screen fails when more than 0.05 % of its pixels differ, when its size changed, when it cannot be read, or when its baseline has no screenshot; differing pixels are drawn magenta over the faded baseline in <screen>-diff.png |
Exact pixel equality; a perceptual metric (SSIM) | Anti-aliased edges move a few levels between runs; 0.05 % (about 650 pixels of 1440×900) absorbs the measured latency and last-sync time while a moved control, a new colour or a missing picture exceed it; a per-pixel rule is easy to explain and to check by eye in the diff image. |
| 2026-10-12 | A screenshot without a baseline fails as soon as tests/visual/baselines holds any PNG; before the first baselines the step passes with a warning and a bold job-summary line saying it compared nothing |
Always only warn; always fail; a --require-baselines switch in ci.yml |
Warn-only left every screen, and any screen added later, ungated for good; failing before any baseline exists would keep CI red until a Windows run produced them; a rule that arms itself needs no switch to remember. |
| 2026-10-12 | (Superseded by the 2026-11-04 baselines row: the baselines are captured on the development PC and the ci-screenshots branch is gone.) Baselines are accepted only from CI's ci-screenshots branch (screenshots accept), never from a local capture; the first set is accepted from the first green windows-latest run whose code captures at SampleData.Now, after the review-fix branches merge, so this change commits none |
Commit the current ci-screenshots pictures now; capture locally |
Fonts, scaling and time zone differ per machine and Linux cannot run the WPF capture; the current ci-screenshots commit (of 261ab46) predates the fixed clock, so its times and dates ("12:18 AM", sequences dated from the capture day) would fail every such screen, and parallel branches still change screens. |
| 2026-10-12 | --capture runs on a fixed clock (SampleData.Now, 2026-10-02 10:18 UTC; AppClock.Today frozen for screens laid out around today), English formats and Motion off (indeterminate bars stand still) |
Mask the changing regions per screen in the diff | The same code then draws the same pixels on any day, so the diff needs no masks; only a measured latency and the last sync time remain, a few dozen pixels. |
| 2026-10-12 | Media Foundation playback (BRIEF §20.2) is checked by separate tests: MediaPlayer opens the software H.264 output (and the hardware HEVC Main10 output where an encoder and an HEVC decoder exist), skipped with the reason where Windows Media Player is missing or WPF reports it unusable; a Media Foundation source reader decodes the first frame to the encoded picture on every Windows with Media Foundation | One test that logs and passes without Windows Media Player; playback only in the manual release test | Windows Server runners may lack wmp.dll; a skip shows that the MediaPlayer layer did not run, and the source reader still proves the file decodes. |
| 2026-10-12 | CI installer job on a clean windows-latest: packs 1.0.0 and 1.0.1 installers from the published programs and checks silent install, run, the Add/Remove Programs entry, shortcuts and the .chronos file type, upgrade in place (a file only in 1.0.0 must go, user data kept), the Uploader-only installer, uninstall and the documented exit codes (.github/scripts/installer-test.ps1) |
Leave it to the manual release test | BRIEF §18 behaviour can only be proven by running the real installers; a clean runner is the closest thing to a user's PC. |
| 2026-10-12 | The CI PostgreSQL 16/17 service containers are prepared by .github/scripts/postgres-ci-setup.sh (MD5, cleartext and trust roles with pg_hba lines ahead of SCRAM, TLS with a self-signed certificate for localhost and 127.0.0.1); CHRONOS_TEST_PG_TLS=1 turns a server refusing TLS into a failure |
A custom image; leave those tests skipping | BRIEF §6.3 requires every authentication method and TLS mode against the service containers; the official image starts with SCRAM only and TLS off, and the skips looked green. |
| 2026-10-12 | Tests that change or observe process-wide state (the UI language, unobserved task exceptions) live in [Serial] classes; the App and Core test programs switch back to English and then fail a non-serial test that left English (TestContext.Current, an AsyncLocal) |
Pass the culture into the code under test; only document the rule | The code under test reads Loc like the app does; the guard catches the next such test at the switch, without leaving the classes beside it in the other language. |
| 2026-10-12 | A host takes a frame's pixels from its proxy whenever its decoders cannot read the original (ArchiveImages.NeedsProxy: no decoder, or only a HEIF's embedded previews). Renders and analyses pick the proxy themselves, and thumbnails of such frames are rebuilt from it. |
A "use proxies" choice left to the user | BRIEF §2.3, §8.1 and §8.5: the server keeps HEIF originals and relies on proxies made by a Windows client or render node. |
| 2026-10-12 | The server asks for proxies (ManifestFrame.WantsProxy, made as SequenceManifest.Proxies / ClaimedJob.Proxies say) of every format its managed decoders cannot read: HEIF, AVIF, and also WebP, which §8.1 lists as metadata only on the server. It takes them with PUT /api/v1/frames/{id}/proxy (Edit or RenderNode right): a JPEG of at most 64 MiB that decodes, with the frame's Exif capture time and the policy's size. A refusal of one proxy answers 422 (invalid_proxy, proxy_mismatch, proxy_too_small, proxy_not_wanted, the last one also for frames the server decodes itself or that are missing or damaged); 409 proxies_disabled concerns all proxies. |
Proxies for HEIF only; a Proxies job a node claims; 409 for proxy_not_wanted | One rule for every host. A WebP proxy costs a client nothing and gives the server pixels it otherwise lacks. Clients stop a pass on 409 and go on after a 422. |
| 2026-10-12 | Desktop uploads make and send the wanted proxies after the originals and count them with the originals the server lacks. A render node sends the ones it can make from the originals it fetched after its job. Wanted frames are matched to this PC's originals by SHA-256, or, for an original not hashed yet, by size in the count; the upload then uses the hash it computes. | Match by file name; hash adopted folders during the comparison | The server renames uploads with its own template, and the comparison must stay cheap (adopted frames stay unhashed until Verify, 2026-10-02). |
| 2026-10-12 | Client migration 0006 adds sync_links.diff_remote_updated_at. While the copy may make proxies for the server (some were counted, or it holds originals the server cannot decode and this PC can), the link keeps the server's update time of the last comparison and is compared again when that time moves. |
Store the ProxiesBuilt bit; a wanted-proxies counter in SequenceDto; in-memory only |
Proxy arrivals and policy changes leave the frame counters alone, but they always change the update time through the follow-up passes. The bit misses partial arrivals and policy switches, a per-sequence counter costs the server a frame scan in every listing, and memory is lost on restart. Numbered 0006 so it does not clash with WS-C1's 0005 (renumber if another branch takes 0006). |
| 2026-10-12 | The proxy pass drops a HEIF proxy whose long edge is under 90 % of the policy's for the frame (the frame's own size when smaller, or at full size), and the server refuses one sent that small (422 proxy_too_small). Frames of unknown size are not judged. |
Exact size; keep the proxies earlier versions made | Earlier versions made thumbnail-sized proxies here from previews. The slack spares decoders that crop a few pixels, and a small original of unknown size would otherwise be refused forever. Older archives get the check on their next proxy pass (new frames, an arriving proxy, or a Proxies job queued by an administrator). |
| 2026-10-12 | Render nodes skip frames flagged missing, corrupt or excluded, fetch originals the server has not hashed into the job folder with a two-attempt size check, and keep the server's Undecodable flag except for a format the server cannot decode and the node can. | Fail the job; queue a Verify first; trust only the node's decoders | The node renders the same frames as the server's own render (§11, §14.7). |
| 2026-10-12 | (Superseded by the 2026-10-26 system schedules and scan at start rows: the archive-scan schedule, run once at start.) The server queues an incremental archive scan at start and every 10 minutes at background priority, except while a scan or rebuild of that archive is queued, running or paused. |
Rescans only when an administrator asks | BRIEF §7: polling by mtime and size, the desktop's rhythm. |
| 2026-10-12 | Mass rename carries the sequences nested in a folder that moves (RenameStep.Carried, listed in the dry run). Selected inner sequences move out first, and a target inside a sequence folder or another target is refused (NestedRenameException). A moving step holds the sequence leases, then the thumbnail leases, of itself and of the sequences it carries, by id, until their sidecars and index rows follow; they are journaled together. |
Refuse to rename folders that hold sequences; lock only the moving sequence | The index must follow the files (§7), one sequence is never nested in another, and no ingest, editor save or thumbnail pass writes in a folder while it moves. |
| 2026-10-12 | Sync applies the server's payload to a local sequence in one step under the sequence lease, and only while the local settings version is still the one compared. If an edit was saved in the meantime, nothing is written and the change is settled as a conflict, never overwritten. | Apply after the fact; last writer wins | BRIEF §14.5: neither side's edit is lost unseen. |
| 2026-10-12 | Monetization is a build switch: ChronosAdsEnabled (Directory.Build.props, default false) is stamped into the assembly metadata and read by ProductFeatures.AdsEnabled; without it the usage counts consent is not shown at first run or in Settings, and the Settings search does not find it |
Remove the consent until Phase 9, or a conditional-compilation constant | BRIEF §21 ships monetization disabled until the human sets ChronosAdsEnabled=true; assembly metadata needs no #if, and the setting stays ready for when it is enabled. |
| 2026-10-12 | (Partly superseded by the 2026-10-26 desktop toasts row: a schedule's background run that fails is said, unless it is upkeep.) Job endings that raise a toast: finished renders, deep analyses, verifies, rebuilds, maintenance, uploads, moves and adoptions, and every failure except upkeep (scan, thumbnails, proxies, light analysis). Background-priority jobs, cancelled jobs, finished imports (the Import screen says them) and finished downloads (Library card, Server row) stay silent | Toast every job ending | The scan every 10 minutes and the work queued behind an import would bury the endings the user asked for (BRIEF §12.1 "toasts … for job completion"). |
| 2026-10-12 | Finished jobs of one kind wait until no non-background job of that kind is queued or running; then one toast says how many ("12 jobs finished", action Jobs). Paused jobs do not hold the batch. Failures are said at the end of the update that brought them, several in one toast | One toast per job; also wait for paused jobs | Server › Upload all queues one upload per sequence, which made 100 toasts and 100 Windows notifications; uploads paused on a metered network would hold the batch's toast indefinitely. |
| 2026-10-12 | A click on a Windows notification restores the window. It runs the toast's action only when the toast opts in (Toast.RunsFromNotification: card detected → Import, interrupted import → Resume, job finished → Open, navigation to Import or Jobs) and it is the only notification shown since the tray icon appeared |
Run every toast's action; track which balloon was clicked | People click a notification to bring the window back, so a Cancel, Undo or Retry there would act before they read why; NIN_BALLOONUSERCLICK does not say which of several notifications was clicked. |
| 2026-10-12 | Toasts also become Windows notifications while no Chronos window is active, not only while the window is minimised or hidden; Settings › General › Notifications turns them off | Only when minimised, as BRIEF §12.1 words it | A window behind another program is as unseen as a minimised one; card prompts (§12.4) and job endings would expire unseen after 8 s. |
| 2026-10-12 | Settings › General › Startup writes the HKCU Run value Chronos = "<exe>" --minimized. The window starts minimised, and its first restore brings back the saved maximised state. The value counts as on only when it starts this executable; it is rewritten only when an update renamed the program in this copy's folder, and only the copy it starts removes it. Portable copies hide the row and write nothing to the registry |
Scheduled task; one value per copy; rewrite the value at every start | The Run key is what Task Manager's Startup tab shows and turns off (as for the Uploader). One value cannot serve two copies, and a copy that merely starts must not take it over. Portable mode keeps everything under .\data (BRIEF §6.2). |
| 2026-10-12 | (Superseded by the sign-in entry cleanup row below: a value is removed only when it starts a program the install log lists.) The uninstaller removes the client's and the Uploader's HKCU Run values when their command starts a program in the folder it removes (StartupCommand in Chronos.Core is shared by the programs and Setup) |
Leave them; remove them whatever they start | Windows would otherwise keep a sign-in entry that points at a deleted exe; another copy's entry is not this uninstaller's to remove. |
| 2026-10-12 | The editor's 1:1 view moves from Ctrl+1 to Ctrl+Shift+1 (tooltip key Tooltips.Editor.Preview.OneToOne). Ctrl+1…6 (number row and keypad) and Ctrl+, open the rail's sections and do nothing behind the first-run dialog |
Change the rail's shortcuts instead | The rail tooltips already listed Ctrl+1…6 (BRIEF §12.1 "standard shortcuts, listed in tooltips"); section shortcuts must work everywhere, the 1:1 view only inside the editor. |
| 2026-10-12 | Rail badges: Jobs counts running or paused jobs plus failures not yet seen on the Jobs screen (which also turn the idle taskbar button red). Server counts sync conflicts. Library counts the sequences of this PC flagged with warnings (the Warnings filter), recounted after analyses. Archive counts the index health lines that need attention, set when the Archive screen reads its figures | Badge running jobs only; read the archive figures at start for the Archive badge | BRIEF §12.1 asks for "badge counts (warnings, running jobs)", and DESIGN §4 defines the badge as the count of things needing attention. The Archive figures are a heavy read that the screen already does when it opens. |
| 2026-10-12 | The taskbar button uses WPF's Window.TaskbarItemInfo, bound to the shell: the job bar's progress, an indeterminate bar while the total is unknown, and red while a failure waits unseen |
Chronos.Core.Windows/Shell/TaskbarProgress |
WPF already wraps ITaskbarList3 for its windows, and a binding needs no window-handle plumbing. |
| 2026-10-12 | Toasts and failure lines in WS-F say why an action failed with a catalog sentence chosen by cause: ErrorText.ForServer for requests to the signed-in server (the server's own localized message, else untrusted certificate, else not answering, else 'Something went wrong.'), ImportFailures.Check/Erase for card checks and deletes, ArchiveFailures.Cause for local saves. ex.Message stays in the log only. |
Show ex.Message as the toast's second line |
BRIEF §0.2 rules 5–6: framework and OS messages are technical English under a translated title. |
| 2026-10-12 | The editor's own save and open failures are a typed EditorException (an IOException; ProxiesOutdatedException derives from it) whose message is already the catalog sentence, and the save toast shows it before any mapping by exception type. A project from a newer Chronos reads as Editor.Error.Project. |
Map every save failure by type (ErrorText.ForServer / ArchiveFailures.Cause) |
Frames changed on the server, a 409 after the last retry, a gone sequence or a read-only account are I/O or invalid-operation failures by type, so mapping by type said 'The server does not answer' or 'Something went wrong' instead of what happened. |
| 2026-10-12 | Keys whose count travels as data (analysis findings, advisor reasons) are plural stems whose count is their first argument, resolved by Loc.Text; a fractional or non-numeric count takes other. A text with two or more counts is written as labels ('Frames: 300, warnings: 2', 'Copied: 40 · failed: 2'). |
A count index stored with each finding, or plural forms for every count of a multi-count text | One rule keeps stored deep reports and project reasons valid. Labels agree with no number in any language, and a cross product of plural forms is unworkable for translators. |
| 2026-10-12 | i18n check fails on an English text that puts a number before a counted noun without plural forms (CountedNoun), and on a tally of two or more counts followed by participles or adjectives (CountedTally). A single '{0} failed' or '{0} missing' is not flagged. |
Flag every placeholder followed by a participle | Before a single participle the placeholder is as often a name ('Import of {0} failed', a job kind in '{0} queued') or a size ('{0} missing') as a count, so CI would fail on correct texts. |
| 2026-10-12 | Where the English reads correctly with a bare count and a mockup fixes that English (Uploader progress line), or where the key belongs to another area that needs no rewording in English (admin dashboard upload total), only the Italian takes the label form. | Reword the English as labels too and drop the other translations | Mockup wins for looks; the defect is only in languages whose participles agree with the number. |
| 2026-10-12 | The Archive screen keeps 'which archive was read' (_readId) apart from availability. Until the picked archive is read, Rebuild and the online-only commands wait, and their tooltips say 'Wait until the archive is read.'. The previous archive's figures for the rebuild dialog, its health fixes and its search results are cleared, and a running search is cancelled. |
Force the picked archive Offline until it is probed | Offline is a claim about the volume: the rebuild dialog told the user that a healthy archive was offline, with the previous archive's count, and kept Rebuild disabled for the life of the dialog. |
| 2026-10-12 | A replaced import result is disposed by the Result setter, and a just-queued import job is read back once after its id is recorded. |
Dispose only in Finish; rely on job events | New import and a source change replace the result too, and a job that ends before its id is recorded (destination offline) sends its events before the screen listens. |
| 2026-10-12 | Offering and completing a render upload (POST /sequences/{id}/renders, /renders/{uploadId}/complete) needs the Edit permission |
Upload or Edit, as for frame uploads | A render output counts against no quota and changes what the sequence shows to everyone. Clients already offer Send exports only with Upload plus Edit, so no flow breaks. |
| 2026-10-12 | A client that imports a card into the server reports it through POST /api/v1/uploads/cards (Upload permission). The server republishes each report as cardEvent, naming the account and client. A server without the endpoint (404) gets no further reports |
Server-side detection from upload session keys | The server sees single uploads, not the card, the plan's size or when the import ends. §14.3 names the event but not its source. |
| 2026-10-12 | (Partly superseded by the 2026-11-03 portable form row: project versions store every position parked by photo; project.json and a workspace's working state keep positions.) Project frame positions (exclusions, hero, camera keyframes) stay positions in project.json. When the index takes a sidecar in which frames were only inserted, they move with their frames, inside the index transaction and under the sequence lease, without a new settings version. project.json follows unless it was written since. Any other frame change leaves them as they are |
Store exclusions and the hero by frame id; bump settings_version on a move |
Keeps the project format and old projects. Each copy (server, synced PC) moves its own positions when it receives the same frames, whereas a version bump would make sync push a move the other copy then makes again. The lease makes a local editor's save read the moved positions and merge onto them, and remote editors already go read-only when frames change. |
| 2026-10-12 | A damaged or wrong-size original replaced by a verified re-upload is kept beside it as <name>.damaged-<UTC time> and is never deleted by Chronos |
Delete it after the repair, or move it to the trash | BRIEF §0.2 rule 8 forbids automatic deletion. Scans ignore the name, and the user decides. |
| 2026-10-12 | The Uploader deletes a source only after its own verified upload, not when the server answers that it already holds the content, so such watch-folder files stay | Also delete on "already on the server" | That answer comes without the server re-reading the bytes. BRIEF §15 deletes after a verified upload only. |
| 2026-10-12 | An upload whose target sequence (the requested one, or the one its session key names) already holds its content is free: a repair adds no used bytes, and the quota checks at start and completion skip it | Charge every committed upload | The archive does not grow. used_bytes is never recomputed, so charged repairs drifted it upward and could refuse the repair itself. |
| 2026-10-12 | The upload shortcut and the recovery of a crashed commit accept only an intact copy (no missing or corrupt flag, file present with its size), the target sequence's own copy first. A target that holds the content only in damaged copies always gets the bytes | Any copy in the archive | A client may delete its file on "already exists", and another sequence's copy cannot repair the target's frame. |
| 2026-10-12 | Card events: one account's progress is published at most once a second (sooner reports get 204 and are dropped), and at most 120 card events per account per rolling minute (429 rate_limited beyond). A client gives its last reports 2 s after an import ends, then cancels them |
No server limit; wait for every report (10 s each) | Event queues hold 512 events and drop the oldest, so one upload-only account could push job and sequence events out of every client's queue. An import that was cancelled or lost its server must end at once. |
| 2026-10-12 | A sequence created through POST /api/v1/sequences gets its folder with its first frame, named by the archive's folder template from that frame and the title, like a sequence created by an upload. A sequence that ever held frames is never moved, even one at the archive root whose sidecar is missing |
Create a folder when the sequence is created | The folder template needs the capture date and camera, which only the first photo gives. Moving a root-adopted sequence would drop its photos from the index. |
| 2026-10-12 | Decode tiers are recorded per frame (sidecar tier, previewW/previewH and the PreviewOnly/Undecodable flags; index frames.preview_width/preview_height, sequences.preview_only_count). The light analysis probes headers once per frame of unknown tier; deep analysis, renders and thumbnail/proxy passes correct the tier with what decoding finds |
Decode every frame at indexing; keep tiers in memory | The preview cap, the Library chip and render exclusions (BRIEF §8.2) need the tier on every host and after restarts; a header probe is cheap. |
| 2026-10-12 | Only a file in a format this host decodes natively (JPEG always) is flagged Undecodable when nothing decodes it; other formats keep the unavailable tier without the flag |
Flag every frame without pixels | A HEIF or unsupported RAW on the server is beyond its decoders, not damaged: a render node, a client or a proxy can still provide its pixels. |
| 2026-10-12 | A planned frame that stops decoding during a render shows its nearest planned neighbour (earlier first), is logged (Export.Log.StandIns) and flagged for later renders; the render fails only when no planned frame decodes. Only frames the pipeline asks for get a stand-in |
Fail the render (previous behaviour) | BRIEF §8.2 tier 3 excludes such frames from renders; one file damaged after indexing must not lose a long render, and frames a speed-up skips are never shown. |
| 2026-10-12 | A read error never makes a frame undecodable: ImageDecoder.Decode throws the IOException when a provider could not read the file and none produced pixels; deep passes leave frames they could not read (or that vanished) unflagged, and a frame only an interrupted earlier run found undecodable is decoded again before it is flagged |
Read one byte to check readability before flagging; trust the checkpoint | A sharing violation (antivirus, backup) or a network hiccup would otherwise drop good files from every render; the decoder already knows which providers failed to read. |
| 2026-10-12 | Preview sizes come from probes and unscaled decodes only; a size-limited decode records the tier without a size | Take the size of every decode's preview; keep only the largest seen | A size-limited decode picks the smallest preview that reaches its edge (CR3 PRVW 1620×1080 instead of the 6000×4000 track), so the output cap followed the last render's size. |
| 2026-10-12 | A GoPro GPR's JPEG is looked up in the index when it is not beside the GPR (the archive's JPEG frame with the GPR's original stem and capture time ±1 s) and passed to the decoder as DecodeRequest.Companion; GPRs whose JPEG is indexed later are probed again. Render nodes receive only the GPR originals and decode them through their embedded preview |
Record the JPEG's path on the GPR frame at ingest; copy or move the JPEG into the GPR sequence | BRIEF §8.1 makes the JPEG the server's pixel source; the per-format split (2026-10-02) keeps the JPEG sequence, and an index lookup survives renames and moves without changing ingest, uploads or node manifests. |
| 2026-10-12 | Thumbnails judge a stored embedded preview by its own JPEG header (≥ 320 px), not by the sidecar's preview size | Trust the sidecar's size | The sidecar's size can be a GPR companion's, larger than the preview embedded in the file (BRIEF §8.5). |
| 2026-10-12 | The MakerNote intervalometer hint is read from Panasonic TimerRecording only and kept as FrameFlags.Intervalometer; when most frames carry it, gaps are deliberate pauses and the advisor picks adaptive timing |
Parse Fujifilm and Olympus drive-mode tags; a nullable sidecar field and index column | Nikon keeps the state in its encrypted ShotInfo, and Canon, Sony, Fujifilm and Olympus document no interval-shooting tag (their drive modes list single, continuous and bracketing); a flag bit travels through sidecar, index, sync and protocol without a migration. Frames indexed earlier gain it only when they are adopted again. |
| 2026-10-12 | The RAW size (Canon sRAW/mRAW, Nikon RAW M/S) is read into FrameMetadata but not stored per frame |
A sidecar and index field | Nothing in the brief consumes it beyond parsing; the decode tier already reflects sRAW (the CR2 developer refuses it, so such frames fall to the preview tier with that reason). |
| 2026-10-12 | The MakerNote exposure mode (Canon, Olympus, Fujifilm, Panasonic, Sony) fills ExposureProgram only when Exif has none |
Prefer the vendor value | Exif is the standard field most cameras write; the vendor value covers bodies that leave it out. |
| 2026-10-12 | PRAGMA compile_options is probed once per process, logged and written to the diagnostics bundle; any failure gives an empty list |
Fail opening the index; probe on every open | BRIEF §6.2 makes it informational: Chronos uses no optional SQLite feature (FTS, JSON). |
| 2026-10-12 | Frames both analyses find undecodable are one finding over the union of both lists, at the higher severity | Keep the light finding and drop the deep one | The deep pass also lists missing and corrupt frames and those beyond this host's decoders, which are never flagged; dropping its finding hid them and miscounted. |
| 2026-10-12 | (Partly superseded by the 2026-11-03 project file format 2 and .chronos files rows: a workspace's working state is format 2 with a workspace section; opening a format 1 file gives its settings to the sequence's Main project in the workspace.) A .chronos project file is versioned UTF-8 JSON (chronos-project, formatVersion 1) that names the archive (id, name, path) and the sequence (id, folder, title, frame count) and carries the project.json settings. Opening it finds the sequence by id, otherwise by the same folder in the same archive, and applies the settings as one undo step. |
A self-contained bundle (zip with frames or proxies), or a bare copy of project.json | Frames live in the archive and the index already knows them. A small reference plus settings is what BRIEF §18's file association needs, survives an index rebuild (folder fallback) and never duplicates photos. |
| 2026-10-12 | One Chronos per data folder: a named mutex keyed by the data folder's hash. A later launch hands its arguments over a current-user named pipe. The running one listens from the moment it holds the mutex and queues messages until its window exists. It stops listening when its window closes but keeps the mutex until its services have stopped. A launch that gets no answer waits up to 30 s for it to exit and starts in its place. An elevated instance's mutex counts as 'running'. | Several instances on one data folder, one instance per user, or exiting when the hand-over fails | Two processes would share one SQLite index and job engine. Portable copies have their own data folder. Without the queue and the wait, a file double-clicked during start-up or just after closing was silently dropped. |
| 2026-10-12 | The Server component installs only for all users in a folder inside Program Files or Program Files (x86), not Program Files itself. Upgrading an installation elsewhere (per-user, or all-users in another folder) cannot add it, and a Server it carried is dropped with its service. | A protected DACL set by setup on a custom folder, or only a warning | A LocalSystem service must not start a program a standard user can replace (CWE-732). Program Files' inherited permissions already guarantee that, while rewriting ACLs on arbitrary drives (FAT, network shares, folders with other files) is unreliable. |
| 2026-10-12 | Setup changes only services, sign-in entries and shortcuts that start a program its install log or payload lists, with full paths compared ignoring case. The services are stopped, started, pruned or deleted through the Service Control Manager. An unelevated setup runs /SERVICES=… /NAMES=… /DIR=… in an elevated copy that reads each named service again and refuses one that no longer starts such a program. |
Everything under the install folder; sc.exe; trusting the caller's list | The folder may be shared (D:\Apps, /DIR="C:\Program Files"). No external processes may run. An elevated step must not act on what an unelevated caller merely names. |
| 2026-10-12 | Setup asks programs to close before touching any service. On install it stops the running services, then installs, then prunes services whose program is gone and starts exactly the ones it stopped, whatever their start type. On uninstall it deletes the services only once the programs have closed, just before the files go. Any failure after a stop starts those services again. | Stop or delete services first; start every automatic service after an upgrade | A program refusing to close left the Server stopped, or its service already deleted, and a failed upgrade left it down until reboot. An administrator's deliberately stopped service, or a running demand-start one, keeps its state. |
| 2026-10-12 | User data ownership in %LOCALAPPDATA%\Chronos: entries starting with uploader (also inside logs) are the Uploader's, everything else the desktop app's. 'Remove my data' offers only the data of the uninstalled product's components that no other registered Chronos product (same Publisher) has. A product whose folder or log cannot be read now counts as using all of it. |
Delete the whole folder; hide the option whenever another product is registered | The products share the folder. An offline drive or damaged log must not make a still-installed product's index or upload queue look orphaned. A stale entry only hides the option, which is the safe direction. |
| 2026-10-12 | A shortcut that starts an existing program elsewhere is not created or retargeted, but it is logged. When the product it starts is uninstalled (or an upgrade drops it), the shortcut is pointed at the same program of another installation of the same scope whose log lists it, and only deleted when there is none. | Each product overwrites and deletes the shared 'Chronos Uploader' shortcuts; distinct names per product | Both products ship the Uploader under the same shortcut name. The program that stays installed keeps its Start menu and desktop shortcuts, and neither uninstall touches the other's. |
| 2026-10-12 | Sign-in entry cleanup: SetupRegistry.DeleteStartupEntries removes the client's ('Chronos') and the Uploader's ('Chronos Uploader') Run values, named by Core/IO/StartupCommand, only when they start a program the install log lists. This happens on uninstall, and on an upgrade that drops the program's component; an upgrade that renames the program moves the entry instead (see the sign-in entry move row below). | Every Run value under the folder (first version); the folder-scoped variant of fix/shell-notify | Nothing outside Chronos's own value names and installed programs is touched, so a portable copy in a subfolder keeps its entry. |
| 2026-10-12 | 'Maintenance release.' is written whenever no section or breaking entry was written, also under a title. | Test the output length | release.yml always passes a title, so the old check never fired (BRIEF §19.3). |
| 2026-10-12 | A frame read from its proxy (an original this host cannot decode) records no decode tier: thumbnails drawn from the proxy, and renders or analyses that read it, leave the original's tier and flags as they are. | Record the proxy's tier | The tier describes the original on this host (BRIEF §8.2); a proxy that decodes says nothing about it, and its Undecodable flag must stay so renders keep reading the proxy. |
| 2026-10-12 | Reset all also turns Start with Windows off; importing a settings file leaves it alone. | Keep the sign-in entry on reset | The entry belongs to this copy and lives in the registry, not in the settings file; its default is off, and a settings file from another PC says nothing about this copy. |
| 2026-10-12 | An import from a folder or the server starts with Keep and no eject, whatever Settings › Import says for cards. | Apply the card defaults to every source | Delete, format and eject concern cards only (BRIEF §13); a folder or server source keeps its photos. |
| 2026-10-12 | The restore dialog's summaries read as labels ("Backup: sequences 12, photos 3,400"). | Plural keys | One line counts two things; plural forms select on one number only. |
| 2026-10-12 | A frame whose original this host reads through its proxy (ArchiveImages.NeedsProxy: HEIF on the server) is PreviewOnly only while its own proxy is there. FrameTiers checks the proxy as it writes the sidecar, not when the caller loaded the frames: analyses and the proxy pass bring every such frame in line, renders and thumbnail passes the frames they record a tier for. The original's tier and preview size stay. An analysis advises from the flags as the sidecar holds them after that write, and on the server an arriving proxy also queues a light analysis. |
Never flag those formats on the server; cap at the proxy policy's size; pass a map of proxies taken when the job loaded its frames | BRIEF §8.1, §8.2: the server takes HEIF pixels from client-made proxies, and only a frame rendered from its embedded preview is preview-only. Deep analyses and renders run for hours while proxies arrive: a map taken at load set the flag again after the proxy pass had cleared it, and the deep run's advice capped the preset again. Refines 2026-10-12 'A frame read from its proxy records no decode tier': the tier stays, the flag follows the proxy. |
| 2026-10-12 | A proxy is a frame's only when its Exif capture time is the frame's to the microsecond (a frame without one accepts any). For a frame whose original this host cannot decode, it must also be at least 90 % of the policy's size (ArchiveImages.IsProxyOf). The proxy pass, uploads (proxy_mismatch), thumbnails, renders, analyses, decode tiers, the server's manifests (HasProxy/WantsProxy) and proxy downloads apply this one rule. A proxy that fails it counts as missing, and the next proxy pass removes it. |
Compare to the 100 ns tick; judge size in the proxy pass only; rename proxies when an insert renumbers frames | The index keeps capture times to the microsecond, sidecars and Exif to the tick, so an exact comparison rejected the host's own proxies of frames timed by the file system. Two rules let an analysis count a thumbnail-sized proxy that the proxy pass then deleted. Proxies are named by index and inserts renumber frames. The capture time is what the proxy pass already checks (2026-10-02). |
| 2026-10-12 | analysis.json lists the frames it measured from their proxies (proxyFrames). The deep checkpoint's content key marks only the frames read from proxies, so a sequence read from its originals keeps the key earlier versions wrote. A report that found a frame unreadable while reading its original is stale once the frame is read from a proxy: the light analysis drops the deep status and its warning, and GET /sequences/{id}/analysis/report answers 404 analysis (DeepReports.ReadCurrentAsync), as it does for a report of another frame count or one that does not parse. A partial run made before the proxies arrived starts over. |
Compare the file times of the proxy and the report; queue a deep analysis whenever a proxy arrives; answer 404 only when the AnalyzedDeep status is missing; mark every frame's source in the key | Clock-free and exact: a frame whose proxy itself does not decode keeps its verdict, and the server starts no long deep pass on its own. The status changes only when the background light analysis runs, so remote editors would advise excluding good frames until then. Marking every frame changed every sequence's key, so a server updated during a long deep pass would start it over. |
| 2026-10-12 | A thumbnail or proxy pass resumed inside a sequence sets ThumbsBuilt/ProxiesBuilt only when the frames an earlier run did still have theirs: pack entries and proxy headers are checked again. The proxy pass logs frames waiting for a client's or render node's proxy apart from unreadable ones (Archive.Log.ProxiesDone). |
Carry the earlier run's counts in the job checkpoint | ProxiesBuilt decides what the server asks clients and render nodes for, so it must hold for the whole sequence. The files are the truth, and the check reads only headers and the pack index. |
| 2026-10-12 | The server's manifests say a frame it cannot decode has its proxy only when that frame's own proxy is there, whatever ProxiesBuilt says; for frames it decodes, the flag still answers. Proxy headers (capture time, long edge) are kept in memory per file while its length and write time are unchanged, once the file is 3 s old, for up to 131,072 files. Writes and deletes by this process evict them. |
Clear ThumbsBuilt/ProxiesBuilt whenever frames are added or renumbered; compute the manifest ETag from cheap inputs |
The flag stays set between an insert or append and the next background proxy pass, so frames added meanwhile were never asked for. Every sync refresh (2 min per linked sequence) and every render-node claim lists the manifest, so an unchanged proxy must cost a stat, not a read. The age rule covers file systems whose clocks give a quick rewrite the same write time. |
| 2026-10-12 | When settings move between a PC's copy and its server sequence (pull, push, conflict comparison and resolution), their frame positions (exclusions, hero, camera keyframes) are translated by photo to the receiving copy's frames. A photo matches by SHA-256, or else by size and capture time to the millisecond. A position whose photo the receiving copy lacks waits in project.json as a pendingFrames entry (photo, excluded, hero, keyframes) and becomes a position again when the photo arrives, whether inserted or appended. A hero or keyframe chosen meanwhile wins over a waiting one, even when the newer hero must wait for its own photo, and advice does not fill a hero while one waits. The client translates, since it holds both frame lists. It translates only against frames read as one state with the settings they belong to: this copy's row and frames are read between two reads of the row at the same frames version; the manifest lists the server's frames again while its frames version moved, then under the sequence's row lock; and nothing is sent or applied while either copy's frames keep changing. Pushes send expectedFramesVersion, and PATCH /api/v1/sequences/{id} answers 409 frames_conflict when the frames changed since. A project without the member reads as before. This refines the earlier 2026-10-12 positions row: each copy still moves its own positions on insertion, because what it receives is already in its own order |
Store exclusions, hero and keyframes by frame id; store an ordered frame-list fingerprint with the settings and move only when it matches the pre-insert list; send the source's frame basis and let the server translate; read the manifest in a REPEATABLE READ transaction | Frame ids differ between copies. A fingerprint cannot place positions when the two copies never hold exactly the same frames (each has photos the other lacks). Only the client sees both lists. Positions stay positions, so editors, renders, the remote editor and older projects are unchanged. The data layer has no isolation levels, and SQLite's transactions take the write lock, so the manifest re-reads without a lock first and locks only when commits keep landing. |
| 2026-10-12 | Index commits that write the whole sequence row back (archive sync of a sidecar, the ingest's in-step append, the first frame of an API sequence) read the row with FOR UPDATE |
Re-check the settings version before the upsert; let the server's PATCH take the sequence lease | EditAsync already locks the row, so the same lock serialises the two writers on PostgreSQL (SQLite's write lock already did). A PATCH committed first is then moved with the inserted frames, and a later one is refused by its frames-version check. A lease would block PATCHes on archive I/O. |
| 2026-10-12 | Originals the server has not hashed (adopted, not verified) are downloaded by frame id with a two-attempt size check and hashed on this PC. Such frames are matched to this PC's originals by size and capture time to the millisecond in four places: the comparison counts, the download (not fetched twice), the upload (not sent again) and the proxies the server asks for. In all four a photo is present when any photo of the other side matches it, so several server copies of one photo are held by one local original | Fail the download until the server verifies; have the server queue a Verify of what its scans adopt; pair server and local frames one to one | Same rule as render nodes (row 'Render nodes skip frames…'). A server pointed at an existing folder adopts it unhashed and polls every 10 minutes, and verifying a large archive takes hours. Unhashed local originals were already matched by size. A folder may hold the same photo twice ('IMG_0001.JPG' and 'IMG_0001 (1).JPG'), and the comparison must agree with the download, which never fetches it. |
| 2026-10-12 | The proxy cache records whether each cached file is a proxy or a thumbnail standing in for one (remote.json kinds). A proxy download replaces thumbnails, and files of caches written before kinds were kept, once the server offers the frame's proxy. A cache filled with thumbnails while the server had no proxies counts as stale, so offline caches refresh when the proxies arrive |
Tell thumbnails from proxies by their pixel size; never replace a cached file | A 320-px thumbnail and a small original's proxy can be the same size. Downloading an old cache again once costs less than editing on thumbnails. |
| 2026-10-12 | A sequence waiting for its first frame (empty folder, no frames, not named by the archive root's sidecar) is not at the archive root for the index (ArchiveIndexer.AwaitingFolderAsync). Scans never adopt, re-adopt or rebuild the root under its id. Rebuild and the orphans fix never drop it, the orphans report does not list it missing, verify skips it, scan follow-ups neither analyse it nor draw its images, and maintenance never purges or compacts the root's files under its id. A root sidecar that is damaged or cannot be read names nobody for the index; ingest (ArchiveIngest.AwaitsFolder) still reports it at commit. |
A pending state or placeholder folder in the schema; deciding on folder "" alone; one predicate shared with ingest | POST /api/v1/sequences rows and root-adopted sequences share the empty folder. The 10-minute poll gave an Uploader's new sequence the root's loose photos, also when the root sidecar was torn, and a rebuild deleted it while it waited for its uploads. The root-adopted sequence holds the root's frames, so a row with none that the sidecar does not name can only be waiting. An unreadable sidecar must not abort every scan. |
| 2026-10-12 | On the server (ArchiveServiceOptions.ImagesAfterScan), a scan queues a background Thumbs pass and a background Proxies pass for each sequence it indexed that lacks ThumbsBuilt or ProxiesBuilt. After a resumed scan it queues them for every such sequence of the archive. With a Disabled proxy policy it queues no Proxies pass. A sequence whose own pass of that kind is already queued is skipped. A scan that finds photos added or removed clears both flags together with AnalyzedLight. The desktop queues no image passes after a scan. |
One batched pass for all indexed sequences; ImageJobHandler skipping failed targets; ArchivePolling calling SequenceJobs.FramesAddedAsync; the same follow-up on the desktop |
Clients load cards, thumbnails and proxies only from the server (BRIEF §4.3, §14.4). A batch stopped at the first folder renamed or deleted before its pass, and nothing queued the rest again. One pass per sequence matches uploads, and background jobs end without a toast. The flags keep unchanged and already-built sequences out. The desktop decodes thumbnails on demand (row 113) and makes proxies when asked. |
| 2026-10-12 | Applying a mass rename refuses (StaleRenamePlanException) a plan when a folder that moves holds an indexed sequence the plan does not take along. It checks before anything moves, and again under the step's leases just before each move. A resumed journal drops such a step while its folder has not moved yet. |
Carry the newcomer silently; re-plan on Apply | The dry run is what the user approved (destructive operations rule). Moving an unlisted sequence would leave its index row behind (the CD-4 state). |
| 2026-10-12 | The chunk route carries a 64 MiB request body limit (the largest chunk size a server accepts), which routing applies before authentication answers. The service also keeps the limit at least at the upload's and the server's chunk size and never lowers it. | Raise the limit only in the handler; read and discard the body on every early answer; a middleware between routing and authentication | Kestrel drains a body left unread after the answer, and closes the connection when that body exceeds the limit. A chunk sent again after a lost answer, sent to an unknown or finished upload, or sent with a revoked session then never got its 200, 404, 409, 401 or 403, and the client retried until it failed. Endpoint metadata is the framework's own hook and runs before any answer. |
| 2026-10-12 | PUT /api/v1/archive/settings answers 409 archive_policy, with thumbnailPolicy or proxyPolicy in details, when archive.json holds a thumbnail size or proxy quality out of range that the API cannot set. |
400 (the request is valid); 409 archive_manifest (the file parses); normalising the values on write |
The admin must correct the file, not the form. A 400, or a details value equal to a form field, would mark the valid proxy-size field invalid in the admin panel. Silently rewriting a policy another tool set is unsafe. |
| 2026-10-12 | (Superseded by the 2026-10-26 system schedules and scan at start rows: the archive-scan schedule follows the folder, and an archive unplugged at start is looked for every minute.) Desktop archive polling runs for the whole session. Each tick rescans the archive the Import and Archive screens use: the one registered at this PC's archive folder, else the first of the index. A folder chosen later (first run, Settings, relink, imported settings) is rescanned from the next tick. The start folder is reopened (relink, interrupted renames) once its archive.json is there, unless the folder changed meanwhile; a damaged or newer one is not retried. |
Restart the polling loop on every folder change; keep polling the archive opened at start | One loop cannot race the code that opens the new archive, and Rescan every always reaches a live timer. A first-run session or a drive unplugged at start no longer goes without rescans. |
| 2026-10-12 | When another process sharing the archive (a server's admin panel, another PC) changes archive.json, this index catches up when Settings › Archive loads it, before each rescan (desktop and server) and when the server's admin panel opens its archive form. Name, templates and proxy size are registered again from the file without the settings lease. A file that cannot be read, was written by a newer Chronos, or belongs to another archive leaves the row alone. The server serves the re-read archive only when the refresh registered a change, and never over an administrator's edit saved since it read the archive (compare-and-swap). | Read the templates from archive.json at every import and upload; refresh only at start | Imports, uploads and the admin panel use the index row, and the admin form saves every field: a stale row lasts only until the next refresh, and an edit made meanwhile registers its own row. |
| 2026-10-12 | While the open archive's archive.json cannot be read, Settings › Archive shows the index's templates and proxy size and keeps this PC's thumbnail size, which the index does not store. | Show and save the default thumbnail policy | The stand-in 320 replaced the user's default for new archives whenever the archive was offline. |
| 2026-10-12 | An Archive row edited (or Reset section) while the archive at a just-chosen folder is opening waits for that open. The edit then goes to the archive registered at that folder, or stays this PC's default when the folder holds none. An edit made before a later folder change still goes to the folder it was made for, and the rows show the archive at the folder chosen last. | Disable the Archive rows while the folder opens | The edit is neither lost silently nor written into another archive's shared archive.json. Nothing is disabled under the user's typing, where a field losing focus would commit anyway. |
| 2026-10-12 | Start with Windows (client and Uploader) shows as on only while Task Manager has not turned the entry off, i.e. its StartupApproved\Run value does not have an odd first byte. The client reads it again when Settings is shown, the Uploader when its settings panel opens. Ticking the box deletes that value, unticking deletes it with the Run value, and re-pointing the command after a rename keeps it. Setup removes the value together with the Run value when it removes the entry (see the Task Manager state row below). | Read only the Run value; write 0x02 instead of deleting the marker | Task Manager keeps the Run value when it disables an entry, so the box stayed ticked and could not turn the entry back on. With no marker, Windows runs the entry. |
| 2026-10-12 | (Partly superseded by the SyncEngines mount point row below: sync roots also come from HKCU\Software\SyncEngines\Providers\OneDrive*\MountPoint.) A portable copy whose .\data would lie in a folder OneDrive synchronises keeps its data in %LOCALAPPDATA%\Chronos. Sync roots come from the OneDrive environment variables and HKCU\Software\Microsoft\OneDrive\Accounts, matched by whole path segments, ignoring case. The copy otherwise stays portable (portable-zip updates, no sign-in entry) and shows a toast at every start (Data kept outside OneDrive, with Open). It then shares the data folder and the single instance with an installed copy of the same user. The Uploader keeps .\data, since its files are JSON written atomically. Other sync tools are not detected. | Refuse to start; a separate per-copy folder under %LOCALAPPDATA%\Chronos | BRIEF §6.2 forbids synchronised folders and names the per-user folder as the location. A copy that refused to start would leave the user with nothing. |
| 2026-10-12 | The .\data a portable copy now in a OneDrive folder used before (a chronos.db or settings.json in it) is left as it is: the log and a toast at every start (Earlier data unused, with Open) name it. Nothing is copied, moved or deleted. | Move or copy it into %LOCALAPPDATA%\Chronos at start | Moving an index is a destructive operation (dry-run plan, hash verification, explicit user action), and the per-user folder may already hold an installed copy's index; the user decides which to keep. |
| 2026-10-12 | When %LOCALAPPDATA%\Chronos itself lies in a OneDrive sync root, the client starts all the same, logs a warning and shows an error toast at every start (Data inside OneDrive, with Open; its tooltip says to exclude the folder from syncing) instead of Data kept outside OneDrive. AppPaths.CreateDirectories, which refuses such a folder, stays unused by the client. | Refuse to start | BRIEF §6.2 names no safer place than the per-user folder; a client that does not start leaves the user nothing, while the warning lets them fix the sync setup. |
| 2026-10-12 | A photo an import could not copy shows one catalog sentence beside it on the Import screen and in the import job's log (ImportExecutor.FailureText: the executor's own checks, a full destination, access denied, else 'The photo could not be read or copied.'). So does a card file the plan cannot read ('Cannot read {0}: {1}'). The photos a stopped folder or server import never reached show the stop's cause (ImportFailures.Stop: the server's own sentence, not answering, untrusted certificate, card gone, destination full or not writable), and a failed index check reads Archive.Failed.Index. The system's text goes to the application log only. |
Keep ex.Message beside each photo, or move it into each line's tooltip |
BRIEF §0.2 rules 5–6, as for toasts (2026-10-12): framework and OS messages are technical English under a translated screen, and each failure is already logged with its exception. |
| 2026-10-12 | An error reply that is not the server's own JSON (a reverse proxy's 502/503/504 page while the server restarts, its 413, a bare 500) says what its status means: too large (413), too many attempts (429), the server does not answer (408 and gateway errors), unexpected server error (other 5xx), else 'Something went wrong.' Only a reply with a Chronos error code shows its message. | Show the HTTP reason phrase; drop it in ChronosClient |
The reason phrase is English protocol text (BRIEF §0.2 rules 5–6). Behind the documented NAS proxy it reached every unreached photo, and the client must keep it for the log. |
| 2026-10-12 | Picking another archive, or the shown archive leaving the index, also clears the previous archive's tiles, charts, last scan, recent runs and rail badge, and its read state, until the new archive is read. Picking the first archive again before that read ends does not count it as read either | Keep them until the read ends and clear them only when it fails; a loading state drawn over the old figures | Probing an offline NAS takes seconds and a failed read never replaces anything, so the old figures stood under the new archive's name. An empty overview is the simplest honest state. |
| 2026-10-12 | A finished render is announced once, by whoever claims it first (JobsViewModel.ClaimRenderToast). The Jobs screen yields while the open editor still follows the render (EditorViewModel.FollowsRender). That editor announces it with the output and Show in folder. Without them, it still announces it when the sequence cannot be read again or when it closed in between. A render no editor follows is announced by the Jobs screen |
The Jobs screen stays silent whenever an editor has the sequence open; first come, first served | The editor only announced renders it saw running, and only after reading the sequence again, so a failed read or an unfollowed render got no completion toast, against the job-ending rule (2026-10-12). The order of the Jobs flush and the editor's callback is not fixed, so 'first' alone could lose the output file. |
| 2026-10-12 | Open on a job that worked on several sequences (toast, Windows notification, Jobs row) shows the Library with every one of them selected under the mass actions bar. Search and filters are cleared when they hide one, and pages are read until each is listed. A job over more sequences than a Library page (200, e.g. Rebuild proxies over an archive) opens the Library as it is | Open the first in the editor; lead to the Jobs screen; a Library filter by job; select every target of any job | One editor holds one sequence. The selection is what the job was started from and its results show on the cards; it needs no new filter chip or strings. Looking up, paging through and selecting a whole archive would hold the UI thread for seconds. |
| 2026-10-12 | (Partly superseded by the console-run data folder recovery row below: takeown /A /R, then icacls /remove:g of the account the console ran as, never /reset.) When the Windows service fails to start or stop, it writes the reason to the Application event log as source ChronosServer (advapi32 ReportEventW; event 1 start, event 2 stop) as well as to stderr. The reason comes first (the refused entry), then the exception. The source is not registered with a message file. The Windows README says where to look. It also says how to fix a data folder created by an unelevated console run: delete it (with SQLite, the database goes with it), or takeown /A /R and icacls /reset /T it from an administrator prompt, after which the server makes it private again. |
Register the source at --install-service with .NET Framework's EventLogMessages.dll; System.Diagnostics.EventLog; a log file outside the data folder; re-own only the folder |
A service has no console, and the data folder refusal comes before the log file exists (the log folder may itself be the refused entry), so the SCM recorded only error 1064. Event Viewer shows an unregistered source's text whole, after a 'description not found' line. Nothing is written to the registry, so setup's uninstall has nothing more to clean up, and nothing depends on a message DLL being present or extracted from the single-file build. The server checks the owner of every entry, and the TLS key and password file keep a protected DACL granting the console user, so the folder alone is not enough. |
| 2026-10-12 | Deployment guidance (compose comments, releases README, Unraid template) lists the reverse proxy container's own fixed address in CHRONOS_TRUSTED_PROXIES: a fixed IP on a user-defined network shared with Chronos, reached on that network rather than through a published port. It warns never to list a subnet, the network gateway or Docker's default bridge. For a proxy on the Docker host itself, Chronos runs with network_mode: host and the proxy reaches it over loopback. This replaces 'its address or subnet' in the trusted-proxies row above. |
Keep recommending the shared network's subnet; make the server refuse gateway addresses | Docker's userland proxy relays IPv6 clients and the host's own connections to published ports from the gateway. On Unraid's default bridge the subnet also covers every other container. Trusting a subnet would let any of them set X-Forwarded-For/Proto again. The server cannot tell a gateway from a proxy, so the guidance has to carry the rule. |
| 2026-10-12 | Sign-in entry move: on an upgrade, setup moves the client's or the Uploader's sign-in entry that starts a program the upgrade removes. The entry then starts the program of the same component in the new payload (its shortcut target), with the same options and value name. The entry is removed only when that component is no longer installed. Uninstall removes the entries of the programs its log lists, as before. | Delete the entry and let the client follow it (impossible: nothing is left to follow); remove the client's follow and drop rename support | Setup runs while the programs are closed and knows both the removed and the new program. So the rename case of the Startup row ('rewritten only when an update renamed the program') survives the upgrade, and Task Manager's on/off state stays with the unchanged value name. The client's own follow remains for an entry setup did not move. |
| 2026-10-12 | Setup removes a sign-in entry's Task Manager state (StartupApproved\Run value of the same name) together with the entry; an entry an upgrade moves to a renamed program keeps it. |
Leave the value (Windows ignores it without a Run value) | Uninstall leaves nothing of the entry behind, and an entry the user turned off stays off after an upgrade that renames its program. |
| 2026-10-12 | A scan reads a sidecar again under the sequence lease when it lists other frames than the index row, then moves the project's positions and indexes it. This happens when another process (a desktop sharing the archive, through its ArchiveIngest) added, removed or renumbered frames together with their sidecar entries. On a server (ArchiveServiceOptions.ImagesAfterScan) the scan clears AnalyzedLight, ThumbsBuilt and ProxiesBuilt in its own row only, so its follow-ups queue the light analysis and both image passes, whose marks set the flags in both places again. The shared sidecar keeps the writer's flags, and a desktop clears nothing. Photos the scan reconciles itself still clear the three flags in the sidecar. |
Clear the flags in the sidecar on every host; clear them in ArchiveIngest at every insert; clear them in the row on every host | Row 'A server's scan queues…' covered only photos copied in by hand, which Reconcile finds. The frames another Chronos writer listed answered 404 on /thumb and /proxy until a pass was forced by hand. Cleared in the shared sidecar, a desktop's poll after every server upload cleared flags the server's post-upload passes had just set, and the server then repeated the analysis and both passes. Cleared in a desktop's row, its Library would show no proxies until the sidecar next changed, and the light analysis would run again with the desktop's codecs. Clearing at every insert was rejected before (row 'The server's manifests…'). |
| 2026-10-12 | Writers that change part of a sequence write the sidecar and the index under one sequence lease. The index is written from the sidecar read under that lease, and only in the columns the writer owns. These are decode tiers (SequenceRepository.RecordTiersAsync), image-pass flags (UpdateStatusAsync), the verify (RecordVerifiedAsync) and integrity and duplicate flags. Title, tags, rating and notes go through EditAsync at the settings version read under the lease; the edit is applied again on a conflict, and the sidecar is then written from the stored row. A mass rename uses RelocateAsync: the folder, and the title only for a step that retitles. |
Read the row FOR UPDATE and upsert the whole row from the sidecar | A whole row written from a sidecar this index had not synced claimed another process's frame count and frames version while the frames table lagged. It also wrote back settings committed after the row was read: an analysis's Auto values, or a server PATCH, which takes no lease. Column writes cannot undo either. |
| 2026-10-12 | Such a writer records the folder's scan stamps after its write only when, before that write, the index held the folder as it was (ArchiveIndexer.InStepAsync). That means the stamps stored for the folder are still the sidecar's and the photo folder's, and the row holds the sidecar's frames version. Otherwise the folder stays changed for the next incremental scan, which writes the whole row from the sidecar. A folder that a nested sequence moved out of during a mass rename is therefore read again by the next scan. |
Compare only the frames versions; record the stamps unconditionally | Partial writers no longer carry the whole sidecar into the index. A desktop's retitle, rating, import or verify therefore reaches the server's index only through a scan, and stamps recorded by a later partial write hid it until the folder changed again. The stored stamps tell whether anything other than this index's own writes touched the folder. The frames version also catches a sidecar rewritten at the same size within the file system's time resolution. SyncService.ApplyLocallyAsync (sync workstream) still records stamps unconditionally after its metadata write. |
| 2026-10-12 | An image pass sets ThumbsBuilt or ProxiesBuilt in two cases, and otherwise clears it. First, when it covered every frame it read and the sidecar under the lease still lists those photos: same id, index, file, size and capture time, and the same hash unless the pass read none. Second, when a pass of the same kind is already queued for the sequence. | Clear whenever the frames differ; compare only the frames version | Thumbnails and proxies are kept by frame index. A pass that read the frames before a scan's reconcile must not set the flag the scan cleared, or no pass is queued for the new photos. During an upload burst every pass is overtaken, and clearing then left a server unable to offer any thumbnail or proxy of the sequence until uploads paused. The queued pass draws the new frames, as between an upload and its pass (row 'The server's manifests…'). |
| 2026-10-12 | A thumbnail drawn before a verify hashed its photo still counts as that photo's (ThumbPack.IsFrom): image passes reuse it and the server serves it. Such a thumbnail carries the fingerprint of the file name and size. One drawn from another hash, file or size does not count. |
Clear ThumbsBuilt when a verify hashes frames, and draw them again; serve only exact fingerprints | Hashing changes nothing about the photo. After a verify, the thumbnail of every scan-adopted frame answered 404 while ThumbsBuilt stayed set and no pass was queued, and the next pass drew them all again. |
| 2026-10-12 | A deep analysis checks its own report against the frames as they are when it records. It reloads them under the sequence lock and applies SequenceAnalyser.ReadReport's rule. If the run found a frame unreadable and that frame's proxy arrived during the run, the report counts as none for the Auto values, AnalyzedDeep, HasWarnings, the warning count and the stored summary. The advice is applied under the same lock as the status. Refines 2026-10-12 'analysis.json lists the frames…'. |
Queue another light analysis when the report is stale; keep the deep status until the next light analysis | The light analysis that an arriving proxy queues can finish on another worker (Auto is cores/2) before the deep run records, and nothing runs it again. The stale deep status, warning count and Library badge then stayed, while the report endpoint answered 404. Under one lock, that light analysis either ran before and is not undone, or runs after. |
| 2026-10-12 | Before deleting a row that the folders listed at its start do not back, a rebuild checks it again under the row's sequence lease. The row stays when it waits for its first frame, when its current folder holds a sidecar naming it, when that sidecar cannot be read, or when another process holds its lease. | List the folders again at the end; keep rows whose updated_at is later than the rebuild's start | Uploads go on during a rebuild, which can take minutes. A first frame's new folder, or a new session's sequence, is not in the listing taken at the start. Dropping its row gave the Uploader 404, and (with the session mapping cascaded away) split the session into a ' (2)' sequence. A second listing still races, and updated_at moves for many unrelated edits. |
| 2026-10-12 | (Partly superseded by the 2026-11-03 Edit opens workspace projects row: Edit edits this PC's sequences only as workspace projects, whose media change only through Update media; the rule stays for a capture.) A local editor's save is refused under the sequence lease (FramesChangedException, nothing written) when the sequence's frames version has moved since the editor read its frames. The index edit also names that version. The editor then reads the sequence again and moves its project, its basis and every undo and redo step the way the index moved the stored copy (ProjectSettings.FollowFrames): by frame id when every frame it read is still there, otherwise unchanged; waiting photos are placed. It then saves the project in the new order, up to 3 times. The editor reads the row and frames as one state: the frames are listed between two reads of the row at the same frames version, 3 attempts, then 'Photos are being added to this sequence; wait a moment and try again.' Reads of the sequence never overlap: each waits for the one under way, and saves wait for it, so each read follows the frames the one before took. The frame on screen stays on its photo. |
Translate inside the source and keep the editor's old frame list; refuse with an error and reload, losing the edit; store positions by frame id | Insertions hold the same lease, so the check is exact. Applying the index's own rule moves basis, edit and stored copy alike, so the three-way merge stays meaningful. Undo steps must move too, or Ctrl+Z brings back positions in the old order. Two jobs that end together read the sequence at once, and the later frames must not be followed back to the earlier ones. Positions stay positions (row 'Project frame positions…'). |
| 2026-10-12 | Before a render, the editor checks that the frames it read are still the sequence's (ISequenceSource.FramesCurrentAsync: the index row's frames version on this PC, the manifest on a server). On this PC it reads the sequence again first, so the project the job embeds names the moved positions. A server sequence whose frames changed turns outdated (read-only, Get proxies) and the render is not queued. A render already waiting in the queue keeps the project it embedded. |
Carry the frames version in RenderJobParameters and fail the job in the local, managed and render-node handlers; check inside SubmitAsync |
The editor learns of an insertion only at its next save or after its own job, while Render embeds the project at once. One row read (one manifest read on a server) per render keeps the check in the editor, and the job format, the render handlers and the render nodes stay as they are. A render left waiting in the queue while earlier photos arrive is the one window left; closing it needs the job format to change. |
| 2026-10-12 | The desktop editor of a server sequence sends expectedFramesVersion in its PATCH: the frames version of the proxies it holds. On any 409 it reads the manifest. Other frames make it outdated (read-only, Get proxies; the edit stays pending). The same frames at a new frames version retry at that version. After a lost event socket, and before a render, it compares the frames again. Servers that predate the field ignore it. |
Read the new frames and translate the edit (needs the new frames' proxies); show Server.Error.FramesConflict and drop the edit |
Server scans publish no sequenceChanged event, and events missed during a reconnect were never checked, so a save or a render could use positions the server had moved. The outdated state (row 'Server sequences whose cached frames…') already says why and offers the fix in the editor's own sentence. |
| 2026-10-12 | Positions crossing copies by photo tell copies of one photo apart by their order (FramePhotos.Occurrence). A position on the n-th frame holding a photo goes to the n-th frame holding it on the other copy. When that copy holds fewer, it waits as a pending frame with occurrence n; occurrence 0 is not written. A hashed photo is the frames holding its hash; size and capture time count only when no frame holds the hash. |
Map to every matching frame; keep the first copy; keep the receiving copy's own positions for duplicates; count unhashed frames of the same size and time as copies of a hashed photo | A PC keeps one copy where an adopted server folder holds two ('IMG_0001.JPG', 'IMG_0001 (1).JPG'). The server's exclusion of the duplicate, which the deep analysis flags, must not exclude the PC's only copy, and a push must give the server back exactly what it had. Keyframes then never pile on one frame, and older projects read the same. A frame not hashed yet may be another photo of the same size taken in the same second (an uncompressed RAW in a burst): parking a position until hashing is safe, while moving it to that photo is not. |
| 2026-10-12 | (Superseded by the row below: a proxy cache counts as filled only when every frame is cached as a proxy.) With Keep proxies offline, a stale proxy cache of a server sequence without ProxiesBuilt is compared with the manifest's per-frame HasProxy. This happens once per change of the server's update time. A frame offered as a proxy that the cache holds only a thumbnail for (or a file of unknown kind, or nothing) queues the background proxy download. A comparison that queued a download counts only once that download is done: a failed or cancelled one is compared again after its backoff. This refines the proxy-cache kinds row. |
Wait for ProxiesBuilt; read the manifest at every refresh; offer a manual re-download on ProxiesOnly rows |
ProxiesBuilt waits for every frame, and a missing or damaged frame never gets a proxy, so the flag never came. A proxy that arrives leaves a new update time through the proxy pass it queues. One manifest read per change is enough, and a download that cannot improve the cache is not queued again. The server's sequence may never change after a failed download, so the failure itself must reopen the comparison. |
| 2026-10-12 | PUT /api/v1/frames/{id}/proxy carries its 64 MiB request body limit (ArchiveImages.MaxProxyBytes) as endpoint metadata, as the chunk route does; the handler no longer raises it. |
Raise the limit in the handler after the frame checks (as before) | Authentication's 401 and 403 and the handler's 404 and 422 answered with the proxy unread. For a proxy above 1 MiB, Kestrel then closed the connection, and clients retried a network error instead of stopping on 401/403 or skipping the frame on 404/422. |
| 2026-10-12 | Settings › Archive never shows a read of the open archive's settings (index row and archive.json) that overlapped an Archive row edit being written (ArchiveReadGate). The read waits until no edit is being written and is made again, so a folder change or the reload when Settings is shown is done only once the rows show the archive's values. A read waits for every edit being written, whichever archive the edit is for. |
Serialise reads and edits behind one lock; take the settings lease for reads; drop the overlapped read and leave the reload to the edit's end; key the gate by archive | A lease-free read on a share that is waking up can return archive.json from before the edit. Showing it would put the old value back on the row and in this PC's defaults while the archive keeps the edit. A lock would still apply a read begun before the edit over the value the user had just committed. Leaving the reload to the edit's end let a folder change finish while the rows still showed the archive before it. Waiting for edits to other archives costs at most one edit's write, and keeps the rule simple. |
| 2026-10-12 | A sink whose staging folder is on this PC (IImportSink.StagesOnThisPc: the server import, which stages in the cache folder) names that folder when staging fails. A full disk reads 'The drive of this PC's cache folder is full.' (beside each photo and as the stop cause), and a refused write reads 'Chronos may not write to this PC's cache folder.' |
Keep 'The destination is full.' and 'Chronos may not write to the destination.'; check this PC's free space in the server plan | The server answers for its own space and rights with its own sentences, so in a server import these failures always concern this PC. The plan's space check is the quota, and staging holds one batch at a time. |
| 2026-10-12 | A failed archive import job shows on the Import screen the archive engine's own sentence when the job's error is one: offline, read-only, busy, newer format, card gone, or a photo it could not add. These are matched against the catalog in the language shown. Any other error shows 'The import stopped before the end.', and the job's text stays in the tooltip and the logs. | Show job.Error; map exceptions to sentences in the import job handler |
The job engine keeps only the exception's message, which for SQLite, file moves and the framework is technical English. BRIEF §0.2 rules 5–6 and the 2026-10-12 per-photo row keep such text off a translated screen. A job that failed before a language switch reads as the catalog's sentence. |
| 2026-10-12 | (Partly supersedes the README part of the service start-up row above.) The Windows README fixes a data folder created by an unelevated console run from a Command Prompt run as administrator: takeown /A /R, then icacls /remove:g "PC\name" /T. PC\name is the account the service's refusal names (dir /q C:\ProgramData shows it as the folder's owner until takeown); %USERDOMAIN%\%USERNAME% is that account only when the prompt runs as whoever ran the console. Ownership goes to Administrators, and that account's entries come off the folder, the TLS key and the password file. No other account gains access at any step. |
icacls /reset /T; /remove:g "%USERDOMAIN%\%USERNAME%" from the prompt's account; delete the secrets and let the server make new ones; have the server re-apply its DACL to every protected child |
A reset makes everything inherit %ProgramData%'s ACL: every local user could read chronos.db, the TLS private key and the temporary admin password, and could plant files that stop the next start. A standard user may create the folder (Users may create folders in C:\ProgramData), and the administrator who repairs it then runs the prompt as another account, so the prompt's own name would remove nothing and leave the key and password readable by that user. Deleting initial-admin-password.txt loses the only copy of the temporary password of an administrator the console run already created. |
| 2026-10-12 | (Partly supersedes the portable OneDrive row above.) Sync roots also come from HKCU\Software\SyncEngines\Providers\OneDrive\*\MountPoint, where OneDrive registers each folder it syncs, including SharePoint and Teams libraries synced with their Sync button. |
Read Accounts\*\Tenants or ScopeIdToMountPointPathCache |
Such libraries lie beside the account's UserFolder (%USERPROFILE%\<tenant>\<site> - <library>), not in it. The SyncEngines key is the documented location Office itself reads to find synced files (Microsoft Learn, cloud storage partner program); the other values are undocumented. |
| 2026-10-12 | An analysis records nothing when the frames it read are no longer the sequence's. Under the sequence lock it reads the sidecar and the index row. If the sidecar's frames version differs from the row's, another process (a desktop sharing a server's archive, or that server) changed the frames and this index does not hold them yet. The job then logs Advisor.Log.FramesChangedElsewhere and queues nothing: that process analyses the frames it changed, and this host's next scan indexes them. A server's scan then queues their light analysis; a desktop's scan takes the statuses from the sidecar. If the row's version moved since the analysis read it and no light analysis is queued for the sequence, the job logs Advisor.Log.FramesChanged and queues a light analysis. If one is already queued, the pass records as before and the queued one replaces it. Recording nothing leaves the status, warning count, compact summary and Auto values as they were in the index, the sidecar and project.json. A deep pass keeps only analysis.json and its per-frame measurements, which describe the frames they name. Refines 2026-10-12 'A deep analysis checks its own report…'. |
Never record once a version moved, even with a light analysis queued; recompute the light statistics from the frames as they are under the lock; compare only the row's version; queue a light analysis when only the sidecar moved; queue a deep analysis again | A pass that loaded its frames before an upload, an import or a scan's reconcile recorded AnalyzedLight, the old warning count and Auto values counted on the old frame count. It did so over the newer light analysis, and nothing analysed the new frames again, since scans list only sequences without AnalyzedLight. Comparing only the row missed frames another process listed in a shared sidecar before this host's scan. The pass then wrote Auto values and statuses for the old frames over that process's analysis in the shared files, and a desktop's scan clears nothing (row 'A scan reads a sidecar again…'), so nothing analysed them again. A light analysis queued here while only the sidecar moved would read the same index and be overtaken again until the scan. During an upload burst every pass is overtaken, so never recording would leave a sequence being shot without any analysis until uploads paused, as with image passes (row 'An image pass sets ThumbsBuilt…'). Recomputing would mean probing and reading the new frames under the lock. A deep pass can run for hours: the light analysis restores status and advice, and the user starts a deep pass again when wanted. |
| 2026-10-12 | SyncService.ApplyLocallyAsync records the folder's scan stamps after writing the server's title, tags, rating or notes into the sidecar only when ArchiveIndexer.InStepAsync held before that write, like the other partial writers. Refines 2026-10-12 'Such a writer records the folder's scan stamps…', which left it recording them unconditionally. |
Keep recording them unconditionally; write the whole row from the sidecar | Frames another process (a desktop sharing this archive) listed in the sidecar since this index last synced the folder stayed out of the index until the folder changed again, and the row's frames version stayed behind the sidecar's. An analysis now records nothing while the two differ (row 'An analysis records nothing…'), so the gap would also have kept the sequence from being analysed here. |
| 2026-10-12 | With Keep proxies offline, a proxy cache counts as filled only when every frame is cached as a proxy, missing or damaged frames aside. A thumbnail or no file stands in for a proxy whether or not the server has ProxiesBuilt. A stale cache of a sequence without ProxiesBuilt is compared with the manifest's per-frame HasProxy once per change of the server's update time. A frame offered as a proxy that the cache holds only a thumbnail for (or a file of unknown kind, or nothing) queues the background proxy download. With ProxiesBuilt, a download that left stand-ins is queued again once the server's update time moves; a frames change still downloads at once. A comparison or download that queued a download counts only once that download is done: a failed or cancelled one is compared again after its backoff. Replaces the 2026-10-12 row 'With Keep proxies offline, a stale proxy cache of a server sequence without ProxiesBuilt is compared…'. Refines the proxy-cache kinds row. |
Wait for ProxiesBuilt; trust ProxiesBuilt when a download ends; count only frames that want or offer a proxy; download at every refresh while stand-ins remain; read the manifest at every refresh; offer a manual re-download on ProxiesOnly rows |
ProxiesBuilt does not wait for every frame. It stays set between an insert and the next background proxy pass, and through an upload burst while a pass is queued (rows 'The server's manifests…' and 'An image pass sets ThumbsBuilt…'). Frames added meanwhile were offered but answered 404, and a cache marked filled then kept thumbnails or holes until the frames changed again. While the flag is clear it waits for every frame the server cannot decode, and a missing or damaged frame never gets a proxy, so the flag may never come. Counting every frame also covers a manifest read while the flag changed. A proxy that arrives, or a pass that draws new frames, leaves a new update time, so one comparison or download per change is enough. Fetching at every refresh would queue a job every 2 minutes while a pass waits. The server's sequence may never change after a failed download, so the failure itself must reopen the comparison. |
| 2026-10-12 | Every transaction that writes a sequence's frames takes the sequence row first, then the frames. It takes either a row lock (SequenceRepository.GetForUpdateAsync) or an update of the row. Decode tiers record the row before their frames. A verify's integrity flags and maintenance's duplicate flags lock the row in the same transaction as their frames. On PostgreSQL, a light analysis's statistics lock the rows of their frames' sequences before the frames (FrameRepository.UpdateLightStatsAsync). |
Make the scan's sync take the sequence lease; reorder only FrameTiers.RecordAsync; retry transactions PostgreSQL aborts with 40P01 |
The scan's sync, the ingest, a rename and a restore already locked the row before the frames. Tier writes and light statistics locked their frames first. On PostgreSQL, a scan or rebuild then deadlocked with an analysis, image pass or render on the same sequence, and nothing retries a transaction. One order closes the cycle for every pair. Frame-only writers under the lease also stop committing between a scan's row lock and its write; the scan's check of the sidecar it read relies on this (next row). SQLite serialises writers and was not affected. |
| 2026-10-12 | A scan writes a sidecar it read without the sequence lease only when, under the row lock, the sidecar still has the stamp the scan listed and the row holds the sidecar's frames version. Otherwise it reads the sidecar again under the lease and indexes that. Such a write records the stamps it was checked against. The index snapshot files each sidecar's bytes under the stamp they were read at. | Take the lease for every folder a scan indexes; compare only the frames versions | An upload or a partial writer could commit between the scan's read and its transaction. The scan then wrote its older copy over the row and frames, dropping uploaded frame rows or tier flags, and recorded stamps that hid this from every incremental scan. Partial writers keep the frames version, so comparing versions alone misses them. A lease per folder would slow a rebuild of thousands of folders on a share; the check costs one stat. Only folders changed since the listing, or adopted or rewritten by the scan itself, go through the lease. |
| 2026-10-12 | The index's frames version never goes back. A sidecar read under the lease whose frames version is behind the locked row is written again one version past the row, then indexed. That happens when an older copy was put back by hand, from a backup or by a file-sync tool. | Index the lower version; keep the row's version in the index only; refuse to index the folder | Editors and clients detect frame changes by the frames version (expectedFramesVersion, the local save check). A version that goes back and up again can repeat one a client holds for other frames. A row left ahead of its sidecar would read as moved at every scan. The sidecar stays the truth for the frames. |
| 2026-10-12 | An upload's batch asks ArchiveIndexer.InStepAsync under the lease before it changes the folder. It appends its frame rows and records the folder's stamps only when that held and its frames went at the end. Otherwise it writes the whole row and every frame from the sidecar. This extends the partial-writer stamps row above to ArchiveIngest. |
Keep the frame-count check alone; append and leave the stamps unrecorded | A desktop's verify, decode tiers, duplicates or title change only existing frames or fields, so the frame count still matched. The appended rows and the recorded stamps then hid those changes from the server's index until a full scan, and a sequence that keeps receiving uploads never healed. Appending without recording stamps would still leave the server's frames stale until its next poll. |
| 2026-10-12 | Before an upload's batch files its photos, it asks under the lease whether the photo directory still has the stamp the index recorded (ArchiveIndexer.PhotosChangedAsync). The photo directory is originals/, or the folder for a sequence adopted in place. If it changed, because photos were copied in or removed by hand or by another process since the last scan, the resync from the sidecar records the photo stamp the index held before, or none when none was recorded. The folder's new stamp is not recorded, so the next incremental scan reconciles the folder with its photos. |
Reconcile the photos in the upload under the lease; record the new stamp as before | The batch's own files change the photo directory's stamp. Recording it hid the copied photos from every incremental scan, so only a full scan or the orphans check found them. A reconcile in the upload would read new photos while uploads to the sequence wait. The scan's reconcile already clears and queues what covers the frames. Until that scan, which server and desktop run every 10 minutes, every upload batch to that sequence writes all its frames instead of appending. |
| 2026-10-12 | A verify writes only Missing and Corrupt, merged into the frame's flags as the sidecar has them under the lease. The index sets and clears only those bits, with the new hash. A check is written only while the sidecar lists the frame with the file, size and hash that were checked, and the file still has the size and modification time it had before it was read. Otherwise the next verify checks it. |
Write every flag computed from the frame read at the start (as before); merge the bits but write every verdict; hash the file again under the lease | A verify reads each sidecar once, possibly hours before it writes. Tiers, duplicates and repairs recorded meanwhile were reverted. A photo an upload repaired during the run was flagged missing, so the next copy moved the good file aside. Hashing again under the lease would hold uploads back for as long as the files take to read. One case remains: during the run, a good copy with the same size and modification time is put back over a same-size corrupt file, and it is still flagged corrupt. A card import keeps the camera file's time, so it can do this. The next verify clears the flag. |
| 2026-10-12 | On PostgreSQL a sequence's tags are written in the order of their keys (TagRepository.Key), whatever order the caller listed them in. A tag set the sequence already carries (compared by key) is not written again (SequenceRepository.ReplaceTagsAsync). |
Keep the caller's order; retry transactions PostgreSQL aborts with 40P01; lock every tag of the set in one statement | Each tag upsert locks its row until commit. A PATCH may list tags in any order, while ingest batches, scans and the trash wrote them sorted. Two writers of sequences sharing two tags could then take the rows in opposite orders, and PostgreSQL aborted one with a deadlock that nothing retries (row 'Every transaction that writes a sequence's frames…'). One order closes the cycle. Ingest batches and scans rewrote unchanged tags at every write; skipping them takes no tag lock at all. SQLite serialises writers and was not affected. |
| 2026-10-12 | The Archive screen's orphans fix (ArchiveService.ReconcileAsync) clears AnalyzedLight, ThumbsBuilt and ProxiesBuilt in the sidecar and the row when photos were added, gone or back, as a scan's reconcile does. It then queues on the host's engine what a scan's follow-ups would. That is the light analysis, plus a background deep analysis when the host asks for one after scans (desktop: Settings › Analysis › After a scan). On a server (ImagesAfterScan) it is also the Thumbs pass and, unless proxies are disabled, the Proxies pass. A kind the engine does not run is left out. So is a kind for which a queued job already covers the sequence, whatever else that job targets. |
Keep the flags; clear them and leave the queueing to the next scan; run the fix as a job; queue the light analysis only | The fix records the folder's stamps, so incremental scans skip the folder, and a full scan's reconcile finds nothing new; cleared flags alone would wait for the next change of the folder. With the flags kept, the light analysis was never redone: Auto values, warnings and preview-only tiers stayed those of the old frames, and the Analyse health line did not list the sequence. Without the deep analysis, the light analysis drops the deep status when the frame count changes, and nothing redid the deep analysis, while the same photos found by a scan got one. A queued job runs after the fix on the frames as they are; a scan's follow-ups target several sequences, so checking only single-target jobs would queue a second deep analysis of hours. Cleared in the sidecar, the flags also tell a server sharing the archive to draw the new frames after its next scan. |
| 2026-10-12 | A deep analysis saves analysis.json under the sequence lock, after it has checked its frames (SequenceAnalyser.SaveReport). It replaces the saved report when the frames it measured are still the sequence's: no change found, and the sidecar at the frames version the pass read. Otherwise it replaces only a report that describes the frames as they are no better: none, unreadable, or of another frame count than the sidecar's. Its checkpoint is deleted only then. A pass that leaves the saved report in place and still records (a light analysis is queued) records that report, read as a light analysis reads it, not its own. Refines 2026-10-12 'An analysis records nothing…'. |
Save before the check (as before); never save an overtaken pass's report; name the report by its frames version; record the pass's own report, or no report, when it did not save | A pass overtaken by an upload, or by another Chronos sharing the archive, replaced the report that a later pass had made of the frames as they are. GET /report then answered 404, and the next light analysis cleared that pass's deep status. Keeping a report when no better one exists keeps what the refined row keeps. Recording the unsaved report put a summary, warning count and Auto values in the index that no file holds, and the queued light analysis keeps the stored summary. Recording none would drop the deep status of the report on disk until that light analysis ran. A versioned name would change the file that every reader and the server's report endpoint open. Deleting the checkpoint only after the save lets a pass stopped while waiting for the lock resume. |
| 2026-10-12 | Equal frames versions in a sidecar and an index row mean the same frames only when the row's frame ids and order are the sidecar's (ArchiveIndexer.OtherFramesAsync). Otherwise the scan treats it as any frames change: it reads the sidecar again under the lease, writes it one version past the row, moves the project's positions and, on a server, clears what covered the frames. Refines 2026-10-12 'The index's frames version never goes back.' |
Compare versions only; make the bump unique (a counter kept in the sidecar, a timestamp) | Each index of a shared archive bumps a sidecar put back behind its own row to one past that row. That can be the version another index already holds for other frames, for example a desktop rebuilding a damaged sidecar while the server is one upload ahead. That index then kept its positions, statuses, sync diff and proxy cache, and accepted editors' saves made against frames that had changed. A counter in the sidecar goes back with the sidecar it is put back with. The frame list is read only when the versions match, and the scan writes every frame row in that case anyway. |
| 2026-10-13 | SequenceAdopter.Reconcile returns null, and the sidecar is left as it was, when the photos it found could not be read and no frame's missing flag changed. |
Index the photo without metadata; flag it | A photo held open by another program, without read permission or not downloaded yet is read at the next scan or fix. Treating its folder as changed rewrote the sidecar, cleared the covering flags and queued the analyses (with a deep analysis, hours) again at every orphans fix. |
| 2026-10-13 | A deep pass counts as current only when its report describes the frames as this host reads them under the lock, proxies included (SequenceAnalyser.Describes), besides an unchanged frames version. Otherwise it replaces only a saved report that does not describe them either (ReadReport of the frames as they are). Refines 2026-10-12 'A deep analysis saves analysis.json under the sequence lock…'. |
Compare frames versions only | A proxy arriving moves no frames version but makes an unreadable verdict on that frame's original stale. A pass that started before it overwrote the report a later pass made from the proxies, then dropped the deep status. |
| 2026-10-15 | VS Code debugs the Windows programs with the C# extension's coreclr debugger (.vscode/launch.json): Chronos, the Uploader, the server, the --capture runs of Chronos, the Uploader and Setup, Chronos.Tools and the test programs (these two ask for their arguments). Each launch configuration builds in Debug first (.vscode/tasks.json; Tests builds the solution) and starts the program's .exe. The server's session keeps its data and archive in out/debug/server (CHRONOS_DATA_PATH, CHRONOS_ARCHIVE_PATH) and its default ports; Chronos and the Uploader use their usual data folder. The build tasks use no reused MSBuild nodes and keep MSB3026 a warning. |
C# Dev Kit's dotnet launch type with launchSettings.json; start dotnet <program>.dll; the server's default folders; ports of its own for the server; a portable copy (portable.txt) for the desktop programs; reused MSBuild nodes; MSB3026 as an error |
The coreclr debugger needs only the C# extension. Started as a .dll, the process is dotnet.exe, which the programs read as their own path (Environment.ProcessPath): Setup's payload and the stub of its capture's sample installer, the Run keys and tray icons. A console run creates %ProgramData%\Chronos Server owned by the developer, which the service then refuses (the console-run data folder rows), and C:\ChronosArchive at the drive root. On the default ports the clients reach the debug server as they reach an installed one; the README says to stop the Docker stack or an installed server first. A portable copy would run other code than an installed one (data beside the program, the portable update download). MSB3026 reports a copy that a retry then completes (a file held for a moment by an antivirus or another build): as an error it stopped F5 although the build succeeded, while a copy that never succeeds still fails (MSB3027). Reused MSBuild nodes keep the drive letter's case of the build that started them, while VS Code passes it in lower case: restores mixed both cases, rewrote project.assets.json at every build and made C# Dev Kit reload the projects, so no F5 build was a no-op (7 to 14 s for Chronos instead of about 5 s). |
| 2026-10-15 | Design-time builds (DesignTimeBuild=true: C# Dev Kit, Visual Studio) skip the ChronosGenerateIcons target (Directory.Build.targets) and log WPF's MC1000 as a message (Directory.Build.props). Refines 2026-10-02 'Program icons (ICO) are generated at build time…'. |
Build Chronos.Tools from the design-time build; no warnings as errors in design-time builds; leave it |
A design-time build builds no project references, so on a fresh clone make-icon ran a Chronos.Tools.dll that did not exist yet: VS Code listed MSB3073 for Chronos, the Uploader and Setup when the folder opened. A design-time build compiles nothing, so it needs no icon. Past that target, the markup compile of their XAML cannot load Chronos.Ui.dll before the first build: MC1000, which the design-time build makes a warning and warnings as errors made an error again (21 of them). Without warnings as errors they would still be listed, as warnings. Real builds still fail on MC1000. |
| 2026-10-16 | Job throughput: the first two-second window that saw progress seeds the moving average, and below 1e-6 items/s the rate reads unknown; a time left is null when it is not finite, negative or above 365 days, and every stored or reported time left goes through JobEta. Saving progress never throws (a failure is logged and the job goes on) and a progress subscriber never fails a job, so a job's final state is always written. Thumbnail and proxy jobs count frames across their targets. Refines 2026-10-02 'Job throughput is a moving average…'. (Owner review 1, R10.) |
Clamp the time left only when it is stored; keep counting sequences | The owner's Proxies job over 17 sequences counted sequences while it checkpointed every 10 s inside one of 14,082 frames: each window without progress multiplied the rate by 0.7, the time left passed TimeSpan's limit after 18 minutes and threw in PublishProgress, then again in PersistAsync, so the job stayed Running for 4 hours until the owner cancelled it. A node-supplied rate and the stored seconds had the same unbounded conversion. |
| 2026-10-16 | The editor's background decodes (LocalSequenceSource, RemoteSequenceSource), LatestRunner and the render node's proxy task keep a superseded decode's OperationCanceledException inside their own delegate: the local source catches it in the pool delegate and throws it again after the await, so a cancellation is never reported as an unreadable frame. (Owner review 1, R4.) |
justMyCode: false in launch.json; providers that return null on cancellation |
The owner's "error in WicDecoderProvider.cs when I select some presets" was the cancellation of a preview decode a newer click replaced: it left a synchronous Task.Run delegate into the thread pool, where the debugger with Just My Code stops as "not handled by user code"; at runtime it was swallowed and nothing was logged. Throwing on cancellation stays the provider contract. |
| 2026-10-16 | WIC decodes a camera RAW only when the decoder it chose is the Raw Image Extension (CLSID read per file), never a DNG, and never for a request that prefers the embedded preview. Refines 2026-10-02 'Camera RAW is "native" via WIC only when the Raw Image Extension package is installed.' (Owner review 1, R4.) | Trust CodecInventory per format; force the Raw Image Extension by CLSID for DNG |
With the extension installed, WIC still picks Windows' in-box "DNG Decoder" for every DNG with a JPEG preview; it reads only that 8-bit preview, which the provider labelled native (a smaller preview was a silent downscale). The Raw Image Extension develops DNG to 8 bits and fails on Lightroom's lossy LinearRaw DNGs; the managed decoder develops all of the owner's files at 16 bits. |
| 2026-10-16 | A DNG is GPR only when its raw image is VC-5 (Compression 9) or its extension is .gpr; Make=GoPro alone no longer counts. Frames stored as GPR whose file is not a .gpr are probed again by the next light analysis, which the scan follow-up queues for their sequences, and the format the probe finds replaces the stored one in the sidecar and in frames.format. (Owner review 1, R4.) |
A migration that rewrites every sidecar; leave existing frames as indexed | The owner's 84,400 GoPro DNGs were converted by Lightroom or DNG Converter (lossy LinearRaw, lossless CFA), which the managed DNG decoder develops, but every one was indexed GPR and preview-only. A light analysis reads only metadata and already probes tiers under the sequence lease. |
| 2026-10-16 | Decode policy, the owner's choice: analyses, thumbnails, proxies and the editor's preview set DecodeRequest.PreferPreview, so a RAW gives an embedded preview whose long edge reaches the requested size when it has one and is developed otherwise; renders never set it and develop natively at 16 bits. Such a result is DecodedImage.ByChoice and is never recorded as the frame's tier. (Owner review 1, R4.) |
Native development everywhere; the preview everywhere | Developing one of the owner's 12 MP DNGs takes 0.8–2.6 s against about 0.1 s for its preview: an analysis of the 84,400 frames would take about 18 hours instead of about 2. Exposure measured on a preview is tone-mapped by the converter, so deflicker corrections computed on it only approximate those of the native pixels the render corrects; the owner chose speed for analysis and quality for videos. |
| 2026-10-16 | Jobs run one at a time (owner review 1, R2): the engine has one worker by default (JobEngineOptions.Workers stays for tests of concurrent claims) and SetWorkers is gone. The parallelism reaches the work through the hosts' options, asked at the start of each sequence or job: ArchiveServiceOptions.Parallelism (thumbnail and proxy passes, tier probes) and ProcessingOptions.WithParallelism (deep analysis threads, render read-ahead and decodes). The running job has the whole memory budget. Refines 2026-10-12 'Settings › Rendering › Parallelism Auto is the job engine's default'. |
Keep N workers with per-job caps; a JobContext.Parallelism passed through every handler and service |
The owner's answer. The hosts already tune both option sets per job, render nodes reuse the desktop tuning, and no handler signature changes. |
| 2026-10-16 | The priority queue gives each job kind a level (high, normal, low), off by default: claim order level → priority → age; a queued job of a higher level that the engine would claim makes the running job of the lowest level yield without asking (cancelled, its checkpoint and a log line saved, then JobRepository.RequeueAsync back to Queued unless the user paused or cancelled it meanwhile); it resumes by itself when nothing above it waits. Reviewed at every Wake (enqueue, resume, settings saved) and every poll (3 s). Jobs of the same level never interrupt each other, a job's own follow-ups never interrupt it, and only a full engine interrupts. Defaults: render, import and download high; verify and proxies low. |
An ordered list of all kinds; asking before pausing | The owner: set priorities so that a render started during a scan pauses the scan without confirmation and the scan resumes afterwards. A total order would make every pair of kinds interrupt each other (each periodic scan would pause hours of deep analysis); follow-ups work on what their parent produces. |
| 2026-10-16 | Thumbnail and proxy passes work on several photos at once through OrderedWork: up to the parallelism run on the thread pool (twice as many results wait) and their results come back in frame order on the pass's flow, so the pack writer, the counters and the checkpoints stay sequential and a checkpoint still means every frame before it is done; a parallelism of one runs inline. Decodes that develop originals whole run fewer at once for large originals (DecodeBudget.PhotosAtOnce): memory budget ÷ (largest frame × 32 bytes per pixel), 24 MP when no size is known, a size a damaged file claims saturating instead of overflowing. Proxy passes always count; thumbnail passes, deep analyses and every window of a render or its preparation count only the frames a decode at their size develops whole (DecodeBudget.Developed, SequenceFrames.DevelopedPixels): not a JPEG at least twice the size asked for (it decodes scaled down), not a frame read through its proxy or from a JPEG file, not a RAW's embedded preview of that size when previews are preferred (never in a render; another format's stored preview, such as a JPEG-compressed TIFF strip, may need the file's own tables and fall back to a full decode); a TIFF, a PNG or a developed RAW counts whole, so a render node's originals and a preparation over TIFFs are held back too. A frame window that develops originals gates every decode with that limit, read-ahead and demand loads alike (the window itself caps only its read-ahead). The server's frame window gets the host's memory budget (a quarter of the memory available, as the desktop's Auto) instead of the window's 1 GiB default. Tier probes run that many at a time (Parallel.ForEachAsync). |
Parallel.ForEach with a lock around the pack; a byte semaphore per frame |
Output identical to a pass of one photo at a time (tested byte for byte). The frames of a sequence share one size, so a limit per sequence is as good as a gate per frame. |
| 2026-10-16 | Verify, import and scan stay sequential inside their job. | Hash, copy or read metadata in parallel | They are bound by one disk or one card reader, where parallel reads are slower; the verify log keeps its order. |
| 2026-10-16 | Server: CHRONOS_PARALLELISM replaces CHRONOS_WORKERS, which still sets it (CHRONOS_PARALLELISM wins when both are set) and logs a warning at start; the Workers key of server.json still sets the parallelism and saving the setting removes it. CHRONOS_PRIORITY_QUEUE sets the queue on or off. The parallelism is 1 to 64 (the admin panel's range); a larger value from the environment or server.json, or the default on a machine with more than 128 threads, is brought down to 64, so a value the panel cannot change never blocks saving the others. Both apply at once (no restart), server.json keeps only the levels that differ from the defaults, and the admin panel lists the 14 kinds a server runs. ServerSettingsDto and DashboardDto replace Workers with Parallelism and add the priority queue. |
Keep the name Workers; require a restart | The meaning changed (jobs at once → photos at once) and an older value keeps working. The admin panel ships with the server, so the DTO rename breaks no client. |
| 2026-10-16 | Chronos.Tools i18n prune removes orphan keys (not in English and not a plural form of an English plural key) from every translation, rewriting only the files that had some, as import writes them. |
Hand edits; regex | A renamed or removed key otherwise stays an orphan in 36 languages, and resx files are never mass-edited with regular expressions. |
| 2026-10-16 | Desktop: the Jobs toolbar shows "8 photos at once" (Settings › Rendering › Parallelism) and a Priority queue chip while the queue is on, instead of "Workers n / m"; Settings › Rendering lists the 16 job kinds with a level dropdown only while the queue is on; the Jobs list orders the queue with the engine's JobPriorityQueue.ClaimsBefore. The Jobs, Settings and Admin mockups follow in phase 6 with the rest of the review. |
Keep the workers readout | One job runs at a time, so a count of busy workers says nothing. |
| 2026-10-16 | AtomicFile tries the rename over the target again for some 1 s (15 attempts, 10 ms × n) while another handle holds it: a sharing or lock violation, or Windows' "access denied" for an open file that is neither read-only nor a folder (those, like a missing file, fail at once). Sidecars, ingest journals, index snapshots and project.json are read whole and at once with AtomicFile.ReadAllBytes/ReadAllText (sharing read and delete, never a writer in place; above 2 GB an IOException, as File.ReadAllBytes). Windows refuses MoveFileEx over an open file even when the reader shares deletion. |
Rename with POSIX semantics (SetFileInformationByHandle, Windows interop in Core); take the sequence lease for every sidecar read |
Readers hold these files for milliseconds; a lease per read would queue thumbnail passes behind uploads, and Core stays free of Windows interop. Found when the faster passes of phase 2 made an upload's commit fail in the server tests. |
| 2026-10-16 | LeaseFile.TryCreate treats "access denied" on creating a lease as the name of a lease just released while a reader still holds it (pending deletion on Windows, since readers share deletion) and tries again for some 130 ms (8 attempts, 1 ms doubling), as it already did for the create-or-check race. |
Return "held" at once; stop sharing deletion in readers | Returning "held" makes the caller wait its whole poll back-off for a name free milliseconds later, and readers must never block a release or a takeover. A real permission problem still fails after the short retry. Found when the phase 2 test runs hit it in MassRenameTests under load. |
| 2026-10-16 | The rail is 200 px (Width.Rail, was 128 growing to 200 with the language's longest name) and collapses to the 48 px icons (Width.RailCollapsed) with ≡ or Ctrl+B, a window key binding gated like Ctrl+1…6 (not behind the first-run dialog; a held key toggles once). A collapsed icon's tooltip is "Name · description" (Tooltips.Nav.Collapsed, invariant) so the section is named without its label, while screen readers keep the name and, as help text, the description alone. The state is written the moment it changes, through AppServices.SavePreferences (the settings file and nothing else: no render node restart, no engine wake), and Settings reset and import keep it, as they keep the window. The admin panel's sidebar is 256 px (was 220) and collapses to 56 px of icons with its own ≡ or Ctrl+B (matched on the physical B key when that key types no letter a–z, as in Cyrillic, Greek, Hebrew or Arabic layouts; Latin layouts keep their own Ctrl shortcuts), the choice kept in the browser (localStorage chronos.admin.sidebar, like the theme; a browser that refuses storage keeps it for the page), the tables fitting their columns again after each toggle and the links' names kept for screen readers; at 900 px and below it stays the top bar, which shows icons only already, and Ctrl+B stays the browser's. Beside the wider rail at the 1200 px minimum, in every shipped language: the Jobs table's Kind, Where and State became star columns (minimums 90, 80, 116; at most 140, 140, 170, so on wide windows Target takes the rest, as in Jobs.html) and Target and Progress give way first (84, 104), so the row actions fit; a cut kind, place or header shows whole in its tooltip, and the state's tooltip starts with the state, as the sync table's does (the explanations after it were reworded not to repeat it, and "waiting for a worker" became "waits for its turn"); the trusted certificates row's server column and the cache folder's path give way first; the editor's preview tools wrap to a second line (6 px apart) instead of losing Play and Full screen, the crop-result tool always beside Crop mask and disabled while the mask is off (with its reason), so turning the mask on never moves the tools; the editor header gives the server job and its Cancel their own column, the title and the summary giving way first; the Archive tree keeps a year's label and lets its figures trim; the Import session rows, Show plan and the result line fit; the frame table's Time column holds every language's widest time and its header names trim with the name in the tooltip, header and rows sharing the actions column. Cells that can be cut repeat their text in their tooltip (Library list, Jobs, sync state, Settings encoder table and adapter, priority queue rows; EmptyToNullConverter so an empty cell shows none). Tests check, in all 38 languages at 1200 px: the Jobs row buttons, Settings' Clear and Forget, the Archive years, the Import rows and result, the frame table's times, the editor's tools and a server job's Cancel. (Owner review 1, R1.) |
A width that follows the language; save the rail state at exit; keep the admin sidebar state per user on the server | The owner fixed 200 and 256 px so names fit in every language without a jumping rail; a crash or a forced shutdown no longer loses the choice; the server keeps no presentation state per user and the theme already lives in the browser. Found by the phase's review rounds: buttons and labels cut at 1200 px in some languages (Jobs row actions, Forget, Clear, the preview's Play, a remote job's Cancel, Merge, a year in the Archive tree), Ctrl+B behind the first-run dialog, and admin tables that kept their old fit. |
| 2026-10-16 | The App test program shuts the shared WPF dispatcher down in order (WpfApplication.Shutdown: InvokeShutdown, then a join of up to 10 s) after the runner finishes, instead of letting the process end under its background thread. (Owner review 1, R1.) |
Leave the background STA thread to die with the process | The binding engine's cleanup then ran against a half-torn-down engine and crashed the exit (code 127) after every test had passed; the tests that walk 38 languages made it likely. |
| 2026-10-16 | The Sequence section is renamed Edit ("Modifica"): SectionKey.Edit, Shell.Nav.Edit and Tooltips.Nav.Edit; the classes keep their names (SequenceView, SequenceViewModel, ShellViewModel.Sequence, Icon.Sequence) and so do the editor's resource keys (Editor.*). Screenshots are edit-* (edit-picker, edit-<step>, edit-change, edit-busy). (Owner review 1, R7.) |
Rename the classes and keys too | The owner's word is the section's name; renaming twenty files and two hundred keys would change nothing the user sees and would bury the real change in churn. |
| 2026-10-16 | The editor's tabs become the steps of a guided path, freely navigable (the owner's choice): a step bar of equal cells under the header (the tab strip under the filmstrip is gone), a new first step Analysis (every finding with the step that deals with it, five measurements, the other steps with their states, Analyse), Previous · n / m · Next under the step's column (both buttons measured whole, the counter giving way), Alt+1…8, Ctrl+PgUp/PgDn (read on the way down the tree, since the filmstrip and the curve editors take Page Up/Down whatever the modifiers) and ←/→ in the bar. Each step shows a status by its own glyph (to do, ✓ done, ▲ attention, ◐ running, ○ waiting) worked out by EditPath.Of from the content, the advice, the project, the active analysis and render (SequenceJobs.Active), the render's blocker and whether a render has the current settings; no status ever blocks a step. The step's tooltip is "name · what it is for · state · Alt+n" (the name first, because a long name ends in an ellipsis in its cell: about 82 px at the 1200 px minimum, which every English and Italian name fits). After a step change the keyboard goes to the new step's cell when it was in the bar, on a control of the replaced step or on Previous turning itself off, and the preview takes it back if it falls to the window; Space on the step shown plays; Ctrl+click or Ctrl+Space never leaves the bar without a current step. The editor opens on the step last shown for that sequence in this run (a deep analysis that ended meanwhile resets its visited marks), else on Analysis while there is no current deep analysis or one waits, runs or is paused (EditPath.Start, applied again once the jobs are read unless the user chose a step), else on Frames. Last step's Next is "Next sequence". (Owner review 1, R7.) |
Steps that unlock in order; a wizard with its own window; a ninth "Result" step | The owner asked for a path from the deep analysis to completion that stays freely navigable; locking steps would get in the way of photographers who know what they want; the result belongs to phase 5's export and videos library. |
| 2026-10-16 | Step rules: Analysis is running while a deep analysis is active; needs attention when the index says AnalyzedDeep but the saved analysis describes another number of frames ("Frames changed") or cannot be read now ("Analysis unavailable": archive offline, file moved or damaged, a server that sends none; SequenceContent.DeepOfOtherFrames tells them apart); done with its warning count; else to do. Frames waits for the analysis, then needs attention while frames the analysis flags as black, white, duplicate or unreadable are neither excluded nor skipped by the render anyway. Exposure, Motion, Camera and Time wait while an Auto setting of the section needs the deep analysis and there is none, need attention while an Auto setting that applies lacks other data (timestamps, exposure data, source size: the tooltip is the advisor's reason), which taking the value over by hand settles; a setting whose switch is off (EditorSettings.Applies, the same rule as the rows' n/a) is never asked for, and a value the analysis could not measure (no usable region mask) stays at the engine's fallback. Otherwise Auto, or Edited once an Auto setting or a value set by hand differs (crop, offsets, camera moves, fit to a duration, exposure offset). Stack is optional. Export is running with its render, needs attention when the export cannot render or no render, of any age, was made from settings with the project's EditPath.Signature (which leaves out hero, frames to place, batch, folder, output name and server copy); the renders count as current when the newest keeps no settings (a server's, or one fetched from it) or none's settings can be read. Findings go to steps through EditPath.FindingSteps (all 29 keys, tested by reflection; frames of another size or orientation go to Frames, which excludes them); Frames lists its own under "Frame warnings". |
A finding count per step; any missing data as "waiting" | Counts would turn Frames ▲ for timing findings it cannot fix; analysis cannot supply timestamps or exposure data, so those need the user, not a wait; a setting shown n/a cannot be taken over, so asking for it would leave a ▲ nobody can clear. |
| 2026-10-16 | (Partly superseded by the 2026-11-03 Edit picker row: the picker lists the workspace's projects above the library's sequences, and a sequence of this PC opens as a workspace project.) The sequence is chosen inside Edit: without an open sequence, or after Change sequence (the title's ▾, Ctrl+O, Next on the last step), a picker covers the editor in place (not a popup): this PC's sequences and the server's sequences the Library knows, newest first, searched after 250 ms (Enter and ↓ in the search box wait for the list to match what was typed), read page by page (more pages are read until the open sequence, else the one edited last, is listed, then it is selected and scrolled into view); Enter or a double-click opens, Esc clears the search then goes back. The open editor stays laid out behind it (hidden, not collapsed, so its preview is not rendered again) and keeps saving each change a moment after it is made (2026-10-03 autosave). Choosing another sequence reads it first; only once it has loaded is the open one's pending change written at once and the editor closed. When the next one cannot open now (its proxies are on their way, or it fails), the open one stays open and is again the sequence asked for (ShellViewModel.KeepSequence), so coming back to Edit neither asks again nor retries; Cancel also stops a server sequence chosen meanwhile from opening over it when its proxies arrive. A failed write is either kept (Keep editing) or discarded on the user's word. Asking for the open sequence again (Library, Jobs, a project file) ends a choice of another; coming back to Edit leaves it on screen (ShellViewModel.SequenceRequests). Deleting the sequence asked for clears the request. The section remembers each sequence's step and visited steps for the run, and AppSettings.LastEditedSequence (saved with SavePreferences) is selected first in the picker. (Owner review 1, R7.) |
A popup or a separate window; close the editor when the picker opens; close it before the next sequence is read | Captures render the window's visual tree and off-screen test windows make popups fragile; keeping the editor open makes Cancel instant, and closing it only once the next sequence has loaded means a sequence that cannot open never costs the open one (nor its undo history). |
| 2026-10-17 | A double-click on a row is read on the row (MouseDoubleClick on its ListBoxItem, left button only, not over one of its own buttons) in Edit's picker and in the Library's list and grid, instead of a gesture on the list: a ListBoxItem marks every left mouse-down handled to select, so the list's gesture only ever fired on its empty area. While the user is asked whether to discard a change that could not be written, no retry runs (ProjectSaver.HoldAsync, EditorSession.HoldPendingAsync); Discard drops it unwritten (DiscardPending), Keep editing lets the retries go on (KeepPending). (Owner review 1, R7 review.) |
A double-click binding on the row template; retry during the question and drop only what is still pending | A template binding misses the row's padding; a retry that succeeds while the question is open would write the change the user is about to drop. |
| 2026-10-23 | The product is Chronos: a byte-exact rename of every tracked file's contents and path (Titano, titano, TITANO → Chronos, chronos, CHRONOS; 10,394 replacements in 1,744 files, 1,159 moved), so identifiers, namespaces, projects, CHRONOS_* variables, %LOCALAPPDATA%\Chronos, .chronos files and sidecar folders, the error code CHRONOS001 and the image name change together. No migration of old data folders or settings. Translations were then reviewed per language for forms the old name's final vowel had dictated (Finnish and Estonian cases, Hungarian, Turkish suffixes, Scandinavian genitives, Slavic and Baltic cases): 80 strings changed. Two golden values that contained the old name were recomputed (PostgreSQL MD5 response of chronos_md5, verified independently; the payload-tampering test's target). (Chronos on Gitea, R1.) |
Keep Titano in identifiers and paths; migrate %LOCALAPPDATA%\Titano and .titano files |
No release has shipped, so nobody has data under the old names; one name everywhere is what the owner asked for. |
| 2026-10-23 | The repository is BalboSoft/Chronos on the owner's Gitea (https://gitea.encke-hake.ts.net). Builds embed its web address as ChronosReleasesUrl (replacing ChronosReleasesRepo, an owner/name on GitHub): the update check reads <server>/api/v1/repos/<owner>/<name>/releases?draft=false&pre-release=false (a path prefix in front of the owner is kept), the licence opens <repository>/src/branch/main/EULA.md, issues <repository>/issues, and Add/Remove Programs shows the repository. (R2.) |
Two properties (server and repository); keep the GitHub API shape | One address is what the owner sees in the browser; Gitea's release JSON has the fields the update check reads (tag_name, html_url, draft, prerelease, assets[].browser_download_url). |
| 2026-10-23 | Releases are published in the repository that runs the workflow; the separate public releases repository of BRIEF §19.4 becomes optional (RELEASES_REPO and RELEASES_TOKEN). EULA.md and SECURITY.md move to the repository root and the issue forms to .gitea/ISSUE_TEMPLATE (Gitea's about key instead of GitHub's description), so they are live where the releases are; deploy/releases-repo/ keeps only the README of a separate repository, to which release.yml copies the rest. Security reports go privately to the maintainers: Gitea has no private vulnerability reporting. (R2.) |
Create BalboSoft/chronos-releases |
§19.4 split the repositories because a private GitHub repository cannot serve release files; on a self-hosted Gitea the owner decides visibility of the one repository. |
| 2026-10-23 | Gitea Actions workflows in .gitea/workflows run on act_runner in Docker mode: the .NET jobs use the mcr.microsoft.com/dotnet/sdk:10.0 container and check out with git (the image has no Node.js for JavaScript actions), install the system SQLite (libsqlite3-0) the image lacks, use no artifacts or caches, and build with 4 cores (BUILD_CPUS) because the runner shares its host with Gitea, which stalled during the first unthrottled ReadyToRun build. Jobs that need docker use the runner's own image and the host's daemon. (R3.) |
actions/checkout and actions/setup-dotnet in the runner image |
Downloading the SDK on every job costs minutes and network; the SDK image stays on the host after its first pull. |
| 2026-10-23 | The release cross-compiles the Windows programs on Linux (EnableWindowsTargeting, win-x64 runtime packs, ReadyToRun through the Linux crossgen). Chronos.Tools pe-check fails the release (and CI) when a published program is not a GUI program or lacks its icon, version information or PerMonitorV2 manifest, which the SDK copies into the apphost. Optional Authenticode signing uses osslsigncode (signtool needs Windows); the payload format already tolerates the appended certificate table. (R3.) |
Require a Windows runner for releases | The owner's only runner is Linux; the resource check measured on the runner showed icon, version and manifest present, and the check keeps it that way. |
| 2026-10-23 | New Chronos.Tools commands for the Linux runner: zip (the SDK image has no zip program), gitea-release (creates a draft for a new tag, uploads every file replacing same-named ones, publishes, then checks that every file is listed at its size; token from an environment variable, never printed) and postgres-ci (MD5, cleartext and trust roles with their pg_hba lines and TLS with a self-signed certificate for the service host name, all through SQL as the superuser: pg_read_file, lo_export, COPY … TO PROGRAM 'chmod 600' for the key, ALTER SYSTEM; the CI server also runs without durability, fsync, synchronous commit and full-page writes off, because on the runner's shared storage the 100k-frame bulk insert of the Phase 2 gate took 21–33 s against its 15 s budget, a measure of the host's disk instead of the client's COPY path). .github/scripts/postgres-ci-setup.sh is gone: Gitea gives no service container id to docker exec into. (R3.) |
curl and jq scripts; install docker or psql into the job | The SDK image has neither jq nor psql nor docker; C# commands are tested like the rest and keep the zero-package rule. |
| 2026-10-23 | The server image is built for linux/amd64 only and pushed to the Gitea container registry (<host of PUBLIC_URL>/<owner>/chronos-server) with the REGISTRY_TOKEN secret; :latest moves only to the highest stable version among the published releases, read back after publishing. The workflow's own token is refused by the organisation's registry (measured), so without the secret the image job fails with instructions while the release itself is already published. (R3.) |
Multi-arch with QEMU; fail the whole release | Multi-arch needs QEMU's binfmt handlers installed on the owner's host, a change to the host outside the repository; the Windows programs should not wait on a registry credential. |
| 2026-10-23 | The Windows-only CI (Core.Windows and App tests, screenshots and their diff, the installer test) is the windows job, run only when the repository variable WINDOWS_RUNNER names a Windows act_runner in host mode; until then those tests run on a Windows PC before a merge. The Definition of Done says so (CLAUDE.md, BRIEF Appendix A). (R3.) |
Drop them; fail CI without a Windows runner | They are the only automatic proof of the installer and the screens; a job that waits for a runner that does not exist would hold every run. |
| 2026-10-23 | Update check: the client reads the published stable releases and takes the highest version, because Gitea's releases/latest is the most recently created release (a re-published older tag or a backport would become it); a pre-release build (0.1.0-rc.1) is offered the final release of its own version, which it used to call "up to date" forever; a 404 is a failed check, because Gitea answers 404 for a repository the client may not see (the BalboSoft organisation is private today) and that used to read as "up to date". The release workflow picks :latest the same way. gitea-release checks every file's size before it publishes, and when it replaces the files of a release clients can already see it removes the old SHA256SUMS first and uploads the new one last. (R2, R3; independent review of this change.) |
Trust releases/latest; leave the pre-release rule as it was |
The first release is a pre-release: its testers must be told when 0.1.0 is out; a download checked against the checksums of another build would be refused. |
| 2026-10-23 | Timed tests (bulk insert, JPEG and RAW decode, resampler, light analysis, metadata robustness, scroll smoke, and the lease renewal test's timer periods) take their budget from TestTiming.Budget, stretched by CHRONOS_TEST_TIME_FACTOR (at least 1, default 1); ci.yml and release.yml set 3, perf.yml nothing. On the owner's runner, which shares its CPU and disks with Gitea and the server's other containers, the 100k-frame SQLite bulk insert took 10–19 s against 15 s from one run to the next. (R3.) |
Raise the budgets; move the timed tests to perf.yml | The budgets stay what a developer's PC must meet and the weekly performance gates measure them unstretched; a CI run fails on a real regression, not on a busy host. |
| 2026-10-23 | The update check builds the release page (<repository>/releases/tag/<tag>) and the download links (<repository>/releases/download/<tag>/<name>) from ChronosReleasesUrl and takes only the tags, names and sizes from Gitea's answer: Gitea writes html_url and browser_download_url with its ROOT_URL, the owner's being http://192.168.30.23:3000, so the first release's links were plain http on a LAN address and the https-only check ignored the release. Without a repository address (tests) the answer's links are used as before. (R2, after the first release.) |
Ask the owner to set ROOT_URL to the public https name | The build already names the address its users reach; the client then works whatever Gitea's ROOT_URL is, and a ROOT_URL change stays the owner's choice. |
| 2026-10-26 | The server image's :latest follows the highest stable release, or the highest pre-release while no stable release exists; the releases repository's content and the in-app update check still follow stable releases only. Chronos.Tools release-channels --tag <tag> --releases <page.json> […] prints both answers (latest=, image_latest=) from every page of Gitea's releases list (releases?draft=false&limit=50&page=<n>, saved by curl, one --releases per page) by SemVer 2.0 precedence: drafts and tags that are not v + strict SemVer 2.0 are ignored, the tag itself always counts, a release Gitea flags prerelease counts as one whatever its tag, build metadata is ignored and equal precedence counts as highest; a body that is not a JSON array (a sign-in page, an API error) is refused (exit 2), and the tag then moves no channel (next row). It replaces curl + grep + sort -V in release.yml and the 2026-10-23 rule ":latest only for the highest stable version". (Owner review 2, R1.) |
Point the Unraid template and compose at :nightly or a pinned :<ver>; push :latest for every pre-release; keep sort -V over all releases |
With only pre-releases published (v0.1.0-rc.1, rc.2) :latest never existed, so the template and compose found no image. Users should get the newest release, not the untested nightly build of main. A pre-release published after a stable one, or an older tag re-published, must not move :latest. sort -V ranks 1.0.0-rc.1 above 1.0.0, so it cannot compare pre-releases with stable releases. |
| 2026-10-26 | release.yml decides the channels after publishing, from every page of the releases list (page=1, 2, … up to the first empty page, at most 100); when it cannot (a page unreadable or not a JSON array, more pages, or a tag older than release-channels, such as v0.1.0-rc.1 and rc.2, whose Chronos.Tools is built from the tag and lacks the command) it warns and the tag moves neither the releases repository nor :latest, while the image job still pushes :<ver>. The Version step checks the tag with release-channels' SemVer 2.0 pattern without +BUILD (no leading zeros, no empty identifiers), so a tag the command would refuse stops before anything is built or published. (Owner review 2, R1; review of phase 1.) |
Fail the step; build Chronos.Tools from the workflow's own commit for this command; read one page |
The release is already public when the channels are decided: failing then loses the image as well, while moving no channel is always safe, and a second build for two old tags costs minutes. Pre-releases now share Gitea's 50-a-page list with stable releases, so one page could hide the only stable release and move :latest to a pre-release. |
| 2026-10-26 | The admin panel's free space comes from an optional space path (SpacePath in server.json, CHRONOS_SPACE_PATH): the Unraid template maps the share's array view /mnt/user0/Timelapse read-only to /space (Array view) and sets Space path to /space (advanced); empty means the archive's volume, as before. The archive's own volume, where uploads land, is shown apart as Write volume. ArchiveStatsDto keeps FreeBytes/CapacityBytes as the shown volume's figures and gains optional WriteFreeBytes, WriteCapacityBytes, FileSystem and UsesSpacePath. (Owner review 2, R2.) |
Sum the array disks (/mnt/disk*) mapped into the container; read Unraid's emhttp state files; call Unraid's API |
The container sees only what is mapped: one read-only mount of the same share's array view gives the array's figures with no host access, no external process and no Unraid-specific code. Only the server builds the stats and only the admin panel reads them, so the new members break no client. |
| 2026-10-26 | The file system type and mount of a folder come from /proc/self/mountinfo on Linux: the longest mount point that is the folder or one of its parents, of mounts stacked there the last listed, octal escapes (\040) decoded; elsewhere DriveInfo.DriveFormat. (Owner review 2, R2.) |
DriveInfo.DriveFormat alone; findmnt or stat -f |
DriveFormat calls a FUSE mount only "fuse", never fuse.shfs, which is what tells an Unraid share apart; external processes are not allowed at runtime. |
| 2026-10-26 | A space path that is missing or cannot be measured falls back to the archive's volume with one warning: at start, and again only after it has been measured in between. (Owner review 2, R2.) | Refuse to start; warn on every request | The template's default (/space) without the mapping must not stop the server or flood the log. |
| 2026-10-26 | The write volume is shown only when its figures differ from the space volume's: another total size, or free space more than 64 MiB apart. (Owner review 2, R2.) | Always show both; compare device ids | Two reads of one volume a moment apart differ by what was written in between; comparing figures also works on Windows. |
| 2026-10-26 | Completing a frame upload, a render upload or a render node's result first checks the archive root's volume for the upload's size + 64 MiB and answers 507 insufficient_storage with the upload still receiving; a volume that cannot be measured refuses nothing. The start keeps checking /data only. (Owner review 2, R2.) |
Check only at upload start; fail the upload; check the space path | The staging copy lands on the archive's own volume (on Unraid the share's primary storage, often the cache); refusing before the state change keeps the part file, so the client can complete again once there is room. |
| 2026-10-26 | Free space comes from one injectable VolumeSpace service (Server/Storage, registered with TryAddSingleton; tests override Measure), also for the /data checks at upload start and for the diagnostics report, which lists the archive, the space path and /data with free space, file system and mount; the static UploadRules.FreeBytes is removed. (Owner review 2, R2.) |
Keep a static helper | One source for every check, and tests can simulate a full volume. |
| 2026-10-26 | Admin panel menu in two groups: Dashboard, Users, Archive, Jobs and Logs from the top; Settings docked at the sidebar's foot above the account, or at the end of the top bar on narrow screens; on a short window only the pages above scroll, so Settings and the account stay in view. pages/about.js is gone: About is the last, read-only group of Settings (version, API version, database, uptime counting on from when it was read; the last two fill in when the admin dashboard answers, so the form never waits for its archive statistics, and they stay off the anonymous /server/info), without the server name and certificate fingerprint rows that the Server and Network groups already show. #/about opens Settings on that group (focus on its heading) and rewrites the address to #/settings. (Owner review 2, R4, R5.) |
Keep About as a page; an About dialog from the account box; repeat the name and fingerprint rows in About | One sidebar entry less, as the owner asked. Repeated rows on one page are noise, and the name row was stale after a save. Old bookmarks keep working. |
| 2026-10-26 | The Settings icon is an 8-tooth gear with a centre hole (outer radius 6.5, valleys on 4.6, teeth 0.6/0.85 half-width at tip/base, hole 1.7), drawn by gear() in branding/ui-icons/icons.py. The script now also writes the admin panel's icons.js (through a name map; the unused about icon dropped) and writes every file as UTF-8 with LF on every OS. (Owner review 2, R4.) |
6 teeth (crisper at 16 px but less familiar); wider hollow teeth (they merge at 16 px with 1.5 px strokes); radial stubs on a ring (close to the old sun); keep icons.js by hand |
8 narrow teeth close up into solid knobs at 16 px with open gaps, read as the usual settings gear at 20–32 px and stay distinct from Sun. One generator keeps the desktop and web paths identical. On Windows the script wrote Icons.xaml in the ANSI code page, garbling its header. |
| 2026-10-26 | Desktop About becomes the last Settings page (SettingsPage.About); SectionKey.About and AboutView are gone and the rail keeps Settings alone at the bottom. AboutViewModel (now Chronos.App.About) stays a view model owned by the shell (Shell.About), not a section, so the Updates page's bindings and the update check on start are unchanged. The page shows identity only (version, build, runtime, system, licence, third-party notice, translation notice outside English) and has no Reset section; the Releases link moved to Updates › Latest version; About's own diagnostics bundle and Open data folder buttons are removed (Advanced has both). (Owner review 2, R5.) |
Move UpdateFlow into SettingsViewModel; embed the old AboutView inside Settings; repeat the data folder, diagnostics and update rows on About |
Smallest change that keeps every Shell.About binding and the update check on start; one place per action avoids duplicates inside Settings, and saving space is what the owner asked for. Nothing navigated to the About section, so no link needed redirecting. |
| 2026-10-26 | Import › Folder… Whole folder (ImportGrouping.WholeFolder) makes one sequence per file format: camera bodies and pauses are ignored, formats are not; only the user's splits break it (the session splitter runs with no gap and a minimum of 1). The title defaults to the folder's name and fills {title}; a typed title wins. A repeated import gives the folder's name only to a sequence without a title: the archive applies a title only when it creates the sequence, and a server import reads the sequence first and names it only when it has none, so a rename made on the server survives (a typed title is still set). The plan row shows "Canon EOS R5 · CR3" or "2 cameras · JPEG", with both dates when the photos span several days, and a split part merges back into the part before it of the same format. Switching the grouping clears the user's splits and merges. (Owner review 2, R9.) |
One sequence holding every file; one sequence per camera body | A folder shot RAW+JPEG would otherwise hold every instant twice, doubling the time-lapse; formats also decode and render differently. Bodies are ignored because the owner asked for the folder's sequence "in its entirety". |
| 2026-10-26 | A whole folder's session key is folder- + the first 16 hex digits of SHA-256 of "PC name, full path (trailing separator trimmed, upper-cased on Windows), format", plus -yyyyMMdd-HHmmss of the first photo for a part the user split off. The grouping is not stored in card profiles: a folder starts on Sessions, and cards and drives are always planned by sessions. (Owner review 2, R9.) |
Hash of path and format only; remember the grouping per folder | The same key for the same folder lets an interrupted or repeated import continue its sequence through the existing session-key lookup. The server files client uploads by session key without user scope, so the same D:\Photos\Trip on two PCs must not land in one sequence; renaming the PC starts a new one (hash duplicate detection still prevents doubled frames). Folder sources have no profile today, so the simplest safe default applies. |
| 2026-10-26 | Schedule recurrences use an in-house text form: every:<n>m|h|d (5 minutes to a day, 1–168 hours or 1–366 days), daily:HH:MM, weekly:mon,thu@HH:MM, monthly:<1–28>@HH:MM, with a structured form (RecurrenceDto) for the editors. Intervals are fixed durations on the grid of the previous due time (a day of an interval is 24 h); daily, weekly and monthly times are wall-clock times of the host's zone: a time a spring-forward gap skips moves forward by the gap, and a time the clocks go back over runs once, at its first occurrence. (Owner review 2, R10.) |
Cron expressions; a calendar rule engine (RRULE) | No package may parse cron (rule 1), and an in-house cron would be more code than four shapes that cover every action and fit a form. Day 28 exists in every month; 5 minutes keeps the queue sane. |
| 2026-10-26 | A schedule's run is claimed with a compare-and-set on next_run (UPDATE schedules SET next_run = <next> WHERE id = … AND enabled AND next_run = <expected>); only the process that wins queues the jobs. An edit that keeps the recurrence never writes next_run, so it cannot undo a run claimed at the same moment. A crash between the claim and the queueing loses that one run (the claim is logged at Debug). (Owner review 2, R10.) |
Advisory locks or a leader election; the claim and the jobs in one transaction | The same SQL works on SQLite and on several servers sharing one PostgreSQL, and the jobs go through the engine's own queueing. Losing one run of a recurring job is harmless: the next one comes. |
| 2026-10-26 | System schedules are seeded at every start with INSERT … ON CONFLICT (system_key) DO NOTHING: a row that exists, edited or not, is never overwritten, so the user's edits survive restarts and upgrades. They can be edited, turned off and reset to the host's defaults (built from its options as they are at the reset), never deleted, and keep their name and action; clients show them by key in the user's language (the stored name is English). A row whose key a host no longer defines stays and can no longer be reset. Rows seeded together are stamped a microsecond apart to keep the host's order. (Owner review 2, R10.) |
Overwrite the defaults at start; allow deleting them | The owner wants no hidden timers: each one is a row the user sees and controls, and an upgrade must not undo a change. A deleted system schedule would come back at the next start. |
| 2026-10-26 | The timers that queued work are gone: on the server ArchivePolling, DatabaseBackupService and the periodic sweep of UploadMaintenance (which now only recovers interrupted commits at start); on the desktop the rescan loop and DatabaseBackups.RunDailyAsync; in both the job engine's history purge at start. Their work is done by system schedules, with keys shared by both hosts: on the server archive-scan (every 10 minutes, no catch-up), upload-cleanup (the uploads step), index-backup (SQLite only), housekeeping (job-history) and audit-cleanup (audit); on the desktop archive-scan, index-backup and housekeeping (job-history, cache-trim). The audit log has a schedule of its own because a clean-up job has one age limit. No other schedule is pre-seeded. (Owner review 2, R10.) |
Keep the timers beside visible schedules; one housekeeping schedule for job history and audit | "No pre-scheduled job may be missing from this page"; one place for recurring work. Job history (90 days) and audit (forever by default) need two limits. |
| 2026-10-26 | A run more than 5 minutes late was missed, checked on every pass and not only at start (a PC that slept): with catch-up it fires once, otherwise the schedule moves to its next occurrence without running. A next run more than two periods ahead means the clock went back and is computed again. A new interval schedule first runs one interval after it is created or seeded. A run is skipped-pending while the schedule's previous job is queued, running or paused, checked before the action's own checks. (Owner review 2, R10.) |
Catch-up only at start; run interval schedules at once | One rule covers a host that was off and a laptop that slept. Running at once would surprise a user who just created a schedule; Run now does it on request. |
| 2026-10-26 | Live services are not schedules: on the server the read of archive.json every 10 minutes, the render-node monitor and the LAN beacon; on the desktop the sync agent, the render node, card and drive detection, the look for an unplugged archive every minute and the update check at start. They queue no recurring job and change no user data; the transfers the sync agent decides are jobs in the queue. (Owner review 2, R10.) | Make every timer a schedule | They keep a connection, a device or the archive's settings current from moment to moment and show in their own screens. As schedules they would fill the job history with runs nobody would edit, and turning one off would break sync, discovery or uploads. |
| 2026-10-26 | No schedule empties the trash: the clean-up step trash-report lists the trash entries older than its limit (30 days by default) with their sizes in the job log and deletes nothing; no system schedule uses it. Clean-up steps delete only what the product made and no longer needs (job history, audit entries, temporary and cache files). (Owner review 2, R10; BRIEF §0.2 rule 8.) |
A timed emptying of the trash | Deleting user data needs an explicit user action, and the trash is the user's last copy. |
| 2026-10-26 | The job engine no longer purges finished jobs at start (JobEngineOptions.HistoryRetention is removed): the job-history step of the housekeeping schedule does, daily at 04:00 with catch-up, with the schedule's own age limit (90 days). On the server JobHistoryDays (server.json or API) is only what that schedule is seeded and reset with: its field left the admin panel's Settings, and a new value needs no restart. The audit log is purged the same way, by the audit step. (Owner review 2, R10.) |
Keep the purge in the engine as well; keep the Settings field and copy it into the schedule | One place for each retention, shown to the user, and a host that rarely restarts still purges. Two editable places for one value would disagree after an edit in either. |
| 2026-10-26 | The audit retention has one source, the audit-cleanup schedule. ServerOptions.AuditRetentionDays (default 0 = forever, 0–3650, CHRONOS_AUDIT_RETENTION_DAYS) is what it is seeded and reset with; at 0 it is seeded off, so an upgrade deletes nothing. Settings › Logs › Keep audit shows the limit in force (the schedule's age limit, 0 while it is off) wherever it was last set; saving a different value sets the schedule (on with that limit, off at 0, no restart) and stores it as the reset default, and saving it unchanged writes neither. The variable is put into the schedule at every start before the first pass (Scheduler.StartAsync(host, beforeFirstPass)), so a run caught up at start already uses it; changing its days, or turning the schedule off while they are above 0, is then 409 setting_locked, and the panel field is read-only. (Owner review 2, R10, R11.) |
A default of 365 days; the setting and the schedule as two sources; the variable as a seed only | Audit entries are product data an upgrade must not delete unasked. One value shown in two places that disagree misleads, and so would a variable that did nothing on an existing install or that a caught-up run ignored. |
| 2026-10-26 | The archive scan still runs at start: the server runs archive-scan once when it starts; the desktop once the archive is reopened at start, and again when an unplugged archive is back (Scheduler.RunSystemNowAsync). It does not when the schedule is off, has run since the start, or its scan is pending. The schedule itself has no catch-up. (Owner review 2, R10.) |
Wait for the first interval; catch-up on | The former polling scanned at start, so photos added while the program was closed appear at once; catch-up would also fire after every short pause. Turned off, nothing runs. |
| 2026-10-26 | A scan schedule's deep parameter is optional; unset, the host decides at every run (IScheduleHost.DeepAnalysisAfterScan): the desktop reads Settings › Analysis › After a scan then, as for scans started by hand, and the server says no. The desktop's archive-scan is seeded without it. (Owner review 2, R10.) |
Seed deep from the setting once |
A setting changed after the upgrade would otherwise never reach the scheduled scans. |
| 2026-10-26 | The server's upload-cleanup runs every 6 hours (UploadSweepHours) with catch-up, keeping finished upload records 90 days. An idle upload still expires after UploadRetentionHours (48), up to 6 hours later than with the former half-hourly sweep. (Owner review 2, R10.) |
Every 30 minutes, as the timer did | 48 clean-up jobs a day would bury the job history; four are enough for a 48-hour expiry. |
| 2026-10-26 | Scheduled is a tab inside Jobs: on the desktop a Queue · Scheduled segmented control first in the toolbar (New schedule at its end), on the admin panel header tabs (#/jobs?tab=schedules, New schedule only on that tab); not a rail or sidebar entry. A job a schedule queued carries a Scheduled pill linking to it, and a schedule's runs link to their jobs. (Owner review 2, R10.) |
A page of its own; a section under Archive | The owner asked for a space within job management; the rail and the sidebar stay as R4/R5 left them, and a schedule sits next to the queue its runs fill. |
| 2026-10-26 | New job kinds Backup and Cleanup (stored as 16 and 17) and read-only report handlers for Duplicates and Orphans, all four registered by ArchiveService.CreateJobHandlers, so both hosts run them (POST /api/v1/jobs with duplicates or orphans now queues a report instead of answering 409 job_unavailable); their priority-queue level is Low. Hosts add their own clean-up steps through ArchiveServiceOptions.CleanupSteps; a step that fails fails the job after the others ran. The scheduler lives in Chronos.Data/Scheduling, the handlers and steps in Chronos.Data/Housekeeping; migration 0007 adds schedules and jobs.schedule_id. (Owner review 2, R10.) |
A handler provider each host registers; backups and clean-ups outside the job queue | Logged, cancellable and shown in Jobs like everything else; one registration point means neither host forgets a handler. |
| 2026-10-26 | A run queues at most 500 sequences per job (a larger set becomes several jobs, and the schedule records the first one's id) and leaves out the sequences a pending job of the same kind already covers. Verify takes percent of the archive's sequences (rounded up), never-verified first, then the least recently verified, only those unverified for olderThanDays (defaults 100 % and 30 days); at 100 % and 0 days it is one verify of the whole archive. (Owner review 2, R10.) |
One job per run whatever its size | Small target_ids, resumes and cancels in manageable pieces; a rolling verify spreads the hashing of a large archive over several runs. |
| 2026-10-26 | Index backups are the Backup jobs of the index-backup system schedule: desktop every:1d, server daily:03:00, both with catch-up and Copies kept 3, into backups next to the index; SQLite index files only (not seeded on a PostgreSQL server, unavailable for an index in memory). DatabaseBackups.RunDailyAsync is removed. The backups folder has one retention, the largest Copies kept of the backup schedules (enabled or not; 3 without any): Back up now, Back up database and the copy kept before a restore prune to it, and a backup job keeps the larger of its own value and that one, so a schedule that keeps fewer never deletes copies another keeps. A newly seeded system schedule whose work was last done a whole period ago (SystemSchedule.LastDone; for index-backup the newest copy) is due at once, so the first start after the upgrade copies when the newest copy is a day old; otherwise, and on a fresh install, the first copy comes at the first occurrence (on the desktop a day after the first start, on the server at the next 03:00). (Owner review 2, R10.) |
A fixed nightly time on the desktop too; a count of its own for each way of copying; the first copy at the first occurrence after an upgrade as well | A desktop rarely runs at night, a server always does. Two counts on one folder would delete each other's copies. An upgrade must not leave an index without a recent copy for another day. |
| 2026-10-26 | The server reads archive.json every 10 minutes on a timer of its own in SchedulerHost, whatever the archive-scan schedule does (pending, daily or off); the timer queues no job. Every schedule run also reads it first (ServerScheduleHost.GetArchiveAsync). (Owner review 2, R10.) |
Read it only in the scan schedule's runs; read it in Scheduler before the pending check |
Uploads follow the settings a desktop sharing the archive wrote, as with the former polling, also while a long scan is pending or the schedule is off; the Data layer stays the same for both hosts. |
| 2026-10-26 | Schedule API /api/v1/schedules (ManageArchive): PUT and PATCH both change the fields given (parameters replaced as a whole); 400 invalid_schedule names the field; 409 schedule_system for deleting a system schedule, schedule_no_defaults for resetting a user's, and schedule_pending for Run now while the last job is queued, running or paused (checked first, so nothing is recorded); a run that skips for another reason is 200 with its outcome. Audit actions are schedule_created, schedule_updated, schedule_deleted, schedule_run and schedule_reset, with details name · action · recurrence[ · off] (a run: name · outcome), after system:<key> · for a system schedule; the admin panel shows them in words, a system schedule by its name in the panel's language. (Owner review 2, R10.) |
Only PUT; dotted action names; map skipped-pending to 409 | UpdateScheduleRequest has partial semantics like users and sequences; the existing actions are snake_case; a refused request must not overwrite the last outcome; the key makes the entry readable in every language. |
| 2026-10-26 | Schedule changes are a WebSocket event, scheduleChanged {scheduleId, deleted}, published for every create, edit, reset, delete and run (skipped and unavailable runs included) and every move of a next run; the admin panel's Scheduled tab reloads on it and on jobState, debounced 800 ms. Older clients ignore the unknown type. (Owner review 2, R10.) |
Reload only on jobState and after the panel's own actions |
A run that queued nothing, a moved next run or another administrator's edit would otherwise show only at the next reload. |
| 2026-10-26 | The server's schedule zone is TimeZoneInfo.Local (the container's TZ), reported by its IANA id where the platform maps one; off Windows a TZ the system does not know falls back to UTC with a warning. Every time on the admin panel's Scheduled tab (next run, last result, runs) is in that zone, named on the tab, and in the browser's only when Intl does not know it. The desktop uses the PC's zone. (Owner review 2, R10.) |
Show the times in the browser's zone | "Daily at 03:00" next to a next run shown at 04:00 for a browser elsewhere would contradict itself. |
| 2026-10-26 | Desktop cache trim (step cache-trim, CacheStore.Trim) brings the cache down to Settings › Storage › Cache limit, the least recently written files first; files that cannot be opened exclusively are skipped, and proxies/, render-node/ and server-import/ are never trimmed (they still count towards the size); a folder Chronos did not create is left alone. (Owner review 2, R10.) |
Trim everything, oldest first | Those folders hold the complete proxy sets the sync keeps, the render node's own cache at the same limit and copies waiting for upload; Settings › Storage › Clear still empties all of it. |
| 2026-10-26 | Desktop toasts: a schedule's Background run raises one only when it fails, unless it is upkeep the next run repeats (scan, thumbnails, proxies, light analysis, clean-up), so a failed index backup or verify is said. Run now raises one only when it queued nothing (skipped, unavailable, failed). Delete and Reset are confirmed; the editor has no default button (Enter never closes it unsaved) and Esc cancels. (Owner review 2, R10.) | Background jobs always silent, as before; a toast for every scheduled run | A failed backup must be noticed, while a scan failing every 10 minutes is no useful toast (the rail badge still counts it); queued runs show in the job bar and the row. |
| 2026-10-26 | Desktop texts: next runs read Today, Tomorrow or Yesterday and a time, else a short date and a time; weekly days follow the UI language's first day of the week in the table, the editor's summary and its toggles; system schedules show by key in the UI language, and the editor's choices switch language live. --capture runs the scheduler on a stopped clock (SampleData.Now) with two sample schedules, so jobs-scheduled and jobs-schedule-editor are the same on every run. (Owner review 2, R10.) |
Monday first everywhere; the stored English names | Short, unambiguous texts in every language; screenshots must not change between runs. |
| 2026-10-26 | Desktop: the archive is reopened before the scheduler starts, whose first pass settles the runs missed while Chronos was closed; an archive unplugged at start is looked for every minute (ReopenInterval; before, every rescan interval), then scanned and the scheduler woken. Settings › Archive › Rescan every is removed: ScanIntervalMinutes stays in settings.json only as the seed and the Reset value of archive-scan (clamped to 5–1440 minutes). When the index does not open, the Scheduled tab says the schedules do not run. (Owner review 2, R10.) |
Keep Rescan every and copy it into the schedule | The user's interval survives the upgrade, with one editable place for it. |
| 2026-10-26 | Log defaults: level Information, files kept 14 days, a numbered part from 50 MB, 1,024 MB for all of a program's files, daily files, audit kept forever (0), 4 MB of the end of each log in the diagnostics zip; an MB is 2²⁰ bytes. Server ranges: retention 1–3650 days, file 0–10240 MB, total 0–1048576 MB and not below the file size (0 = no limit for either), audit 0–3650 days, diagnostics 1–1024 MB; a value out of range stops the start or is 400 invalid_setting. The desktop offers presets in combos, lists a value set elsewhere with them once it is brought within range, and raises a total below the file size to that size (LogFileOptions.TotalBelowFile). The Uploader and Setup keep daily files with the default limits. (Owner review 2, R11.) |
No size limits, as before; refuse the desktop's out-of-range values | Bounded disk use with about the history kept before; a combo cannot hold an invalid value, so the desktop corrects what a file brings instead of refusing it. |
| 2026-10-26 | Log rotation is daily or hourly by the UTC clock: prefix-yyyyMMdd.log or prefix-yyyyMMdd-HH.log; a full file continues in prefix-yyyyMMdd[-HH].N.log, and a restart continues the period's newest part. Pruning runs at every new file and when the options change: by age (last write), then the oldest while the sink's own files exceed the total; only names of the sink's own pattern are touched, never the file being written, and the total counts one prefix. (Owner review 2, R11.) |
Size-only rotation; weekly files; delete any *.log |
Names sort and read as before; other programs' logs and files placed by hand are never deleted. |
| 2026-10-26 | Bug fixed: the server's file logger enabled only Information and above, so CHRONOS_LOG_LEVEL=Debug or Trace never reached /data/logs, and the engine's Log.MinimumLevel was never set. The logging pipeline now runs at Trace with one filter per provider (console, file) that reads a level switch at every line; ASP.NET Core's categories stay at Warning or above and Microsoft.Hosting.Lifetime at Information or above; Log.MinimumLevel is the lower of the two levels. (Owner review 2, R11.) |
Rebuild the logger factory at every change | A change in Settings › Logs applies at once, without a restart; a line per request below Warning would bury everything else. |
| 2026-10-26 | CHRONOS_LOG_LEVEL keeps its meaning (files and console) and sets and locks both levels; CHRONOS_LOG_CONSOLE_LEVEL, read after it, sets the console alone and wins for it. In server.json LogLevel now sets the files only and ConsoleLogLevel the console. Levels are names in any case (also info, warn, off); numbers are refused. GET/PUT /server/settings carries lockedBy, the variable that fixes each locked setting (of two, the one that wins; ignored when saving), and the panel's tooltip names it; the panel's own map of variables is gone. The deploy files no longer set the variable (the Unraid Log level is empty, compose has it commented out), and the upgrade note tells existing containers to remove it. (Owner review 2, R11.) |
A nullable console level meaning "as the files"; keep Information in the deploy files |
Existing environments keep working with a simple two-level model; a variable left by an old template would otherwise lock both levels without a word, and only the server knows which variable won. |
| 2026-10-26 | ServerSettingsDto carries the log group as a nested LogSettingsDto; a PUT without it (an older panel) keeps the log settings, and saving applies them at once (ServerLogging.Apply). Desktop: Settings › Advanced gets six log rows, applied to the files at once and from the first log line of every launch (AppLogging.Open, also a launch that only hands over to the running Chronos), and Advanced gets a Reset section that restores them. (Owner review 2, R11.) |
Flat DTO fields; apply the desktop's settings once the app has started | The group mirrors the panel's Logs group. The first line opens a file and prunes, so the defaults would delete what the user keeps longer. |
| 2026-10-26 | Logging never fails what logs: Log.Write drops a line its sink throws on (anything but OutOfMemoryException), TeeLogSink isolates each sink, FileLogSink drops a line it cannot write (folder removed, disk full, file locked) and tries again at the next line without creating a removed folder again, and the server's LoggerSink drops the AggregateException Microsoft.Extensions.Logging throws. Before, an unwritable log left a failed job Running and could stop the job engine's worker and the scheduler's loop (seen as intermittent test failures). (Owner review 2, R10, R11.) |
Let logging errors surface; create the folder again | Logging runs inside error handling (a job marked failed, a scheduler pass): the job's state and the next run matter more than a line. A removed log folder stays removed, its lines lost until the next start, rather than reappearing behind the user's back. |
| 2026-10-26 | Setting a system schedule's age limit above 0 (Settings › Logs › Keep audit, or CHRONOS_AUDIT_RETENTION_DAYS at start) also ticks its default steps back on; while an environment variable fixes the age above 0, turning the schedule off, changing the age or unticking those steps is 409 setting_locked, and the panel disables those controls. The audit retention in force is 0 while the audit step is unticked. Keep audit and Jobs › Scheduled are last-writer-wins, like every panel setting. (Owner review 2, R10, R11.) |
Leave the steps as edited; a separate lock per step | A limit set in Settings must take effect, and a variable's limit must not be undone from the panel. |
| 2026-10-26 | Deleted photos go to .chronos/trash/photos/<sequence id>-<yyyyMMddHHmmss>[-n]/originals/… next to a <name>.json record: each photo's frame record, each file's former place, size and SHA-256, the sequence's title and folder, who deleted them, when, and the kind (photos, or replaced for a later conversion). An XMP companion goes with its photo when no photo that stays shares its name (listed once per folder, case-insensitively). The trash lists these entries as photos-<folder> beside the deleted sequences (TrashKind Sequence, Photos, Replaced). A deletion may name the frames version its photos were read at (refused with frames_conflict when the frames changed since) and is refused when every photo would go (would_empty). (Owner review 2, R6.) |
Delete the files; flag the frames excluded; a trash in the index only | BRIEF §0.2 rule 8: nothing is erased until Empty, and the sidecars stay the truth. One listing serves restore and empty for both kinds; a sequence without photos is deleted whole, which keeps its settings and renders. |
| 2026-10-26 | A photo deletion writes remove.pending.json in the sequence's .chronos before its first move, and its record as <name>.json.pending, which the trash never lists, restores or empties, until the sidecar is written. A failed move or sidecar write puts back what moved. A crash in between is settled by the next writer of the sequence (SequenceWriter.ReadLocked; also a scan and a sequence delete whenever a journal exists): while the sidecar still lists the frames, the files go back and the record and folder go (a file whose place is taken again stays, and its entry is then listed); otherwise the record takes its own name. Once the sidecar is written the deletion stands even if the index cannot follow (logged; the next scan resyncs it). (Owner review 2, R6.) |
Publish the record first; change the index first | A crash never leaves a half-deleted sequence, nor half an entry that Restore or Empty could act on. |
| 2026-10-26 | A restore into an existing sequence writes restore.pending.json before its first move and checks cancellation only before that. Another writer settles it under the sequence's lease and the entry's (taken with TryAcquire, owner chronos@<machine>): before the sidecar was written the files go back into the entry, after it the record drops the photos the sidecar lists. While the entry is busy (being emptied or restored) the journal stays, another restore into that sequence and the sequence's deletion are refused (sequence_busy), and scans do not reconcile it. A restore into a new sequence stages each original in <entry>/.restoring/<path> (never .chronos/staging, which maintenance sweeps), puts it back on any failure, checks cancellation only between photos and rewrites the record after each photo it files; the next restore of the entry first puts back what a crash left staged. Restore and Empty share the entry's lease trash-<name>. (Owner review 2, R6.) |
One shared staging folder erased after the restore; no journal | Two restores of entries of one deleted sequence, maintenance and an emptying never touch each other's originals, and no step of a restore can lose one. |
| 2026-10-26 | A restore re-hashes every file against its record. A photo stays in the trash with its reason when a file no longer matches (mismatch), when its files could not move (not_moved), when an intact frame of the sequence holds its content (in_sequence; a twin that is missing or damaged does not count, and the photo comes back as its own frame with its id) or when its original was missing at deletion (no_file); when no file matches, nothing moves (TrashMismatchException, 422 trash_mismatch). The others go back with the same frame records, by capture time, a name taken since getting _2, _3… with its companion following, and their tombstones go. When the sequence is gone the photos go into a new sequence through the ingest with the session key trash:<sequence id>, so every entry of that sequence joins one; a companion that cannot follow becomes a record leftover, counted, erased by Empty, never restored. A sequence entry goes back as its folder is, without hashing. The desktop and the API say the reasons (keptReasons, one sentence each). (Owner review 2, R6.) |
Refuse when the sequence is gone; one sentence for every kept photo | Photos are never stranded, and the user learns why one stayed. |
| 2026-10-26 | Tombstones are the sidecar's removed list (left out when empty, kept by older builds), copied into frame_removals (migration 0008) at every index sync without the content a frame of the sidecar holds again, and gone with the sequence row. A deletion writes one only for a SHA-256 no photo that stays holds. They outlive emptying the trash; a deleted sequence's record keeps them for a restore whose folder lost its sidecar, and a sidecar rebuilt from the photos takes the index's back. Filing that content into the sequence again (an import, a restore, an explicit upload again) drops its tombstone. (Owner review 2, R6.) |
Tombstones in the index only, or in the trash records | A rebuild from the sidecars keeps them; a duplicate that stays was not removed; an emptied trash must not let sync bring the photo back. |
| 2026-10-26 | Photos never hashed are hashed as they go, for their tombstone. Frames that stay are looked at only when never hashed and of a deleted photo's size: a SHA-256 of their first and last 64 KiB is compared first, the whole file is read only when those match, and the full hash is kept in the sidecar and the index. A dry run blocks a never-hashed original that is on disk but cannot be read (409 photo_unreadable; it opens at most 256 of them, and the deletion's own hashing refuses one past those as folder_in_use, nothing moved). Known limitation: a never-hashed photo whose original is already missing is deleted without a file and without a tombstone (its record stays, a restore reports no_file, Empty erases it), so a copy elsewhere can come back; the edge prints are not stored, so N such originals of one size cost 128 KiB × N reads per deletion until a verify hashes them. (Owner review 2, R6.) |
Refuse to delete a photo without a hash; hash every frame that stays | A file that is gone has no content to name, and blocking it would make it undeletable; reading only likely twins keeps a deletion among raw files quick. |
| 2026-10-26 | When indexed frames vanish from a sidecar (a deletion here, or by another process sharing the archive), ProjectPositions translates the project's positions by photo: those on the photos that went wait as pending frames and come back with a restore, the others follow their photos, and the settings version stays; a hero frame id whose frame is gone is cleared. A deletion or restore clears light and deep analysis, thumbnails and proxies in the sidecar and the row and queues them again: light analysis always, deep analysis at background priority when the sequence had one, thumbnails and proxies always on the server and on the desktop when it had them. Proxies are renamed and thumbs.pack re-keyed (ThumbPackWriter.Rekey, skipped while a thumbnail pass holds the pack) to follow their frames, and the server's thumbnail locator checks the fingerprint of never-hashed frames too. (Owner review 2, R6.) |
Keep positions as they were (the earlier rule); rebuild every proxy and thumbnail | Exclusions, the hero and keyframes must not slide onto other photos; proxies and thumbnails are keyed by index, so moving them lets the passes reuse them and never shows a neighbour's thumbnail. |
| 2026-10-26 | (Partly superseded by the 2026-10-26 replaced entries emptying row: a replaced entry is weighed against the archive on disk, a conversion deleted since is said in the dry run and its fingerprint, and a kept entry is logged with why.) Emptying the trash is only an explicit job behind a dry run and a fingerprint. The dry run measures each entry on disk; the fingerprint is the SHA-256 of kind|name|files|bytes|deletedAt ticks per entry, in name order. The EmptyTrash job (stored as 18, user priority, normal level in the priority queue) keeps each entry's name and fingerprint: at its start any change of the plan erases nothing, a resumed job checks each remaining entry alone, and under its lease each entry is read and measured again and kept if it changed; an entry moves into trash/.erasing and is then deleted, leftovers going at the next emptying; a replaced entry goes only while its replacements still match their SHA-256 (re-hashed); a kept entry fails the job at the end. No schedule and no clean-up step empties the trash. The desktop asks for the number of entries to be typed, the panel for the word "empty" in its language. (Owner review 2, R6; BRIEF §0.2 rule 8.) |
Erase in the request; a scheduled or age-based emptying | The only erase of user files must be an explicit, confirmed, verified and resumable action that erases exactly what the user saw. |
| 2026-10-26 | Trash API under ManageArchive. Entry names are <id>[-<time>[-n]] (a sequence) or photos-<id>-<time>[-n], and the API takes only that shape, never a path. Offline, the listing and the emptying answer 503 archive_offline (the erase also when read-only). 422 trash_mismatch is for an entry none of whose files matches its record, or a sequence entry whose own sidecar no longer names it; 409 sidecar_mismatch for a damaged or foreign sidecar of the sequence the photos return to (also on frames/delete, and on sequence deletes that settle a journal first). The emptying request is audited trash_empty_requested (entries, bytes, names, the job); what was erased is in the job's log. (Owner review 2, R6.) |
Names with /; an empty listing when offline; audit trash_emptied at the request, or from the job |
A single URL segment rules out path traversal; an unreachable archive is not an empty trash; an audit entry must not claim an erase the job may still refuse, and the job has no hook into the server's audit. |
| 2026-10-26 | POST /sequences/{id}/frames/delete needs the Delete permission and the owner or an admin, like DELETE /sequences/{id}; each block has its code (frames_conflict, with the frames version now, only for changed frames; sequence_busy, would_empty, photo_unreadable, archive_offline), and it takes 1–100,000 ids under its own body limit (FrameDeleteBodyLimit, 100,000 × 48 + 4096 bytes, about 4.8 MB) set as routing metadata like the proxy route's: a third exception to the 2026-10-02 1 MiB rule, after chunks and proxies. (Owner review 2, R6.) |
Lower the id limit to about 20,000 | A sequence of 100,000 photos must be able to lose most of them in one request; the 1 MiB limit stopped at about 26,900 ids. |
| 2026-10-26 | Bulk routes take 1–1,000 distinct ids per request and answer each id in order, ok or skipped with the code and its sentence: delete moves each sequence whole as DELETE /sequences/{id} does (another user's is forbidden unless the caller is an admin), retag is the PATCH tag edit with up to 3 attempts on a conflict, and jobs queue one job at user priority. A verify of sequences targets their archive with the sequences in its parameters (ArchiveJobs.Verify), which also fixes POST /jobs with verify, whose job failed at once. The panel sends 1,000 ids a request (one job per 1,000 sequences, the toast counting them), lists every page of a filter for Select all, and refreshes every loaded row 1,000 a request. (Owner review 2, R6.) |
No limit; a server-side "all of the filter" selection | Bounded requests and answers; the same rules as the single-sequence endpoints. |
| 2026-10-26 | Uploads keep deleted photos out: a start whose SHA-256 the target sequence tombstoned answers alreadyExists without a frame id, unless a frame of the target still holds that content (a stale tombstone refuses no repair); the completion checks again after the upload stops receiving, and the ingest a third time under the sequence's lease, which a deletion takes (IngestRequest.RefuseRemoved), answering 409 photo_removed with the upload cancelled and its files deleted (ChronosClient returns null for it). Only an explicit user action brings such a photo back: StartUploadRequest.Restore and complete?restore=true (a query, so the uploads table needs no migration), sent by the panel's Upload again on a Deleted before row between runs, never by sync, the Uploader or a card import; with it no stand-in in another sequence counts, and filing the photo drops its tombstone, also after Empty. The desktop has no such path. (Owner review 2, R3, R6.) |
Check at start only; store the flag on the upload; only a restore from the trash brings a photo back | An old client syncing a copy, or a watch folder, must not undo a deletion, and no deletion may land between the last check and the commit; a user who uploads a photo again on purpose means it, also once the trash is emptied. |
| 2026-10-26 | (Partly superseded by the 2026-10-26 sync aliases row: replaced tombstones of both sides join encodings of one photo, compared as the smallest SHA-256 among them, with no step limit.) Sync tombstones: a deleted tombstone keeps the photo from being offered to the side that deleted it (no upload of what the server deleted, no download of what this PC deleted); a replaced one is an alias, followed up to 8 steps, compared, transferred and translated as the replacement. A tombstone leaves a photo out only while its side holds no matching photo (by hash, or by size and capture time while unhashed). An unhashed server frame is fetched, hashed and dropped when this PC deleted it; an unhashed local frame the server deleted is not sent, and the archive verify then runs so the next comparison leaves it out. Positions parked for a photo the other copy deleted stay pending; sync never deletes local files. Known limitation: until the server verifies such a frame, the row counts it as missing here and Download fetches and drops it each time (fixing it needs size and capture time in the tombstones). (Owner review 2, R6.) |
Drop parked positions; delete the local copy; tombstones by size and time now | A deletion on one side is not undone by the other, neither side loses a file, and a restore places the parked positions again. |
| 2026-10-26 | The server refuses frame uploads whose file name starts with . (400 invalid_file_name) from every client, and the panel's dialog counts such files as not photos. (Owner review 2, R3.) |
Leave them to each client | The archive scanner leaves hidden files out, so an upload must not file what an import of the same folder would not; the AppleDouble ._ files a Mac leaves on cards were filed through the server import before. |
| 2026-10-26 | The panel's Library is the second sidebar entry, with the Image icon (the Dashboard keeps the four tiles of the mockup). The trash is a view of the Library (#/library?view=trash, pages/library/trash.js) that Archive opens with a Trash button. The upload dialog is a module the Library and a sequence import on demand (import("../upload.js"), exporting openUpload({ api, sequence, onDone })); a test checks that nothing imports it statically and, lexing every admin module, that each top-level function that uses api takes it. (Owner review 2, R6, R3.) |
A Trash panel inside Archive; static imports | One route and module reachable from both places, beside the deletions that fill it; other pages never load the upload code; CI has no JavaScript engine, so a structural check catches an out-of-scope api like the one that broke every web upload during this phase. |
| 2026-10-26 | New GET /api/v1/sequences/facets (years newest first, camera models most used first with PathTemplate.CameraName as their label, tags by key with their first spelling, each with its count, from the server archive's rows) and rendered=true|false on GET /sequences. Covers come from GET /sequences/{id}/thumb (the hero's thumbnail, else the first frame's; private, max-age=3600, ETag) at ?v=<hero>-<framesVersion>. (Owner review 2, R6.) |
Menus built from the loaded page; no cover endpoint | The menus must offer exactly the values the filters take without reading every sequence; a new cover or other photos change the address, while edits of title, tags or rating keep the cached image. |
| 2026-10-26 | Panel confirmations: deleting photos asks for their number to be typed when more than 20 go; emptying the trash asks for the localised word "empty" (any case); moving sequences to the trash asks for nothing typed, its dialog listing at most 500 names, the blocked first with why. CSV export is built in the browser from the sequences the page knows (the selection, or all of the filter after Select all): ISO dates as recorded, bytes, localised headers, and a cell starting with =, +, -, @, tab or CR prefixed with an apostrophe. Selectable grids (cards, list rows, photos) are listboxes with one tab stop; the photo grid stays left to right in right-to-left languages. (Owner review 2, R6.) |
A typed confirmation everywhere; a server CSV endpoint | Moving to the trash is undone by Restore, erasing is not; typing a count makes a large deletion's size read; a word is checked the same way in every language; a CSV must be safe to open in a spreadsheet; hundreds of tab stops would make the keyboard useless. |
| 2026-10-26 | The panel's pages follow sequenceChanged and jobState. jobState carries no job kind or target, so a sequence page reads itself and its renders after any job ends (at most every 1.5 s) and redraws only what changed, keeping the focus; thumbnails not built yet are asked again from 2 s up to 60 s apart, 8 times at most. After the WebSocket reconnects, api.events gives the page a client-only { type: "reconnected" }, on which the trash reads the emptying it follows again (GET /jobs/{id}; a job no longer listed is dropped). (Owner review 2, R6.) |
Add kind and targets to jobState now; refresh on every event |
No protocol change in this phase, and archive-wide jobs change every sequence anyway; events lost during a reconnect must not leave Empty disabled. |
| 2026-10-26 | The admin panel's files are served with Cache-Control: no-cache and their content ETag; If-None-Match honours lists, weak W/ tags and *, and an unchanged file answers 304. (Owner review 2, R6.) |
public, max-age=3600 (before); versioned module addresses |
With an hour of cache, a browser that loaded the panel before an upgrade could run new modules next to old ones; revalidation sends again only what the upgrade changed, with no build step. |
| 2026-10-26 | The web upload hashes with an in-house incremental SHA-256 (sha256.js, FIPS 180-4, Int32Array, update/digest) in a same-origin module worker (hash-worker.js) that reads file.slice() in 8 MiB blocks and reports progress. The CSP is unchanged: the panel's policy has no worker-src or child-src, so the worker falls under script-src 'self', which a test pins. About 120 MB/s under V8 (node 24). (Owner review 2, R3.) |
crypto.subtle.digest; a JavaScript library |
crypto.subtle digests one whole buffer, so a large RAW would sit in memory, and the rules allow no third-party code; hashing off the page's thread keeps the dialog responsive. |
| 2026-10-26 | The browser's SHA-256 self-tests and fails closed: before its first hash each worker runs the FIPS 180-4 known answers (the empty message, "abc", the 448- and 896-bit messages, one million "a"), whole and fed in uneven pieces, and where crypto.subtle exists compares a 1 MiB random buffer with it; on any mismatch every hash is refused and the dialog says so and uploads nothing. The server still verifies every upload. CI has no JavaScript engine, so the vectors, 300 random lengths against node:crypto and deliberately broken copies were run once with node 24. (Owner review 2, R3.) |
Trust the implementation; let the server's 422 catch a wrong hash | A wrong hash would be refused only after the whole file was sent, and a browser engine fault would fail every upload one by one. |
| 2026-10-26 | No folder upload on the web panel: the dialog has no webkitdirectory or directory picker (a test checks), and folders dropped on it are detected with webkitGetAsEntry, counted as Folders skipped and left out. Only files whose extension server/info lists (the new optional extensions, from ImageFormatInfo.Known, the scanner's list), not empty and within limits.maxUploadBytes, are taken. (Owner review 2, R3, R9.) |
Upload folders; a list of extensions in JavaScript | The owner's request: importing a whole folder stays on the desktop. A copy of the list would drift, and the archive would ignore files that are not photos. |
| 2026-10-26 | Web upload pacing: two photos and two chunks per photo at once (four of the server's eight chunks per account); a call with no answer, 429 or 503 retried after 1, 2 and 4 s; 401, 403, 507, an unknown target (404 sequence) and a failed self-test stop the remaining photos (Not sent) with the server's message; a completion refused with 409 upload_state is read again after 1, 2, 4 and then every 8 s, about a minute; two copies of one photo in a run go one after the other. A new target is created by one POST /sequences, never retried, and stays the dialog's target. Each start carries the capture time: the Exif DateTimeOriginal of a JPEG or TIFF-based file (from its first 256 KiB, every offset checked), else the file's modification time as local wall time, which the ingest uses only for a photo with no time of its own. (Owner review 2, R3.) |
Send everything at once; capturedAt null |
Room for the user's other clients; a refusal that would refuse every photo stops at once; a lost answer must not create two sequences; photos without Exif keep their order instead of taking their arrival time. |
| 2026-10-26 | Cancel deletes, Close keeps: Cancel aborts the requests, stops the worker and deletes the uploads the run started and did not complete; an upload that failed otherwise (507 at completion, say) stays receiving and the next run resumes it (same user, hash, size and sequence), abandoned ones expiring after the upload retention. During a run Esc is held by a capture-phase listener on the document and leaving the page asks first, so only Cancel stops it. (Owner review 2, R3.) | Delete every unfinished upload on Close; let Esc close the dialog | Cancel frees the space at once; a failure the user can fix is resumed without sending the photo again; a stray Esc must not discard uploads. |
| 2026-10-26 | Import, upload and Reorganize name photos through one rule, FrameNaming: a frame in its sequence, {n} = index + 1, the sequence as one session from its first frame, the sequence's camera and lens (its first photo's, or its creator's camera hint) for every photo, {name} the name on the card, {ext} the file's extension (the card name's when the file lost a photo extension), a frame without a capture time at the sequence's start (its first frame's time, else when it was made; never DateTime.Now or today). Uploads, card and folder imports (each session with its first photo's camera and lens) and the folder of a new sequence (from its first frame) use it, so a whole-folder import of two bodies, or a lens changed during a session, no longer shows in the names. Where filing could not know the sequence as it is now ({session} of a card's second session on, {n} after duplicates skipped mid-session or photos filed out of capture order, a first photo that changed), Reorganize gives other names, which its dry run lists. (Owner review 2, R7.) |
Each photo's own Make, Model and LensModel; a naming of Reorganize's own | A Reorganize with the archive's own templates must plan nothing for what filing named; the sidecar keeps no camera or lens per frame; a dry run and its apply must agree on frames without a time. |
| 2026-10-26 | Reorganize renames only photos under originals/ whose SHA-256 is known and whose file is there, each within its own folder; photos adopted in place (outside originals/), never hashed or missing keep their names and are listed with the reason (in_place, unhashed, missing). A sequence whose sidecar cannot be read, is another sequence's or is of a newer format stays whole (unreadable, 0 photos), and so does every folder around it, which then claims no new folder. The folder and title templates see the sidecar's first frame, the index row only without a sidecar, and a sequence with no time known keeps its folder and title. Sequences created without photos (no folder yet) are left out of rename plans. (Owner review 2, R7.) |
Rename adopted trees too; hash the photos first; move a folder without the sequence inside it | An adopted tree belongs to a layout someone else keeps; an unhashed photo can be neither checked against the plan nor followed by sync and the trash; a folder that cannot take a sequence along would leave its index row behind; today's date would move the folder again another day, and a title rename of an empty sequence failed at apply. |
| 2026-10-26 | New file names are given in index order; a name already given, or held by a file that stays (a frame left alone, a file no frame lists, a companion that stays), gets _2, _3… before the extension, as filing does, so the same frames, template and folder always give the same names and a second Reorganize renames nothing. XMP companions (stem.xmp, name.xmp, any case) follow their photo with the same tail, a stem two frames share going with the first; FrameCompanions serves the trash and Reorganize alike. UniqueNames remembers, per name, the first number not yet taken, giving the same names in linear time (a {title} plan over 20,000 photos in well under a second, about 28 s before); import, ingest and Reorganize use it. (Owner review 2, R7.) |
Refuse a plan with colliding names; search from _2 for every photo |
Deterministic and idempotent; companions keep describing their photo; a quadratic search made a large dry run outlast an HTTP timeout. |
| 2026-10-26 | A step's file renames run under .chronos/rename-files.json (the frames version, the phase, every file's old, temporary and new name): every file first to a hidden temporary name beside it (.chronos-rename-<token>-<n>.tmp), the journal then at phase 2, then every file to its new name, never with overwrite; then the sidecar (frames version + 1, frame order and ids unchanged, so an editor holding the old version reloads once), the index (FrameRepository.RenameFilesAsync, only from the version the renames started at), and the journal goes. A failure while files move puts every file back; when one cannot go back, the journal completes the renames at once. After a crash the next writer of the sequence (SequenceWriter.ReadLocked; the plan's resume; an archive open for a held plan's unfinished steps) rolls forward, safe to run again from any point: phase 1 becomes phase 2 once every file is at its temporary name, a new name taken meanwhile sends the photo and its companions together back to their old names or the first free _n (journaled before they move), and the journal stays while a temporary file is left; the index follows at the plan's resume or the next scan. (Owner review 2, R7.) |
Rename one file at a time in place; roll a crash back | Chains (A→B, B→C) and swaps never meet a name another file holds and nothing is ever written over; once files reached their new names, rolling forward is the shorter way to a sidecar that matches the disk. |
| 2026-10-26 | Each step (a sequence and those nested in a folder that moves with it) takes the sequence leases, then the thumbnail leases, by id, and checks under them, before anything of it moves: the sequences where the plan has them, no sequence indexed since inside a folder that moves, nothing at its new folder (TargetTaken: a folder on disk, or an index row there, around or inside it), no sidecar of a newer format to rewrite, the title it was planned from where it changes the title or names the folder or files after it (NamedByTitle), the folder and title the templates give from the settled sidecar, and the file renames planned again (by digest). Those that refuse (all but the names and the file renames) also run up front, without the leases, before a fresh or a held plan starts. Then the folder moves, every index row of the step follows (folder and title, frame paths, export paths, one transaction), and only then are files renamed; once its folder moved, a step goes to its end whatever is cancelled. A sidecar that cannot be read or written after the move still has its row follow (title kept, no scan stamps), every sequence of the step is told, and the step fails so the job holds the plan. (Owner review 2, R7.) |
Rename the files first; check only when the plan starts | Nothing of a step is half-applied when the plan no longer fits, the index never names a folder the sequence left, and no writer works in a folder while it moves or its files are renamed. |
| 2026-10-26 | A Reorganize is confirmed by its plan's fingerprint: the SHA-256 of the file template and of the steps as the dry run shows them (ids, folders, titles, carried, file count, samples, what stays and why) with each step's file renames as one digest (RenameStep.FileDigest), not the frames version. The move job's parameters (MoveJobParameters) carry the templates, the sequences that have a step in the order the plan was made for (which decides the folder that gets " (2)") and the fingerprint, no file list; the job plans again and applies only a plan of the same fingerprint, else fails with "The archive changed after this plan was made" and nothing changes, naming in its log a sequence deleted since. The server answers a confirmation whose plan differs 409 plan_changed with the fingerprint now. (Owner review 2, R7.) |
Store the plan or its file list in the job; include the frames version | The change made is exactly the one shown (destructive operations rule); the parameters stay small for 100,000 photos; photos uploaded under the names the plan leaves them (the archive's file template is the Reorganize's, the usual case after saving templates) must not refuse it. |
| 2026-10-26 | Photos changed after the plan (received, removed, hashed or copied in, so that the renames planned again differ) refuse nothing: under its leases that sequence keeps its file names (FilesKept), and its folder and title change as planned while the templates still give them from its first photo as it is now (the plan journals its folder and title templates; RenamePlanner.Names, Gives: the expansion or its " (n)"); otherwise its title and file names stay, and its folder too (Dropped; TitlesKept when an interrupted run moved its folder already), and so do the sequences its folder was to carry (CarriedKept). A sequence so left inside the folder of a later step that moves goes with that folder (next row); the folder around it is never kept in place for it. The other steps go on, and the job fails at the end saying how many sequences were not reorganized as planned. A title edited since, a folder taken, a sequence moved or indexed inside a moving folder, or a sidecar of a newer format refuse the rest of the plan instead (a plan an interruption left drops that step, or keeps what no longer fits). A plan journaled before its templates were kept is applied as planned. (Owner review 2, R7.) |
Refuse the step, or the whole plan, as soon as a photo arrives | A time-lapse camera uploading every few seconds would make a file Reorganize impossible; a folder or title must never be named after a photo that is no longer first; a user's title edit is never written over. |
| 2026-10-26 | A sequence of the plan that an earlier step left as it was (it changed after the plan, such as photos that make the templates name it otherwise now, or, when a plan resumes, whatever drops a step), or that stayed with a folder that was to carry it, is taken along by a later step whose folder moves while the index still has it inside that folder (at its own folder, or where an interrupted run's move took it): MassRenamer.LeftInsideAsync adds it to that step as a carried sequence with its title and file names as they are, locked, leased, moved and recorded with the folder. The tally counts it as titles kept (TitlesKept, logged "Title and file names kept, changed after the plan") instead of dropped; one whose carrier stayed is no longer kept when it was only to move, and is titles kept when it was to be retitled or renamed too; one a newer Chronos wrote stays counted as newer. Before a held plan resumes, the check without the leases (RefuseStaleAsync) accepts inside each moving folder only the sequences of the remaining steps and the completed ones so left there; any other refuses the plan, which is given up. (Owner review 2, R7.) |
Refuse the outer step, which failed the plan at every retry; keep the outer folder in place with all it holds | Nested sequences move out first, so one that stayed was found inside the outer folder as a stranger and the plan stayed held for ever; the outer folder's change does not depend on the nested one's, and moving the nested sequence with its index row leaves no row behind. |
| 2026-10-26 | Reorganize is a job on both hosts: JobKind.Move (stored 14, wire move, now labelled Reorganize), user priority, target the archive, handled by MoveJobHandler through ArchiveService.CreateJobHandlers; the desktop dialog keeps its dry run in-window and Apply queues the job. Progress counts the steps that change; the checkpoint is plan:<id> once the plan's journal exists. Paused or cancelled by the user, or failed, the job stops between two steps and holds the plan (RenameJournal.Held): an archive open leaves it to the job (completing only file renames a step left half-way), and the job's resume or retry completes it while it still fits, else gives it up (journal deleted). A yield to another job or a host that stops leaves it unheld, completed at the next open. A failed job whose plan is over (completed with sequences kept, or given up) checkpoints applied, so its retry plans again; one that failed because the archive's volume went away keeps its plan, and its retry completes it once the volume is back. A plan journal not found on an archive that cannot be reached (ArchiveVolume.Probe offline) tells nothing: a failed job then keeps its plan:<id> checkpoint instead of applied, and a retry while the archive is offline fails as offline ("The archive … is offline") instead of logging that the plan was completed at an archive open and ending done. Deleting sequences of the archive is refused while the job runs or is paused. (Owner review 2, R7.) |
Apply inside the dialog, as the 2026-10-03 and 2026-10-06 rename dialog did; complete held plans at the next open | A Reorganize can rename every photo of an archive: as a job it is paused, resumed after a restart, followed and retried in Jobs, on the same path as the panel; an archive open must not finish behind the user's back what they paused; an unplugged drive must not make a held plan look completed. |
| 2026-10-26 | The plan's journal keeps a tally of the whole plan (RenameJournal.Done: changed, files, dropped, files kept, titles kept, files busy, newer, carried kept), so the job log covers every run: "Sequences changed: N, files renamed: M", then one line per sequence not changed as planned, with why. The job then fails with one error: kept first ("changed after the plan"), then newer (a sequence file from a newer Chronos, met only when resuming), then busy (a photo in use or its new name taken); sequences kept because the folder around them stayed follow their carrier's reason. (Owner review 2, R7.) |
Report only the last run; one generic error | A plan applied over several runs reports what it did as a whole, and each sentence must be true. |
| 2026-10-26 | Each sequence a Reorganize changed is told through ArchiveServiceOptions.SequenceChanged (change reorganized) once its step is journaled, by its job or by an archive open that completed an interrupted plan, and at once for a step that failed after its folder moved; a failure to tell is logged, never passed on. The server publishes sequenceChanged reorganized with the row's versions (its open at start has no hook: no client is connected yet); the desktop raises AppServices.SequenceReorganized, and an editor open on that local sequence reloads where it is now while the job goes on (LocalSequenceSource reads the frames again when the folder changed while it listed them). (Owner review 2, R7.) |
One event when the job ends | Steps done before a pause or a failure are told; an open editor would otherwise decode from paths that moved. |
| 2026-10-26 | A folder move rebases the archive-relative paths of the exports inside it in the same transaction as the sequence row and its frames (RenderRepository.RebaseFolderAsync, ArchiveIndexer.RebaseRendersAsync). An export is a file, or a folder for an image sequence. The sequence's own exports follow unless one was written at the old place after the move (there and not at the new place, the old folder not another sequence's now), and so does one whose old path another sequence's export now names; another sequence's export saved inside (the Export folder picker) follows only when it moved with the folder, and never one of the sequence that holds the old folder now (next row); absolute paths and other folders stay. A scan that finds a sequence in another folder (another index's Reorganize, a folder moved by hand) applies the same rule. (Owner review 2, R7.) |
Leave render rows to be recorded again; rebase by sequence only | Exports must stay downloadable and syncable on every host after a move, and a row must keep naming where its file is. |
| 2026-10-26 | When another index moved a sequence out of its folder and another sequence into that folder, this index's rebase of the first one reads once which other sequence the old folder holds now (SequenceFolders.OtherSequence, the id its sidecar names): the first sequence's own exports follow to its new folder even when an export of that name is at the old path (it is the other sequence's), a render row of the sequence that holds the old folder never follows, whatever the scan order, and no other row counts as left behind at the old path while that folder holds another sequence (a third sequence's export saved there through the picker follows when its file moved with the folder) (RenderRepository.RebaseFolderAsync gives the rule each row's owner). Known limitation: an export that sequence had saved through the Export folder picker into the first one's folder, before it took that folder, keeps naming the old path; the file is intact in the first sequence's new folder, and no scan repairs the row. (Owner review 2, R7.) |
Let every row under a taken old folder follow; keep any row whose path still holds a file | When the scan rebased the holder first, its row then followed the other sequence and named that sequence's file, its own export left without a row for good; a row must never name another sequence's file, and the case left out needs an export saved into another sequence's folder before two moves by another program. |
| 2026-10-26 | A render job's checkpoint records the sequence's archive-relative folder with the output it chose (RenderCheckpoint.Folder; older checkpoints read it as null). On resume, a crash's leftovers are rebased by a folder move and removed only inside the sequence's current exports or outside the archive (an export folder chosen on a client); anywhere else in the archive they are left alone and the render takes the next free name. (Owner review 2, R7.) |
Delete the pending output at the path the checkpoint recorded | After another program moved the sequence and another sequence into its folder, that path was the other sequence's export, deleted on resume; leftovers of a crash into an export folder chosen inside the archive are no longer cleaned up, the price of never deleting where the sequence is not. |
| 2026-10-26 | Download originals restores the originals flagged missing after its transfers, under the sequence's lease, at each frame's path in the folder the index has then, and only when that folder holds the sequence (SequenceFolders.Holds); otherwise it restores nothing, keeps the staged copies for the retry and fails with Errors.Archive.FolderMoved after its other work. (Owner review 2, R7.) |
Restore at the path read when the job started, without the lease | A folder moved by another program sent the photo into the sequence that took the folder (adopted there at its next scan) or recreated the moved-away folder; after this PC's next scan the retry restores into the new folder. |
| 2026-10-26 | A writer takes a sequence's folder from the index row read under the sequence's lease (SequenceWriter.FolderAsync; renders a client or a node sends through ArchiveService.UnderLeaseAsync), so it writes where a Reorganize put the sequence and never creates the folder it left. A folder another index moved is not where this index has it until its next scan, and neither is one that holds another sequence now (next row): Take server and Save both, exports fetched by sync, proxies made and a render job as it starts refuse it with "The folder of this sequence is not where the index has it; try again after the next scan" (Errors.Archive.FolderMoved), proxies received with 404 frame, the server's render filing with 503 folder_moved (FolderMovedException) and the editor's save with "This sequence is no longer in the archive"; a deep analysis records nothing. Render filing that meets a sequence held past the lease wait, an offline archive or such a folder answers 503 (sequence_busy, archive_offline, folder_moved) and puts the upload back to receiving, the node keeping its job while its client retries (about 30 s; a node then reports the job failed, and its retry renders again); a proxy upload answers 503 sequence_busy, or 404 frame once its sequence or folder is gone. (Owner review 2, R7.) |
Let writers create the old folder again; answer 409, or 500 as before | A folder created again holds files no index row names; ChronosClient retries only 503s and a render node fails its job on any other error, which would discard a finished render (a 500 left the upload stuck in Committing until a restart). |
| 2026-10-26 | A sequence is in the folder the index has for it only while that folder exists and its sidecar, when it has one, names no other sequence (SequenceFolders.Holds; a sidecar that cannot be read does not count as another's). Every writer that files into a sequence's folder asks it, so a folder another index moved the sequence out of, and another sequence into, is refused exactly like a missing folder until this index's next scan: settings sync and Take server (nothing written), Save both's copy and its clean-up (which deletes nothing in such a folder), exports fetched by sync (the download stays staged), the server's render filing, a render job as it starts, proxies received, proxy passes, the deep analysis's checkpoint and the editor's save; a thumbnail pass refuses a sidecar of another sequence before it opens the pack. (Owner review 2, R7.) |
Check only that the folder exists; check the sidecar's id in some writers | With only the folder checked, Take server wrote the server's settings into the other sequence's project.json, Save both wrote this PC's copy into its .chronos and a render sent for the sequence was filed among its exports; one check shared by every writer leaves none out. |
| 2026-10-26 | The proxy pass holds the thumbnail lease one batch at a time: a quarter of the lease wait (30 s by default), at least one photo, then lets it go for 750 ms (1.5 × LeaseFile.LongestPoll, 500 ms) and reads the folder, sidecar and companions again; a folder gone, or holding another sequence now, stops the job with the folder-moved error (resumed from its checkpoint after the scan), and photos changed between batches leave ProxiesBuilt unset. File renames take the thumbnail leases too; the thumbnail pass still holds its lease for its whole run. Cost: up to about 2.5 % on long passes. Another process's thumbnail pass may take the lease in a gap, and one longer than the lease wait then fails the running proxy pass, which resumes from its checkpoint. (Owner review 2, R7.) |
Hold the lease for the whole pass; no lease | Another program's Reorganize, sequence deletion or pack compaction waits for one batch instead of failing after two minutes behind an hours-long pass, and no pass writes proxies into a folder that moved. |
| 2026-10-26 | A sequence keeps its folder when it already is what the template gives, or that name with the " (n)" filing or an earlier Reorganize gave it, in the template's case; a change of case only is planned while no other folder holds that exact name (another sequence's, or on a case-sensitive file system a folder on disk beside the sequence's own: RenamePlanner.ExistsExactly compares every level exactly) and moves through a temporary name. No two sequences of a plan get folders that differ only in case. Under the step's leases a case-only target that now exists beside the sequence's own folder refuses the step (dropped when resuming), as MoveFolder would; a change of case in an outer level moves on every file system. (Owner review 2, R7.) |
Compare folder names without case; make every target unique again | A second Reorganize must plan nothing (a folder flipped between " (2)" and " (3)" before); NTFS ignores case and Linux does not; a plan that fails at every archive open must never be journaled. |
| 2026-10-26 | Template rules (TemplateRules, checked on three sample photos two seconds apart): a folder template may not write a level scans never enter (ReservedFolder: starting with ., or originals, proxies, exports, .chronos); a file template may hold no slash (FileSeparator), must keep the photo's extension (Extension: PathTemplate.KeepsExtension, the extension appended or after .{ext}) and must give a session's photos different names (NotUnique). What a template does not write itself is made safe instead: a folder level a title gives that scans skip gets a leading _ (ExpandFolder, for import, upload and Reorganize alike), a file name over 200 characters is shortened before its .{ext} without splitting a surrogate pair, and a title template expands as text (ExpandText: control characters as spaces, at most 200 characters, no file-name sanitizing). Each rule has its sentence (Errors.Template.<Rule>). (Owner review 2, R7.) |
Check only that a template parses | {n}{ext} drops the dot, and with it the extension every decoder goes by; a folder scans skip vanishes from a rebuilt index; repeating names fill a session with _2, _3; titles became Paris_ night. |
| 2026-10-26 | The rules hold wherever a template is typed or sent: the desktop's Settings › Archive, Import and Reorganize fields (NamingPreview), the server's Reorganize and PUT /archive/settings, and the archive engine (ArchiveSettings.Problem, CheckTemplates). A template archive.json already holds (saved by 0.1.0-rc.5 or earlier) is held to them only when an edit changes it: the engine's UpdateSettingsAsync and the server's PUT check the rules only for templates that differ from the stored ones, every template still having to be non-blank, valid and expandable (the PUT compares with the archive as the server last read archive.json; when that file changed since, a desktop's edit say, and the engine refuses a template the form still sends, the answer is still invalid_template with the rule, never 409 archive_policy); CreateAsync, and so adopting a new folder, holds both to every rule (this PC's templates saved by an older version then refuse Welcome › Create, the toast naming the rule, fixed in Settings › Archive). A broken rule is a TemplateRuleException (an ArgumentException naming the field, with the rule), whose sentence the desktop's toasts show; the API's invalid_template details are <field>:<rule> (fileTemplate:extension) with that sentence in the request's language, a blank or invalid template keeping the bare field and the generic message. (Owner review 2, R7.) |
Refuse every save while a stored template breaks a rule; check the rules in the user interfaces only | A pre-rules template must not block an edit of the name, the proxy size or the other template, on the desktop or the panel; neither the engine nor the server accepts from another client what the fields refuse. |
| 2026-10-26 | (Partly superseded by the 2026-10-26 conversion plan cache row: ReorganizePlanCache is PlanCache, shared with Convert, its 2 at once and 8 kept counting both kinds.) The server keeps Reorganize dry runs (ReorganizePlanCache), keyed by the archive, the selection (all, or the ids in their order), the templates and SequenceRepository.GetStampAsync: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (nested_target, not_found), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (Concurrency) and 8 kept or being made (Capacity: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (PlanTimeout, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 plan_dropped. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) |
Plan again at every request; plan in a background job with progress | An all dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). |
| 2026-10-26 | POST /api/v1/archive/reorganize (ManageArchive): exactly one of sequenceIds (1–1,000) and all, a null template kept, at least one given; a dry run answers the plan (ReorganizePlanDto: steps with folders, titles, carried, frames version, file count, up to 3 samples and what stays, its reason in snake case with a sentence in the request's language; totals; fingerprint); the change answers 202 with the move job. 400 bad_request (sequenceIds, templates, fingerprint), invalid_template; 404 not_found (sequence); 409 nested_target (details: the folder), plan_changed (details: the fingerprint now), job_unavailable; 503 archive_offline, plan_dropped. Audited archive_reorganized ("sequences · files · folder, file and title templates"), which the panel's audit log and Dashboard show as a sentence. (Owner review 2, R7.) |
Separate rename and move endpoints; every planned name in the answer | One request carries the three templates as both programs do; a dry run of 100,000 photos answers counts and samples, not every name. |
| 2026-10-26 | Panel: the Library's Reorganize… sends the selected ids, up to 1,000, and all: true only above that while the selection is exactly Select all without a filter and the total has not changed; any other larger selection is refused with a toast, never split into several plans or jobs. The dialog's switches start on for the parts with a template (Titles off and empty, the archive having no title template; from the Archive page's toast only the changed parts), templates are sent trimmed, a dry run runs 400 ms after typing (Enter at once) with one request in flight and a change meanwhile planned right after, an older request's refusal is not shown, and Apply runs only while the shown plan is the fields' and changes a sequence. The confirmation has two buttons and asks for nothing typed (nothing is deleted); a different plan answered during it is shown, not applied. toast(message, isError, action) takes an optional link or button; such toasts stay 15 s and pause under the pointer or the keyboard focus. (Owner review 2, R7.) |
Split a large selection into several jobs; a typed confirmation | One dialog is one plan and one job, and separate plans could give two sequences one destination; a typed word is for what cannot be undone. |
| 2026-10-26 | Desktop: one Reorganize… dialog replaces Rename… and Move… of the Archive manager and Move… of the Library, for the sequences of one archive as Move was: Folders and File names on with the archive's templates (read again from the index when it opens), Titles off with {title}; the dry run follows the typing (400 ms; Enter or leaving a field plans at once unless that dry run is on screen or under way, so a click on Apply is never turned off under it), and only the latest dry run publishes its result. After Settings › Archive saves a new folder or file template into an archive with sequences, a toast offers Reorganize… for every sequence with the changed parts on, one offer per archive, a change made while its toast is up (8 s) joining it (ReorganizeOffer, Toast.Closed); on the Archive screen an open dialog is never replaced: Reorganize waits, says so, and opens when it closes. The old Rename and Move keys were pruned from every language (i18n prune); the capture scene is archive-reorganize-*. (Owner review 2, R7.) |
Keep Rename (titles) beside Reorganize; a modal question or an automatic Reorganize after a template change | One concept and one button for how filed sequences are named, with the same three templates as the panel; templates only name what is filed next, so a toast offers without interrupting and nothing moves without the dry run; a new key shows as untranslated instead of 36 languages keeping "Move". |
| 2026-10-26 | Conversion after import: import still copies every photo byte for byte and has no Convert row (the 2026-10-03 row stands for import). Converting is Convert…, an explicit step after import, on the desktop (the Archive manager's set, the Library's selection of one archive) and the admin panel (the Library's selection: up to 1,000 sequences, or every sequence after Select all without a filter), through one engine (MassConverter) and one job, behind a dry run. Replace only moves originals into the archive's trash and New sequence leaves them where they are: nothing rewrites an original. The card erase gate still re-hashes the card file and the archived copy against the import hash, so a converted photo keeps its card copy (CopyMismatch) and a format is refused while it is on the card. (Owner review 2, R7.) |
Convert at import (the sketch's row); convert originals in place | The owner asked for conversion after import as well; the hash-verified erase and format gate and immutable originals hold because no original is rewritten and a card is never erased against a converted file. |
| 2026-10-26 | Replace or New sequence is chosen at every run and never remembered: both dialogs open with no mode and Apply waits for one, asked last, after what converts and the space; Format starts on Linear DNG (ConvertOptions.ArchivalTarget) and Quality on 95, nothing kept in settings. What converts does not depend on the mode, so the desktop plans once per format and quality and sets the mode on that plan, and the panel asks its preview in Replace's words (mode: replace) and asks again for New sequence, answered from the plan the server keeps; the fingerprint names the mode. A Replace is typed: the desktop asks for the number of photos it replaces (as Delete and Empty ask for a count), the panel for the localised word "replace" (as Empty asks for "empty"); New sequence asks a plain confirmation that says how many photos the new sequences lack. (Owner review 2, R7.) |
Remember the last format and mode; default to Replace; a typed confirmation for both modes | The owner's answer: a choice at every run; a remembered Replace would be one Enter away; each program keeps its own typed confirmation for what moves originals into the trash, and New sequence changes no original. |
| 2026-10-26 | Targets: JPEG baseline 4:4:4 with optimised Huffman tables, 8-bit, quality 1–100 (default 95); TIFF 16-bit RGB with Deflate and the horizontal predictor; linear DNG (16-bit LinearRaw, lossless JPEG tiles, UniqueCameraModel "Chronos"), the archival default. A conversion's DNG is scene-referred (LinearDngOptions.SceneReferred): the pixels are stored in linear ProPhoto (ROMM) primaries, divided by the smallest power of two that brings their peak under 0.998 of white, at most 2^4 (LinearDngWriter.MaxHeadroomStops), BaselineExposure giving those stops back; ColorMatrix1 and ForwardMatrix1 describe ProPhoto with illuminant D65 and AsShotNeutral 1/1/1, and the encode matrix is the inverse of the in-house reader's solve of the rationals written, so a file reads back as written to the 16-bit step. The as-shot white balance is baked in and values below 0 are clipped. Exports keep the clipped linear-sRGB DNG. (Owner review 2, R7.) |
A float DNG; a fixed 4× headroom; the export's clipped linear sRGB for conversions too | Once the trash is emptied a Replace's file is the photo: the highlights a RAW develops above white (about a stop on a partly clipped sky) and its colours outside sRGB (negative in sRGB primaries) must survive; 16-bit integers are what every raw editor reads, and a power of two keeps the steps exact; an export is a rendered picture whose highlights the render decided, and its files stay as earlier builds made them. |
| 2026-10-26 | A conversion decodes at full resolution only (AllowPreview: false, upright) through its own chain (FrameConverter.Decoders): the managed provider first, so every format it reads natively is developed in-house at float precision, as on the server, and the host's others (WIC) after it for what it cannot read (a CR3, a HEIC, a CMYK TIFF). For TIFF-16 and linear DNG a RAW never goes through a provider that develops at 8 bits (IImageDecoderProvider.DevelopsRawAt8Bits, true for WIC's Raw Image Extension): such a RAW is planned out as eight_bit, refused at conversion (ConversionFailure.EightBit) and converts to JPEG only. The conversion's managed provider reads JPEG, PNG and TIFF headers when it probes (ManagedDecoderProvider.ReadsHeaders): what its decoders refuse there (a compression, sample format or photometric they lack, more than MaxSamples or MaxPixels, arithmetic coding, a JPEG or PNG larger than one array) is asked of WIC on a PC and is convert_on_pc on the server. The archive engine's other decodes keep WIC first on the desktop. (Owner review 2, R7.) |
The archive engine's order (WIC first); develop RAWs at 8 bits for every target | The Raw Image Extension gives 24bppRGB, too few bits for a 16-bit archival file, and the in-house developer gives the same pixels on every host; the dry run must promise only what the decoders it uses take. |
| 2026-10-26 | The managed TIFF reader refuses, before reading pixels, samples it does not render (TiffImageReader.Renders): CMYK (5), CIELab (8), palette (3), LogL/LogLuv, RGB of fewer than three samples and float min-is-white, for every managed decode; strip and tile counts are counted in 64 bits and impossible ones refused as data (InvalidDataException), and ReadInfo refuses what a decode would. On the server such a frame is unavailable instead of the gray of its first plane; a conversion on a PC reads it through WIC. (Owner review 2, R7.) |
Decode them as gray, as before | With the managed decoders first, a Replace would have put a gray or black picture in the archive and the original into the trash; an OverflowException escaped the decoder chain, which then never asked WIC. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 conversion colour and sRGB by name rows: float values are written as sRGB codes with a profile made for them, a linear DNG takes only values that are sRGB's as read and refuses other profiles, a gray profile's codes are kept with its curve as an RGB profile, and a name decides sRGB only for a profile without colorant tags.) Colour profiles: SourceColor reads what a photo's headers record (JPEG APP2 chunks, PNG iCCP or sRGB, TIFF tag 34675 from the image the decoders read, then IFD0, then Exif, HEIF/AVIF colr prof, rICC or nclx, WebP ICCP, Exif ColorSpace with Interop) and whether its samples are linear (a float or LinearRaw TIFF), and FrameConverter.Treatment keeps that space. JPEG and TIFF-16 carry the ICC profile (APP2 chunks, tag 34675) with code values unchanged, linear values coded with the profile's own curves; linear DNG takes the values converted to linear Rec.709 through a matrix/TRC profile (linear values through the matrix alone, unclipped); an sRGB profile, told by its numbers for matrix/TRC (matrix within 2e-3 of identity, curves within 2e-3 of the sRGB curve) and by its name only for a lookup-table profile, needs nothing in a DNG; a gray profile converts to sRGB. Exif uncalibrated with Interop R03 (or ColorSpace 2) gets an in-house v2.1 "Compatible with Adobe RGB (1998)" profile, a HEIF nclx box with P3 primaries "Display P3". Refused as color_profile: CMYK, Lab and other non-RGB profiles, a lookup-table profile into a DNG or holding linear values, curves that cannot be inverted, uncalibrated without R03, other nclx primaries or an HDR transfer, a profile that does not parse; colorants that convert nothing (no positive Bradford cone response, a non-finite or singular matrix) are dropped when parsed, so such a profile is carried into JPEG or TIFF and refused for DNG. PNG gAMA/cHRM without iCCP, JPEG XL, JPEG XR, BMP, GIF and other Exif ColorSpace values are read as sRGB. (Owner review 2, R7.) |
Drop profiles and write the values as sRGB (the first version); convert everything to sRGB; refuse every photo that is not sRGB | A Replace makes the converted file the photo: a Display P3 HEIC or an Adobe RGB JPEG must keep its colours; carrying the profile keeps a JPEG's or TIFF's values exact, and a DNG's colour is its matrices, so it takes converted values. |
| 2026-10-26 | A converted file's Exif (FrameConverter.Metadata, ExifWriter): from the sidecar the capture time to the tick, offset, exposure, f-number, ISO, focal length, bias and white balance; from the original the make, model, serial, lens, 35 mm focal length, exposure program, metering mode, flash, GPS, artist and copyright, the sequence's camera and lens where the original names none; a frame without a capture time keeps the original's Exif or XMP time, never one from the file system; orientation 1 (the pixels are upright), Software "Chronos"; no MakerNote or XMP. ExifWriter now writes ExposureProgram, MeteringMode, Flash and WhiteBalance, for proxies and exports too. (Owner review 2, R7.) |
Copy the original's Exif block whole | The sidecar's times are the archive's, and the verify checks them to the tick; MakerNote offsets do not survive a new layout; an upright picture written with its old orientation would turn twice. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 flagged frames and size bounds rows: a frame another host flagged undecodable is asked again where the conversion has other decoders, and sizes are weighed without overflow.) The dry run promises only what the job does (ConvertPlanner.Skip): every frame is asked with the conversion's decoders whatever tier was recorded (unknown before the light analysis, another host's, a preview), headers only, 8 files at a time per sequence, and its colour headers are read. Skip reasons: SameFormat (the target's format already: any TIFF for TIFF-16, any DNG for linear DNG), Missing, Unhashed, Undecodable (flagged, or a file shorter than its own headers), TooLarge, NoNativeDecoder and PreviewOnly (both convert_on_pc on the server), EightBit, ColorProfile and Inaccessible (an I/O error or denied access other than not found: a file another program holds without sharing). TooLarge is a bound, never an estimate: a JPEG side above 65535, more than the server's decoders read back (a JPEG of 2^28 pixels, a TIFF-16 or DNG of 2^29 samples), or an incompressible worst case (51 bits per pixel, plus 1 %, plus 8 MiB for a profile and headers) above one array; a MemoryStream overflow while encoding is TooLarge too. (Owner review 2, R7.) |
Probe only frames recorded below native tier (the first version); count a held file as missing | A conversion the dry run promised that then failed made its whole sequence fail at every retry; a lock released before the job ran let it convert, with Replace, a photo the confirmed plan said stays. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 confirmed photos file and New sequence retries rows: the frame ids live in journal/convert-<job>.photos, not in the parameters, and a retry finishes a copy already filed instead of reporting its sequence changed.) A convert job converts exactly the photos its confirmed plan listed: each ConvertSequence of its parameters carries the frames version, the digest of the photos converted (ConvertSequencePlan.Digest: a SHA-256 over {frameId:N}|{sha256} per photo, in sidecar order) and their frame ids (Photos, 16 bytes each in base64), and the plan's fingerprint covers the digests. Under the sequence's lease, its sidecar settled where the index has it then, the job plans it again and takes the confirmed photos from that plan, going on only while they have the digest confirmed; it then pins them (journal/convert-<job>.pins, PinLog) and from then on, a retry included, converts those alone, stage B checking under the lease that every pinned photo still holds its content, not the frames version. Photos uploaded or verified after the confirmation stay as they are. A confirmed photo that changed, went or no longer converts leaves the sequence as it is (Changed: its retry leaves it too, and the log says to plan again); one another program holds leaves it for the retry (Blocked), and a held photo the job does not convert hides no real change. A job an earlier build queued without photos checks the whole plan's digest, or the frames version. (Owner review 2, R7.) |
Plan again and convert what the job finds (the first version); hold the frames version; store the whole plan in the job | The change made is the one shown and typed (BRIEF §0.2 rule 8); a time-lapse still receiving uploads must not make its sequence unconvertible at every retry; 16 bytes a photo keep a whole-archive job row small. |
| 2026-10-26 | The job takes one sequence at a time, its stage A then its stage B. Stage A runs without the lease: each original is re-hashed against its record (a mismatch fails the photo: verify the sequence), converted and verified into .chronos/staging/convert-<job>/<sequence>/, as many at once as DecodeBudget allows for the parallelism and memory, each staged file appended to journal/convert-<job>.staged (one JSON line, flushed). Stage B is all or nothing under the sequence's lease. journal/convert-<job>.json records each sequence's outcome, the statuses its passes follow from and whether they were queued: the passes are queued as soon as a sequence is journaled, and a resume queues those a pause, a yield or a crash lost. A resumed job first settles the crash journals of the sequences still to do, and takes one its replacement already completed (by the pins, or without them by the frames' source against the digest) as converted. A photo that fails fails its sequence, whose staged files stay for the retry, which verifies and takes them; the other sequences go on, and the job fails at the end. A sequence another index moved away (SequenceFolders.Holds) is left blocked with Errors.Archive.FolderMoved; New sequence reads the source's project under the source's lease and writes the copy's under the copy's, only into a folder that holds it. A sequence's staging goes once it is final or changed, the job's journals and staging once every sequence is final. (Owner review 2, R7.) |
All of stage A first, then all of stage B; one JSON journal rewritten per photo; delete the staging of a sequence that failed | Results appear earlier and less is staged at once; appending keeps journaling linear on an 80,000-frame sequence, where a rewritten journal is quadratic; a retry keeps the work done. |
| 2026-10-26 | Maintenance (ArchiveMaintenance.PurgeTemporaryFilesAsync) keeps a convert-<job> staging folder while its job is queued, running or paused, whatever its age, removes it at once when the job is done, and otherwise once its files are a day idle; a conversion's journal files go when its job is done. A job this index does not know (another host's on a shared archive, or one its history forgot) keeps its staging and journal together while any of their files was written within CleanupSteps.DefaultHistoryDays (90), then both go; staging without a journal goes after a day idle. (Owner review 2, R7.) |
Purge staging by age alone (24 h) | A stage A longer than a day lost its staged files, and another host's paused or failed job would have converted everything again; nothing this purges is an original. |
| 2026-10-26 | (Partly superseded by the 2026-11-03 stage A space row: before each photo the job counts that photo and every photo still being written.) Free space is measured where a conversion writes: ArchiveServiceOptions.FreeSpace for the archive root and for its staging folder, the tighter kept. The server takes VolumeSpace.WritableFree, the tighter of the space path's volume (R2) and the folder's own (on Unraid the cache, until the mover runs); the desktop asks Windows (VolumeInfo.FreeBytesAt, GetDiskFreeSpaceEx), which measures UNC archives too. A conversion needs its estimate × 1.15 plus a 512 MiB reserve, counted in both modes (Replace keeps the originals in the trash), estimated from the Export tab's bits per pixel (JPEG by quality × 1.25 for 4:4:4, TIFF-16 30, linear DNG 26; 24 MP when the size is unknown). The job checks at its start, before each sequence (every estimate not staged yet) and before each photo (that photo and those after it that may convert at once, fewer near the end), its estimates scaled by how far the files staged in this run came out above theirs; short, it stops with Archive.Error.ConvertSpace (in GB, or MB below one), its journal and staging kept for the retry. The server measures again at every dry run and confirmation. (Owner review 2, R7.) |
The space volume alone, as the panel shows it; one check per job | On Unraid every staged and filed byte lands on the cache; the noise of a 14-bit RAW outgrows the estimate; a job must stop before the volume fills, not after; reserving a whole batch near the end stopped jobs that fitted. |
| 2026-10-26 | No conversion of the same sequences twice: MassConverter.QueueAsync checks the queued, running and paused convert jobs and queues under one lock of the process, calling the host's enqueue in the caller's context (the desktop's speaks on its UI thread); a sequence another conversion holds refuses the plan (ConversionQueuedException, Archive.Convert.AlreadyQueued): 409 plan_changed without details on the server, and the desktop plans again, showing those sequences busy. A dry run counts every pending conversion's sequences as busy; a job's own re-plan counts only those of conversions created before it (JobRepository.ListPendingTargetsAsync(kind, createdBefore)). (Owner review 2, R7.) |
Let the second job find the first | Two dialogs or tabs, a lost answer and Apply again, or a dry run made before the first job was queued would make two new sequences or convert twice. |
| 2026-10-26 | New sequence: the copies are filed through the archive ingest under the session key convert:<job>:<source> (a resume finds the same sequence), titled " |