From 80af956bbc4fee9242cb3fe5a9c15646ae28260b Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 17:15:18 +0000 Subject: [PATCH] docs: record the second verification pass in DECISIONS, CHANGELOG and STATUS Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- docs/CHANGELOG.md | 99 +++++++++++++++++++++++++++++++++++++++++++++++ docs/DECISIONS.md | 31 +++++++++++++++ docs/STATUS.md | 11 ++++-- 3 files changed, 137 insertions(+), 4 deletions(-) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index d241a4dd..420c1d31 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -160,6 +160,9 @@ commits follow Conventional Commits (release notes are generated from them by `T one-sentence toasts when the file cannot be read or its sequence is not in the library. One Titano runs per data folder, and a later launch hands its file to the running one or, while that one is closing, waits for it and starts with the file. +- Server: `PATCH /api/v1/sequences/{id}` takes `expectedFramesVersion` and answers 409 `frames_conflict` when the + sequence's frames changed since the settings' frame positions were written. `GET /api/v1/sequences/{id}/manifest` + returns frames, frames version and settings of one frames version. ### Fixed - Server: downloading the current log while it was being written aborted the response (Content-Length mismatch); it @@ -298,3 +301,99 @@ commits follow Conventional Commits (release notes are generated from them by `T copy that stays. - The `.titano` file type name is written in setup's language. - Titled notes with no listed changes now say 'Maintenance release.'. +- Server: HEIF frames whose proxies had arrived stayed preview-only, capped at the size of their Exif thumbnail (often + 160 × 120); the advisor then chose the 720p preview preset and the Library showed the preview-only chip. A frame + read from its proxy is no longer preview-only, an arriving proxy has the sequence analysed again, and a deep + analysis or render that was running when the proxies came no longer flags the frames again. +- Proxies: renders, analyses, the server's manifests and proxy downloads used a proxy another photo had left at a + frame's place after frames were inserted before it, or a thumbnail-sized one made by an earlier version. Proxies of + frames whose capture time has a seventh sub-second digit (file-system times) were rejected. One rule now decides: + the frame's own capture time, to the microsecond, and the policy's size for frames the host reads through proxies. +- Server: frames added to a sequence whose proxies had all arrived were not asked for their own until the next proxy + pass. Manifests now read a proxy's header only when the file has changed. +- Deep analysis: a run resumed after proxies arrived kept its checkpoint's 'unreadable' verdicts, and a saved report + kept listing frames that now decode from their proxies (warning badge, exclusion advice). Such checkpoints start + over, such reports no longer count, and the server no longer sends them to remote editors. Checkpoints written by + earlier versions still resume. +- Thumbnails drawn from proxies ignored the archive's thumbnail size. Below 320 px they were drawn again and appended + to the pack on every pass; above 320 px they were never redrawn at the larger size. +- A proxy or thumbnail pass resumed after a pause, crash or retry could mark the sequence complete while frames before + the resume point lacked them, so the server stopped asking for those proxies. The proxy pass log now counts frames + waiting for a proxy apart from unreadable ones. +- Sync: exclusions, the hero frame and camera keyframes taken from the server, or sent to it, could land on other + photos. This happened when the photos they were written against arrived later (a download or upload of earlier + photos), when photos were imported or uploaded while the settings were compared or sent, or when a hero was chosen + while another waited for its photo. Settings now move between copies translated to the receiving copy's frames, + matched by photo and read as one state with those frames. Positions on photos that copy does not hold yet wait in + the project until the photos arrive. +- Server (PostgreSQL): settings saved through the API while photos were being filed into the sequence could be + silently undone. +- Sync: downloading a sequence the server adopted but never verified failed with 'did not arrive intact'. Its + originals now download, are size-checked and hashed on this PC, and are matched to this PC's copies by size and + capture time. They are not uploaded again, and their proxies are sent like the others. A photo the server's folder + holds twice no longer leaves Download on offer forever. +- Sync: when the server's settings version moved without a change, the comparison failed while the local archive was + offline or read-only. Identical settings are now agreed without touching the archive. +- Sync: thumbnails cached in place of proxies the server did not have yet were kept after the server got its proxies. + The next proxy download replaces them, and offline caches refresh when the proxies arrive. +- Server: a sequence created with `POST /api/v1/sequences` that was still waiting for its first photo could lend its + id to loose photos at the archive root during a scan, also when the root's sidecar was damaged. The Uploader's + uploads then went to the root. A rebuild could delete such a sequence, and maintenance compacted the root's + thumbnails under its id. Scans, rebuilds, the orphans check, verify and maintenance now leave it alone until its + first photo gives it a folder. A root sidecar the server may not read now fails that folder only, not the whole + scan. +- Server: sequences found by a scan now get thumbnails and proxies like uploaded ones. This covers photos already in + an adopted folder, folders another writer adds and photos added to a folder. Each sequence gets its own background + pass, so a folder renamed or deleted before its pass no longer leaves the others without images. Remote cards and + proxy downloads no longer stay empty until an administrator queues the jobs. +- Mass rename and move: a folder that gained a sequence after the dry run (a scan of photos copied into a subfolder) + no longer moves while that sequence's index row stays behind. Such a plan is refused as out of date. +- Server: sending a large chunk again after a lost answer, to an unknown or finished upload, or with a session that + had signed out or lost the upload permission closed the connection instead of answering. The answer now reaches the + client, including 401 and 403, so the Uploader asks the user to sign in instead of retrying. +- Server: `PUT /api/v1/archive/settings` answered 500 when archive.json held a thumbnail size or proxy quality out of + range. It now answers 409 `archive_policy` and names the policy to correct. +- Desktop archive polling started only at launch, for the archive folder known then. An archive created on the first + run, chosen in Settings or relinked was never rescanned, and Rescan every had no effect, until a restart. Polling + now follows the archive folder and survives a drive that is offline at start. +- When the server or another PC changed an archive's templates, proxy size or name in archive.json, imports, uploads + and the admin panel kept the old values until a restart, and saving the admin panel's archive form wrote the old + templates back. The index now follows the file whenever Settings › Archive opens and at every rescan, on the desktop + and on the server, and the admin form reads the file when it opens. A poll no longer puts back values an + administrator had just saved, and an archive.json written by a newer Titano is no longer registered. +- Settings › Archive saved 320 as this PC's thumbnail size whenever the open archive was offline. With an empty + archive folder it edited the first archive of the index. It silently dropped an edit made while a newly chosen + archive was still opening, and an edit made just before a second folder change went to the archive of the later + folder. +- Start with Windows (client and Uploader) stayed ticked after Task Manager disabled the entry, and ticking it again + could not turn the entry back on. The Uploader now also reads it again when its settings open. +- A portable copy unpacked in a OneDrive folder, including a Desktop or Documents folder backed up by OneDrive, kept + its SQLite index there. It now keeps its data in %LOCALAPPDATA%\Titano, says so at start and names the data it kept + beside it before, which it leaves untouched. A per-user data folder that OneDrive synchronises is now reported with + a warning. +- Import: a photo that could not be copied, a card file the plan could not read, and every photo a stopped import + never reached now say why in the app's language: destination full, access denied, card gone, the server's own + reason, server not answering, untrusted certificate. The system's text no longer appears, on the Import screen or in + the import job's log. +- Errors: a server behind a reverse proxy that answers with its own error page (for example 502 while the server + restarts, or 413 for a large photo) now reads 'The server does not answer' or 'The request is larger than the server + accepts' instead of the English 'Bad Gateway' or 'Request Entity Too Large'. +- Archive: picking another archive no longer leaves the previous archive's tiles, charts, last scan, recent runs and + rail badge on screen, or its maintenance actions enabled, while the new one is read or after its read fails. +- Jobs: a render that ends while its sequence is open in the editor always gets exactly one completion toast, with + Show in folder. It still gets one, without Show in folder, when the editor cannot read the sequence again or closes + as the render ends, and a render the editor did not follow is announced too. +- Jobs: Open on a job over several sequences (a deep analysis of a Library selection), from its toast, its Windows + notification or its row, shows all of them selected in the Library instead of opening only the first in the editor. + A job over a whole archive opens the Library without freezing it. +- Server (Windows): a service that refused its data folder or `server.json` stopped with error 1064 and gave no reason + anywhere. Start and stop failures now go to the Application event log (source `TitanoServer`) with the entry to + check. The README gives the full steps to fix a data folder created by a console run. +- Docker and Unraid: the `TITANO_TRUSTED_PROXIES` guidance suggested trusting a whole Docker network (Unraid: + `172.17.0.0/16`), whose gateway carries relayed IPv6 and host connections. It now names the proxy container's own + fixed address and warns against subnets, the gateway and the default bridge. +- Setup: an upgrade that renamed the client or the Uploader deleted its sign-in entry, which silently turned *Start + with Windows* off. The entry now moves to the new program with its options, and is removed only when the component + is dropped. +- Setup: uninstalling removed the client's and the Uploader's sign-in entries but left the on/off state Task Manager + keeps for them. It now goes with the entry; an entry an upgrade moves keeps it. diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index 58763ebd..63684cc3 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -331,3 +331,34 @@ One line per decision: date · decision · alternative · reason. | 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 | 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 Titano, 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. The uninstaller removes only the Run value; a marker left behind is inert. | 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 | A portable copy whose .\data would lie in a folder OneDrive synchronises keeps its data in %LOCALAPPDATA%\Titano. 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%\Titano | 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 titano.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%\Titano 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%\Titano 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 Titano error code shows its message. | Show the HTTP reason phrase; drop it in `TitanoClient` | 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 | When the Windows service fails to start or stop, it writes the reason to the Application event log as source `TitanoServer` (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 `TITANO_TRUSTED_PROXIES`: a fixed IP on a user-defined network shared with Titano, 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, Titano 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. | diff --git a/docs/STATUS.md b/docs/STATUS.md index 3bb856be..2aa1474f 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -18,10 +18,13 @@ Phase plan: docs/BRIEF.md §22. Windows behaviour is verified on CI (`windows-la ## Verification (2026-10-12) A full audit against the brief, `CLAUDE.md`, the UI kit, the tests and the Docker and client setups confirmed 71 -defects with independent verifiers; all are fixed (rows dated 2026-10-12 in DECISIONS and CHANGELOG), except that the -new screenshot diff (BRIEF §20.2 visual regression) gates nothing until its first baselines are committed. The Docker -image was built and run with PostgreSQL 17, a fresh archive folder and remapped ports; the client installers are -installed, run, upgraded and removed on `windows-latest` by the `installer` CI job. +defects with independent verifiers. A second pass over the fixes confirmed 37 more (proxies and decode tiers, project +positions crossing copies through sync, server scans and maintenance, desktop settings and polling, a portable copy +inside OneDrive, setup and deployment guidance). All are fixed, each with tests (rows dated 2026-10-12 in DECISIONS and +CHANGELOG), except that the screenshot diff (BRIEF §20.2 visual regression) gates nothing until its first baselines +are committed (Next steps). The Docker image was built and run with PostgreSQL 17, a fresh archive folder and +remapped ports; the client installers are installed, run, upgraded and removed on `windows-latest` by the +`installer` CI job. ## How to try it