Owner review 1, phase 1 (docs/requests/2026-10-15-owner-review-1.md).
Thumbnail and proxy jobs over several sequences counted sequences while
they checkpointed inside one: the rate decayed until the time left
overflowed TimeSpan, the job failed while publishing progress and again
while saving it, and stayed Running. The throughput is now seeded by the
first window with progress, the time left is bounded (JobEta), saving
progress never throws, image passes count frames, and job speeds use the
right unit (bytes for verify and import).
The debugger stops in WicDecoderProvider.cs when presets changed were
cancelled preview decodes leaving synchronous thread-pool delegates; the
editor's sources, LatestRunner and the render node's proxy task now keep
them in their own tasks, and a cancellation is never an unreadable frame.
GoPro DNGs converted by Adobe software were classified GPR and read only
through their 8-bit preview, and Windows' preview-only DNG decoder was
reported as a native decode. A DNG is GPR only when its raw image is
VC-5, WIC decodes RAW only through the Raw Image Extension and never DNG,
analyses and previews take an adequate embedded preview by choice while
renders develop natively, and frames already indexed as GPR are
reclassified by the next light analysis.
Also records the owner's request (docs/requests), the BRIEF amendments
(§8.1, §8.2, new §24), DECISIONS, CHANGELOG, STATUS and ARCHITECTURE.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The orphans fix and scans treated a folder whose only new photo could not be
read yet (held open, no permission, an offline placeholder) as changed: the
sidecar was rewritten, the covering flags cleared and analyses queued again at
every click. SequenceAdopter.Reconcile now returns null when it indexed nothing
and changed no flag, as its contract says.
A deep pass counted as current by frames version alone, so a pass whose verdict
a proxy made stale overwrote the report a later pass made from the proxies,
then dropped the deep status. It now counts as current only when its report
describes the frames as they are, and otherwise replaces only a saved report
that does not describe them either.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
A deep pass overtaken by a frames change that keeps the frame count, with a
light analysis queued, leaves an analysis.json of that count in place rather
than save its own. It then still recorded its own report: the deep status,
summary, warning count and Auto values described a report that is not on
disk, and the queued light analysis kept that summary until the next deep
pass. SaveReport now says whether it saved; when it did not, the pass reads
the saved report as a light analysis would and records that one.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
A deep pass saved analysis.json as soon as it finished, before it checked
that its frames were still the sequence's. A pass overtaken by an upload, or
by another Titano sharing the archive, replaced the report a later pass had
made of the frames as they are: the report endpoint answered 404 and the
next light analysis dropped that pass's deep status. The report now waits in
memory and is saved under the sequence lock, when its frames are current or
the saved report describes the frames as they are no better; the checkpoint
is deleted only then.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
An analysis compared only this host's index row with the frames version it
read at its start. On a desktop sharing a server's archive, the server's
upload bumps only the shared sidecar until the desktop's next scan, and a
desktop scan clears nothing. A desktop pass that recorded in that window
wrote Auto values and statuses for the old frame count over the server's
analysis in the shared project.json and sidecar, and nothing analysed the
photos again.
Under the sequence lock the analyser now reads the sidecar first. When its
frames version is not the row's, the photos changed in another process and
this index does not hold them yet: the pass records nothing, logs
Advisor.Log.FramesChangedElsewhere and queues nothing, since a light
analysis here would read the same index. The process that changed them
analyses them, and this host's next scan indexes them (a server's scan
then queues their analysis). A moved row still queues a light analysis
unless one is queued, in which case the pass records as before.
Tests cover the shared-archive case with a second index and engine, and
the queued-light escape on a one-worker engine.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
A light or deep analysis read its frames at the start and, under the
sequence lock, recorded AnalyzedLight, the warning count and the advisor's
Auto values for them whatever happened meanwhile. Frames added by an upload,
an import or a scan's reconcile then kept advice and warnings counted on the
old frame count, over a newer light analysis, and scans never queued another
one because AnalyzedLight was set again.
Under the lock the analysis now compares the row's frames version with the
one it read. When it moved and no light analysis is queued for the
sequence, it records nothing (a deep pass keeps only analysis.json and its
per-frame measurements), and the job logs it and queues a light analysis of
the frames as they are. A queued light analysis replaces what the pass
records, as for image passes.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
A deep analysis kept the report it had just made, measured from the frames
loaded at its start. Proxies that arrived during a long run make its verdict
on those frames' originals stale (every later reader drops the report), yet
the run applied its advice and recorded AnalyzedDeep, HasWarnings and the
unreadable frames' warnings. The light analysis the proxies queued could have
finished on another worker before, and nothing ran it again.
The run now loads the frames again under the sequence lock and keeps its
report only while it describes them (SequenceAnalyser.ReadReport's rule); the
Auto values are applied under that same lock as the status
(ProjectStore.UpdateLockedAsync), so a light analysis either ran before and
is not undone, or runs after. Its scan stamps are recorded only while the
index holds the sidecar's frames.
Test: a deep analysis of HEIF files without an Exif thumbnail, during which
their proxies arrive, records no deep status and leaves the warnings and Auto
values of the light analysis that read the proxies.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
- ArchiveImages.IsProxyOf compares capture times to the microsecond the index
keeps (sidecars and Exif keep 100 ns ticks), and for frames read through
proxies also applies the policy's size rule, so the proxy pass, uploads,
thumbnails, renders, analyses, tiers, manifests and downloads agree.
- Proxy headers are cached per file while length and write time are unchanged
(and the file has settled), so manifests cost a stat per proxy.
- FrameTiers.RecordAsync checks proxy presence when it writes the sidecar and
returns the sequence's frames as they are, so a deep analysis or render that
ran while proxies arrived no longer flags the frames preview-only again, and
the analysis advises from the current flags.
- Server manifests ignore ProxiesBuilt for frames the server cannot decode, so
frames added since the last proxy pass are asked for their proxies.
- GET /sequences/{id}/analysis/report answers 404 for a report that found
frames unreadable before their proxies arrived (DeepReports.ReadCurrentAsync).
- The deep checkpoint key marks only frames read from proxies, so checkpoints
written by earlier versions still resume.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
- Renders, analyses, the server's manifests and proxy downloads take a proxy only
when its Exif capture time is the frame's (ArchiveImages.IsProxyOf); one left at
the index by a frame renumbered since counts as missing and is asked for again
(V-24).
- A frame whose original the host reads through its proxy (HEIF on the server) is
preview-only only while it has none: the light analysis and the proxy pass keep
the flag, the preview-only count, the light finding and the advisor's output cap
in step with the proxies, and an arriving proxy queues a light analysis on the
server (V-1, V-25).
- The deep checkpoint's content key includes whether each frame is read from its
original or its proxy, and analysis.json lists the frames measured from proxies;
an unreadable verdict on a frame now read from its proxy makes the report stale
(V-26).
- Thumbnails drawn from proxies are compared with the archive's thumbnail size
instead of 320 px (V-27).
- A resumed thumbnail or proxy pass sets ThumbsBuilt/ProxiesBuilt only when the
frames an earlier run did still have theirs, and the proxy pass logs frames
waiting for a client's proxy apart from unreadable ones (V-28).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
- Preview sizes come from probes and unscaled decodes: a size-limited decode
picks the smallest preview that reaches its edge (CR3 PRVW 1620x1080), so
renders and deep passes record its tier without a size and the output cap
keeps the largest preview's.
- A read error is not an undecodable file: ImageDecoder.Decode throws the
IOException when a provider could not read the file and none produced
pixels. Deep passes never flag frames they could not read or that
vanished, and frames only an interrupted earlier run found undecodable
are decoded again before they are flagged.
- Renders resolve stand-ins only for frames the pipeline asks for; frames
the read-ahead meets on the way (skipped by speed-ups) are left alone.
- A GoPro GPR finds its JPEG in the index when an import or upload kept it
in a sequence of its own (same original stem and capture time), for
probes, deep analysis, renders, thumbnails, proxies and the editor;
GPRs whose JPEG is indexed later are probed again.
- Thumbnails judge an embedded preview by its own JPEG header.
- PostgreSQL writes tier fields 1000 frames per statement.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
Settings (UI-01, UI-02, UI-03, UI-09, RF-4):
- New Import, Analysis and Formats pages, in the order of Settings.html. Import holds
the defaults of new cards (session rules, subfolders, verification, duplicates,
after-import actions); Analysis the deep-analysis width cap, night and star-field
thresholds and deep analysis after import or scan; Formats the decode tier of every
format on this PC with a notice and Store install link per missing codec extension.
- Archive gains thumbnail size and rescan interval; its templates, proxy size and
thumbnail size are the open archive's own (archive.json) and new archives' defaults.
- Rendering quality, parallelism and background priority now drive the jobs: quality
maps to preparation size, read-ahead and default flow quality; parallelism sets the
engine's workers live and caps per-job threads; background priority raises the UI
thread while Titano is in front.
- Advanced gains Restore (daily backups, dry-run summary, destructive confirmation,
staged for the next start) and Reset all.
- The naming preview's sample title is a catalog string.
Engine (ENG-03, ENG-04, ENG-06):
- ArchiveService.GetSettingsAsync/UpdateSettingsAsync rewrite archive.json atomically
under a lease, then the index row; the server endpoint and the desktop use them, and
the desktop creates archives with Settings › Archive. ThumbnailPolicy in archive.json
sizes the thumbnails.
- DatabaseBackups: daily VACUUM INTO copies kept x3 on the desktop and on a server on
SQLite (DatabaseBackupService), staged restore checked and preceded by a fresh copy.
- Maintenance vacuums the SQLite index when 10 % or more is free (dry run reports it).
- JobEngine.SetWorkers; ProcessingOptions.Tune applies host tuning per job.
Archive setup toasts say why in a localized sentence (RF-1).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
BRIEF §8.2 tiers 2 and 3 had no writer: PreviewOnly and Undecodable were never set,
so the advisor could not cap the output at the preview size and one unreadable frame
failed a whole render.
- ImageDecoder.Probe names a file's tier without decoding it (JPEG, PNG and TIFF
without opening the file); the light analysis probes frames whose tier is unknown,
and the deep analysis, renders from originals and thumbnail/proxy passes record
what decoding actually found (FrameTiers). Sidecar frames gain "tier", "previewW"
and "previewH"; the index gains frames.preview_width/height and
sequences.preview_only_count (migration 0005, SQLite and PostgreSQL).
- SequenceContext takes the preview size from preview-only frames, so the advisor's
output cap applies; the light analysis reports format tiers (preview-only frames as
information, undecodable ones as a warning under the deep analysis' key, listed
once); a sequence that gains undecodable frames warns at once.
- Only a file in a format the host decodes natively is flagged undecodable; files
beyond the host's decoders keep their tier without the flag, so render nodes and
proxies can still supply them.
- A frame that stops decoding during a render is replaced by its nearest planned
neighbour and logged instead of failing the job; the render fails only when no
planned frame decodes.
- The Library card shows a preview-only chip with the count (local and server
sequences: SequenceDto.PreviewOnlyCount, FrameDto preview size).
- GoPro GPR decodes through the JPEG the camera writes beside it when that is larger
than the embedded preview (BRIEF §8.1).
- Thumbnails use a stored embedded preview only when it reaches 320 px; a smaller one
sends the frame through the host's decoders instead (BRIEF §8.5).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
"1 sequenze su 3" read wrong in Italian: a single failure now reports its
own line (title and reason); the count is kept for two or more. A worker
whose job could not be finished while the engine stops logs it instead of
faulting, so disposing the engine never throws.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
Moving them to Jobs.Analysis.* deleted keys that the integration branch
translates into every culture. The advisor resource test now covers the
Advisor.Log.* job lines, as on the integration branch.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
- JobEngine: ISelectiveJobHandler lets a host decline jobs of a kind it runs;
declined jobs stay queued for other claimers without holding up the rest.
JobContext.EnqueueFollowUpAsync queues follow-up work on the same engine.
- Server renders the jobs whose every output a managed encoder produces
(ManagedRenderJobHandler); MP4 jobs stay for render nodes. Program.cs
registers ProcessingModule next to ArchiveModule. Server renders ignore a
client's export folder.
- Light analysis is queued after imports and after scans that indexed new
sequences, so the advisor's Auto values exist without user action.
- Analysis jobs log a failing sequence and go on; the job then fails and a
retry analyses only the failed ones. The advised frame rate follows the
user's fit-to duration.
- ProcessingJobs.RenderEach splits a batch into one job per preset for
servers; render nodes say which batch presets they did not render, fetch
each content once and stop on a changed certificate.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC