[ScriptedAlchemy]

Indexing progress

Refs #4508. The daemon records observed capture, parsing, resolution and native graph writes for a particular generation and writer attempt. Durable text pages and verified compact graph segments have separate counters from rows accepted by a builder. Progress is fenced by writer and generation identity across retries, restarts, and discarded publications. The CLI, MCP and dashboard use that distinction for stall diagnostics, freshness and progress display.

Both manifest and streamed native writers now report accepted entity and relation windows. Replaying an already-installed segment does not count it twice. The dashboard retains the completed generation’s committed work, and a rebuilding search with no work evidence reports progress=unreported.

Verification

On 394be3dd46, the macOS Bazel CLI suite passed all 421 tests, including 27 daemon precondition cases. The previously failing real daemon cold-start and restart test passed, and the graph/store tests observed both kinds of rows before the single verified segment and no events on replay. On the preceding changes, seven MCP graph-dispatch tests, three lexical-anchor tests, 49 dashboard DOM tests and 94 extension tests passed. A prior Linux run exceeded the lexical-anchor fixture’s 20-second publication budget under load. The complete macOS MCP suite at 394be3dd46 also passed all 673 tests in 789 seconds, including that lexical-anchor case. Hosted verification is pending.

Review status

This replaces closed #4795. Keep #4508 open pending independent review, the hosted Linux run on the current head, and acceptance on master for cold indexing, interrupted work, restart and completed progress. The separate draft hold on #4776 remains in effect.

At 416adbdb22, the pinned graph-db rustfmt gate and the native staged compact-copy test passed. The regression observes actual row windows on interruption and verifies the completed segment before publication. The preceding repository-gate failure reported formatting in two assertions added after the prior broad test run.

At 6b4ff93636, repository rustfmt and 45 distinct macOS Bazel cases passed. The tests included all 35 CLI index cases, eight sparse/full construction cases and two daemon publication cases. The registered attempt stopped at durable handoff while retaining the last recorded work and rejecting late callbacks. The CLI regression kept stall detection active for unfinished construction and let healthy durable publication proceed past the simulated stall window. All 49 DOM tests across IndexFreshness, CodeIndexNativeProgress and CodeIndexPipeline also passed. Hosted Linux, the earlier history-reconciliation hold and master acceptance for #4508 remain open.

At 0dda36d127, the repository rustfmt gate, strict Clippy on the shipped CLI and CLI unit target, all 38 CLI indexing tests, and all three native graph progress tests passed on macOS. The latter exercised accepted encoding work, durable page and segment receipts, read-only activation, and fencing of stale callbacks after restart.

Historical branch reconciliation

The original published head and its counterpart in the current branch both point to the complete repository tree 068ad9b3b09a533f498161bc6783c5882a79265b. Starting after common ancestor 091bf9d86c, every one of the 23 commits in the original sequence has the same full tree and stable patch ID as the corresponding commit in the current sequence. The only difference reported within those paired commits by git range-diff is the shortened header of the first commit, de2d6134ef → b2c4997fb4. The 22 changed file blobs at the previously reported 0651f1dbed head came from two subsequent commits, a 21-file formatting change (36b58e3f9f) and a one-line borrowed-resolution-segment correction (0651f1dbed).

The original commit identities remain on a divergent branch of history. All original product changes survived at the matched head, and git cherry d424073ee2 609aff4401 found zero original-only patches. The current head d424073ee2 descends from the identical tree through 19 additional commits.

The owner’s explicit merge hold remains in effect. Keep this PR and #4508 open pending owner disposition of the historical divergence, current-head review and CI, and live master acceptance for daemon cold indexing, interruption, stall detection, restart recovery and completed progress.

At abe2b55785, independent review of the shared polling classifier and its two dashboard callers confirmed that an active preseal/native successor continues polling past a retained terminal refusal, an idle terminal park falls back, and an empty loading scope polls for its first mount. All 54 DOM tests across IndexFreshness, CodeIndexPipeline and CodeIndexNativeProgress passed, as did the dashboard TypeScript check. The owner reiterated the merge hold on this head.

[changeset-bot]

⚠️ No Changeset found

Latest commit: 4f3c5da

Merging this PR will not cause a version bump for any packages. If these changes should not result in a new version, you're good to go. If these changes should result in a version bump, you need to add a changeset.

Click here to learn what changesets are, and how to add one.

Click here if you're a maintainer who wants to add a changeset to this PR

[ScriptedAlchemy]

Taking the #4508 producer implementation on this existing branch, starting from exact head 29c1258. File ownership for this pass: pre-seal capture/parse observation and its separately typed attempt authority, native graph writer progress, and the corresponding freshness/status consumers and regressions. Maintenance/sweep owners: please do not duplicate or rewrite this work; preserve all commits and use expected-head nonforce fast forwards. #4616 owns sealed-store reader/receipt/retention changes; I will keep graph writer changes separate and reconcile any overlap against the exact current heads. Existing boundary tests are not completion evidence. Refs #4508; no closure/merge claim, and #4776/Kev stays draft and #4763 stays read-only.

[ScriptedAlchemy]

Published commit 9f3bfe04cbac4dee01979cd44791d57c5a68b99c directly to this PR, fast-forwarding exact head 29c1258b8f491def3cf34c5cd6e4b4a6b5e194f6 with expected_sha and force=false.

Source changes

• dashboard/src/workspaces/observatory/CodeIndexPipeline.tsx: keep active polling when rebuild_in_flight is true or immutable-artifact restore_progress exists, even when the serving envelope/previous report is already ready. useObservatoryReads therefore keeps its existing 1-second active interval instead of prematurely falling back to 30 seconds.
• An in-flight build without a committed report now renders “code-index build in progress; progress not yet reported”, not “no active code-index build.” It does not manufacture a generation, phase, percentage, or completed-work counter.
• Added CodeIndexPipeline.dom.test.tsx: eleven polling cases plus two React rendering journeys for unreported → committed → ready → retired progress and bounded restore → restored state. Existing tests are unchanged.

Verification performed

The original source was reconstructed byte-exactly and matched GitHub blob 5a3704cdfe5ec3b429fb0b9086e7acc67f35c0b9. A Node test harness executed the actual TypeScript-transpiled exported polling predicate, with unused UI imports guarded against invocation: 11 checks, 4 failing before; 11 passing, 0 failing after. This is focused predicate execution, not a React renderer or full Vitest run. Both changed TSX files also passed syntax transpilation. Published source/test blobs match the locally checked bytes (571d7eb4…, bc61e12c…). The final remote compare is one ordinary commit and exactly these two files (12 source insertions/2 deletions plus the new regression file).

Still required: run pnpm --dir dashboard test src/workspaces/observatory/CodeIndexPipeline.dom.test.tsx, dashboard typechecking, and native Bazel checks for the PR's Rust changes. This container has no Bazel and cannot resolve GitHub for a full checkout/dependency installation; no native Rust pass, full Vitest pass, DOM pass, or independent review is claimed. Exact-head hosted CI is queued.

Backend capture/parse and direct-seal/fallback graph producers remain owned by the active implementation pass above; this commit does not touch those files or claim to complete them. Refs #4508 only. Keep the issue/PR open pending full acceptance; #4776/Kev and #4763 remain untouched.

[ScriptedAlchemy]

Published 0fc10fe as a non-force fast-forward with expected head 9f3bfe0, preserving the concurrent dashboard commit and all earlier commits.

This is a narrow production MCP propagation fix, NOT completion of #4508. Search and graph-read summaries previously dropped the daemon's progress authority, epoch, last-work timestamp, committed counters and blocked reason. They now carry generation + daemon/producer incarnation, progress epoch, the original last_progress_micros, committed TEXT artifact counts/bytes and the typed blocked reason. Text counters are explicitly labelled as text, not native graph writes. An in-flight rebuild without a producer report renders progress=unreported rather than inventing a pre-seal generation/count/clock.

Four new tests exercise the actual search_freshness/freshness_lines renderers with nonzero counters: cold_unreported_work_has_no_fabricated_progress_authority; repeated_reads_do_not_turn_elapsed_time_into_progress; blocked_and_recovered_reports_preserve_work_and_name_the_real_phase; restart_and_remount_keep_epoch_scope_visible. Existing coverage and restore/park tests are retained. These are renderer regressions, not cold-build/restart end-to-end proofs.

Validation: diff inspected against exact parent; no Rust build/test/check/codegen has been run locally. This session has no Bazel/Bazelisk executable or checkout-capable network path (git fails proxy DNS), and the public download path also failed. No Cargo, alternate Rust toolchain invocation, generated-contract hand edits, infrastructure changes, or test bypasses were used. Exact-head native CI run 42439812291 is queued; no pass is claimed.

Independent PR-maintenance review requested for 0fc10fe, especially text-vs-graph attribution, owner-scoped epochs, absence of read-time clock fabrication, and the renderer assertions. Keep this PR unmerged: separately typed pre-seal capture/parse production instrumentation, direct native graph durable-write instrumentation, and cold/interrupted/restarted end-to-end acceptance are still unfinished. The earlier unreferenced producer-draft commit 95aac68 is incomplete and must not be adopted; no producer draft was pushed onto this branch. Refs #4508. #4776/Kev remains draft; #4763 untouched.

[ScriptedAlchemy]

Published 091bf9d86c8e7dbc1e9bd661fe60a06ea10366ae on this existing PR by expected-head non-force fast-forward from 0fc10fed2121688077c5427072b495ee0f393690 (all prior boundary, dashboard and MCP commits preserved). Refs #4508; partial producer work, NOT acceptance or a close/merge signal.

• Introduced CodeIndexPresealWorkV1 (capture vs parser-evidence materialization) and a separately typed attempt slot keyed by daemon incarnation, producer incarnation and monotonic pass sequence. The slot has no fictional generation ID or sealed digest. Only actual positive producer events move work counts or last_progress_micros; duplicate/out-of-order callbacks cannot refresh a stalled attempt, and cancellation/retry/Drop fences an old producer.
• Recorded successful real capture decisions inside the parallel dirty-worktree worker, rather than after the whole batch, and inside the clean-HEAD Git-tree visitor, which is the primary cold path. Clean traversal has no invented total. Reused rows are not counted as new capture.
• Recorded parser-backed file materialization only after its segment has successfully entered preparation, explicitly not as a durable text artifact or native graph commit. Reused parser evidence is not labelled a fresh parser invocation.
• Added two nonzero slot regressions (no heartbeat/rollback, stale retry and incarnation fencing) and one real two-file cold reconcile regression asserting positive capture + parser-evidence observations.

Not claimed: no local Rust/Bazel execution (this environment lacks Bazel/Bazelisk and checkout-capable network); exact-head CI run 42447419869 was queued at last check. The attempt slot is not yet surfaced through the freshness wire, CLI/MCP or dashboard. Native durable graph writer/page progress and end-to-end restart/resume, stalled and blocked/recovered transitions are still required, as are hosted Bazel tests and independent review. Do not treat these three tests as #4508 completion. #4776 remains draft; #4763 was untouched.

[ScriptedAlchemy]

Follow-up producer commit de2d6134efac295d253b915424fd7a4976ac04ae has now been published on the same #4800 branch, fast-forwarded from exact head 091bf9d86c8e7dbc1e9bd661fe60a06ea10366ae with expected_sha and force=false.

This targets the actual native graph writers, not project_graph_publication_phase's read-side projection:

• Native fallback staging pages now yield a typed Applied vs Reused transaction verdict from the real run_gated_batch write path. The graph_native_stage_page_applied event is emitted only after an actual row+receipt transaction completes, including WAL settlement for persistent stores; replaying an already-applied receipt emits no fake write event. It carries real page ordinal/kind, mutation and live-byte counts, and whether WAL sync applies.
• The dependency-free direct-seal path does not write pages. It emits graph_native_compact_segment_verified only after its single compact container is installed and reopened with recovered-digest proof; no fabricated per-page progress during encoding.
• Added a real nonzero persistent-graph regression which applies an actual native page, verifies replay returns Reused instead of Applied, then closes/reopens the WAL-backed store and proves the page receipt and rows survived.

This is real producer instrumentation, not yet the progress-status pipeline. Neither the native events nor the new separately typed pre-seal attempt slot are wired to freshness/CLI/MCP/dashboard yet. No local Bazel/Rust test has been executed; wait for an actual exact-head hosted run, not queued/skipped jobs. Full cold + restart/resume, stalled, blocked/recovered end-to-end evidence remains required. Refs #4508, not Fixes; keep PR and issue open, and do not touch #4776 or release #4763.

[ScriptedAlchemy]

Published follow-up b329b67 on this same PR with a checked non-force fast-forward from exact parent de2d6134. Refs #4508 (partial).

Native writer correctness: the compact sealed-store path previously emitted graph_native_compact_segment_verified even when this writer lost the directory-install race and merely reopened another writer’s verified artifact. The new install verdict suppresses that false new-write observation while preserving the required digest-verified adoption and cleanup. Added concurrent_sealed_install_candidate_does_not_count_as_new_write, a nonzero real-container fixture that installs the winning segment, exercises an actual losing rename into the nonempty destination, verifies loser staging cleanup, and reopens the real winner with the expected recovered digest and nonzero entity/relation counts.

Scope coordination: this touches only the native compact writer-install/reporting block of sealed_store.rs; #4616/#4804 owns bounded receipt reads, read-side cleanup and retention. No changes to those reader/retention sites, no conflict rewrite or dropped commits. Independent review requested for the race outcome, platform-specific directory rename behavior, and whether this remains compatible with #4804.

Not acceptance: no local Bazel/Bazelisk or checkout-capable path; no Rust compile/format/test result claimed. Exact-head CI 42450800548 was queued when last sampled. Pre-seal typed attempt and native durable events still require daemon → CLI/MCP/dashboard status wiring and real cold/interrupted-restart/stall/blocked/recovered end-to-end tests. Keep #4508 and this PR open. #4776/Kev remains draft; #4763 untouched.

[ScriptedAlchemy]

Newly confirmed CI blocker — exact #4800 head b329b671 (2026-11-08)

Hosted Repository gates job 128639401232 executed and failed commitlint, rather than merely being queued. Its output: header must not be longer than 72 characters ... current length is 88 [authored-header-max-length]. This is the existing immutable de2d613 subject, feat(graph): observe genuinely committed native stage pages and verified compact segment (88 characters). A follow-up additive commit does not repair an earlier commit checked individually.

Unblocking this mandatory gate normally requires replacing that historical commit with a compliant-header commit (which would rewrite history), or publishing its content on a clean replacement lineage (which would duplicate this active PR). Both violate the explicit preserve all commits / no rewrite / no duplicate constraints. I have not force-pushed, modified policy, bypassed checks, discarded any commit or created another PR. This is a hard acceptance blocker that requires a policy decision outside the current authorization; later additional code changes cannot make this already-published header pass. The benchmark harness self-tests succeeded, but no native Bazel test or full #4508 end-to-end acceptance is established. Issue #4508 and PR #4800 remain open; protected draft #4776 and release #4763 remain untouched.

[ScriptedAlchemy]

Published 2dc0150edc57 onto the existing #4800 branch using expected_sha=b329b671… and force=false, preserving all ten prior commits. Refs #4508 (partial). This connects the already-produced, separately typed pre-seal capture/parse attempt to the actual mounted registry's lock-independent freshness read. The canonical Rust wire now carries the attempt's daemon/producer incarnation, sequence, phase, completed/total source decisions, progress epoch, original work timestamp, and active state. CLI init --wait and MCP graph/search summaries show those observed fields without inventing a sealed generation, durable text commit, graph page, or polling heartbeat. Three focused nonzero wire/renderer tests were added, but none has been Bazel-executed here.

I also checked master, current root AGENTS.md (repository tree contains no nested AGENTS.md), paginated issue comments, PR discussion, reviews (none), the exact earlier CI jobs, and competing #4508 PRs. The preexisting immutable 88-character de2d613 header still fails mandatory commitlint: the preservation/no-rewrite/no-duplicate instructions preclude correcting it in this lineage. Generated dashboard contract outputs must be regenerated with the mandated Bazel codegen, not hand edited; the new field is on the Rust/daemon/MCP/CLI wire but the React dashboard panel is not yet updated. Native graph writer events still need canonical status observations, and cold/restart/stall/blocked/recovered integration acceptance remains unfinished. Exact-head CI was queued when inspected.

Independent review requested on the public wire change, whether pre-seal attempt expiration correctly fences old owners, correct graph-vs-text attribution, and all fully mounted paths. #4616/#4804 reader-retention ownership is untouched; #4776/Kev remains draft and #4763 release remains read-only. Do not merge or close on this partial evidence.

[ScriptedAlchemy]

Continuing #4508 on exact head 2dc0150. Taking the CLI first-generation wait implementation and its behavioral tests: the live wait currently resets its stall timer merely because rebuild_in_flight/Restoring/Verifying stays true, even when all producer counters are frozen. I am replacing that activity-as-progress inference with observed work tracking, retaining typed refusals and leaving daemon work running when the client stops waiting. Maintenance/sweep owners: preserve these edits and all existing commits; no duplicate/rewrite/force update. Native graph callback/status integration and Bazel-generated dashboard contracts remain separate unfinished acceptance, not made complete by this slice. #4804 owns sealed receipt/retention hunks, #4796 owns graph source reader work; neither is changed by this CLI slice. Refs #4508 only; #4776 remains held draft and #4763 read-only.

[ScriptedAlchemy]

Refs #4508 — published production correctness fix b19884d9a140 to the existing #4800 branch using GitHub create_blob/tree/one-parent commit and update_ref(expected_sha=4af29660a8e5, force=false). Independent PR/branch/raw-commit readbacks all agree; compare is ahead 1 / behind 0, only crates/tracedecay-cli/src/commands/index.rs (+99/−1). All current ancestors and peer work remain preserved. No rewrite, merge, retarget, extra branch/PR, generated edit or bypass. The previously rewritten historical 609aff4 ancestry is not restored; HOLD MERGE.

Actual production defect: FirstGenerationWorkMarker::of correctly treats a completed compact row stream or CompactSegmentVerified as an unknown final single-container write, but returned None before checking an independently active successor preseal attempt. During an older native graph's final Grafeo write, genuine successor capture/parse work was thus discarded and a frozen successor could never reach the no-work refusal. The current fix continues to leave the final native write un-timed when it is the only writer, while selecting the separately owned active preseal marker when present. Only that producer's actual callbacks can renew the wait.

Three falsifiable Rust regressions: (1) complete entity+relation windows and verified graph segment do not conceal the active successor's exact capture owner/count/epoch, but retiring the attempt restores the unknown final native write; (2) serialized init --wait accepts advancing capture→parse behind old final native encoding and reaches an actual Ready receipt; (3) duplicate frozen preseal observations behind the same graph boundary refuse before the scripted later Ready. Existing timeout budget, tests and assertions remain unchanged.

Verification still required: These new tests have not been executed locally; exact-head hosted CI and Plugin Validation are queued. Please independently review the graph-final/preseal authority distinction and require nonzero Bazel Rust/JS/rustfmt/Clippy execution, physical cold/SIGKILL and native durable-stage-page restart/recovery, blocked↔recovered/stalled daemon→CLI/MCP→generated-dashboard DOM journeys, and approval before acceptance. All 11 published inline review threads are currently resolved; no independent approving review. Keep #4508 and #4800 OPEN, UNMERGED, Refs only. No reviewer assigned.

[ScriptedAlchemy]

Refs #4508 — published the production wait-progress correction 10dc2fc7ce91 to this sole existing #4800 branch with a one-parent expected-head force=false fast-forward. Independent PR and Git ref readbacks match the published commit; compare from b19884d9 is ahead 1 / behind 0, only crates/tracedecay-cli/src/commands/index.rs (+144/-9). No force, rewrite, retarget, duplicate branch/PR, generated edit or merge. The historical 609aff4 ancestry is still not restored; HOLD MERGE.

Concrete producer-observation bug: init --wait retained independent preseal and native graph watermarks, but when an active native writer had already produced at least one row boundary, it selected only the native marker (and optional preseal). A separately owned retained lexical BulkCommit could commit genuinely new durable pages while the native writer was quiet; those receipts were dropped, causing a false 120-second no-work refusal. Likewise, a final Grafeo container write could overlap a quiet successor preseal guard and real text receipts; the preseal marker hid the receipts. The waiter now records authentic lexical BulkCommit progress alongside an independent native/preseal marker, each under its own existing owner/epoch/counter fence. It still considers a final monolithic Grafeo write alone uninstrumented, does not project phases, and never credits timestamp/epoch-only changes as completed work.

Three falsifiable native CLI regressions: (1) frozen partial native encoding + advancing independent text receipts reaches Ready; (2) completed native row windows + quiet active successor preseal + advancing text receipts reaches Ready without timing the final write; (3) all three writers publishing only new epochs/timestamps but no counts refuse before a scripted later Ready. Existing budget, tests, real durable attribution, and assertions are unchanged.

Verification: exact new-head Bazel workflow and Plugin Validation are queued; no new-head nonzero Rust/JS/rustfmt/Clippy or macOS pass is claimed, and no local Bazel/pnpm checkout was available. No artifacts yet. Please independently review the simultaneous text/native/preseal authority selection, all three regressions, and current-head CI. Physical cold/SIGKILL/native WAL-page interruption and restart/resume through daemon → CLI/MCP → Bazel-generated dashboard/React DOM, blocked/recovered/no-work E2E, human approval, historical disposition, and MASTER acceptance remain outstanding. Keep #4508 and #4800 OPEN, UNMERGED, Refs #4508 only. No people assigned or contacted.

[ScriptedAlchemy]

Refs #4508 — published 6edb4af07692 to the sole existing PR #4800 on fix/4508-progress-boundaries-ci-clean.

Concrete CLI correctness: init --wait treated an authoritative terminal convergence park as “no reconcile pass” when its typed status contained the actual failure cause and operator remediation. Worse, a stale rebuild_in_flight=true bit could suppress that diagnosis entirely. On an immediate wait=unavailable response, the CLI returned only the short availability code, dropping the daemon's separate Parked cause/remedy. The source fix consumes the existing canonical typed StatusCodeIndexFreshnessV1::Parked reading, preserves its cause, remedy and retry-on-wake flag in the typed unavailable refusal, and classifies terminal parks truthfully during timed-out slices. A separately active successor preseal/native writer still overrides the retained park; recoverable parks are not prematurely classified terminal. No new schema, generated output, heartbeat, progress epoch, durable claim or timeout budget.

Three falsifiable regressions: (1) serialized wait=unavailable with a real-shaped typed parked status must return the exact cause/remedy/retry class before a later scripted Ready; (2) terminal park plus a stale rebuild flag must time out with the parked cause instead of silently continuing or reporting NoPass; (3) real successor-admitted work must clear an old parked classification and reset the idle window, which can expire again only after renewed continuous silence. Existing blocked/recovered, native/preseal and wait assertions are retained.

Verified independent PR+Git branch 10dc2fc7 immediately before each Git object/write and the CAS; one-parent GitHub blob/tree/commit, compare ahead 1 / behind 0, exactly one owned CLI source/test file (+149/-4), update_ref(expected_sha=10dc2fc7,force=false) SUCCESS. Independent post-write PR+branch+commit parent agree at 6edb4af07692ae0ae861f17f56b7fc04c83ab2d6; PR remains open/unmerged. This preserves the current history only; the original published 609aff4 lineage is still externally rewritten: HOLD MERGE.

Please independently review the terminal parked-vs-live-successor precedence, actual typed status deserialization/refusal, and the new tests. No person assigned or messaged. The change has not been Bazel-compiled/tested locally (no checkout/Bazel). Exact-head CI is queued, not a pass. Full live 6,136-file cold/SIGKILL, durable WAL stage interruption+recovery, stalled and blocked→recovered daemon→CLI/MCP→generated dashboard DOM, nonzero exact-head Rust/JS/Clippy/codegen, independent approval, owner-authorized history disposition and master acceptance remain required. Keep #4508 and #4800 OPEN UNMERGED, Refs #4508 only.

[ScriptedAlchemy]

Refs #4508 — published a new production correctness and regression fix as 78d33055e8b0 on the sole existing #4800 branch.

Real defect: during final native graph publication, FirstGenerationWorkMarker::of deliberately suppresses a completed compact row-stream/verified-segment marker because Grafeo's final container write is monolithic and uninstrumented. However, the early return also discarded a separately owned lexical BulkCommit when no successor preseal attempt was active. Real durable text page receipts therefore could not renew init --wait; phase-only polls also could not detect that the lexical writer was genuinely frozen. The earlier fix covered this overlap only when an active preseal marker existed.

Source fix: at completed native encoding and CompactSegmentVerified, select an authentic active preseal observer if present, otherwise the independently owned lexical BulkCommit receipt marker. If neither writer has an eligible observed marker, the final Grafeo write remains unknown, not a synthetic stall. The existing owner/epoch/counter fences still reject metadata-only clock changes. No fake graph page, timestamp, digest, generation, heartbeat or durable claim.

Falsifiable regressions: (1) across both fully encoded native rows and digest-verified native segment phases, real serialized status-loop responses with actual advancing lexical committed pages/bytes must reach Ready, and removing the text writer restores the deliberately unknown final write; (2) when only native/text epochs and text timestamps change without completed counters, the loop must refuse before a later scripted Ready. Both fail against the prior early-return branch. Existing assertions, timeouts, generated contracts, CI and other ownership lanes are unchanged.

Before EACH Git object mutation and the branch CAS, independent PR and raw branch refs matched exact old head 6edb4af07692. Created Git blob/tree/ONE-parent commit; compared exactly ahead 1/behind 0 with only crates/tracedecay-cli/src/commands/index.rs (+91/-4), and update_ref(expected_sha=6edb4af,force=false) succeeded. Fresh independent PR, branch and raw commit confirmed new head and its sole parent. Historical rewritten 609aff4 lineage is still not restored; HOLD MERGE.

Please independently review this physical-observation priority and both new CLI test cases. Exact-head hosted CI is queued at publication, with no current-head nonzero Bazel Rust/JS validation or native macOS proof. Full live cold/SIGKILL, durable fallback stage-page resume, stalled and blocked/recovered daemon→CLI/MCP→generated-dashboard DOM acceptance, independent APPROVED review, history disposition and master acceptance remain missing. Keep PR #4800 and issue #4508 OPEN/UNMERGED, Refs only; no reviewer assignments.

[ScriptedAlchemy]

Refs #4508 — published 7218ed2638b0 on the existing branch to repair the exact-head Bazel //crates/tracedecay-cli:rustfmt_check_2024 failure from Repository gates.

I read the failing job log and applied its four exact formatting hunks in crates/tracedecay-cli/src/commands/index.rs (imports, parked diagnosis write!, frozen-text assertion, and parked-cause assertion). No production behavior, tests, budgets, generated files, or CI rules were changed. GitHub verified an exact one-parent non-force fast-forward from e880e8e8: ahead 1 / behind 0, only that file (+14/-5). Independent PR, Git-ref and raw-commit readbacks match the new SHA.

Please independently review the final-native/lexical silence handling and the new regression coverage alongside this formatter correction. New-head hosted CI has not yet supplied nonzero Bazel Rust/JS/Clippy/rustfmt evidence. The physical cold/SIGKILL/restart/durable-page journey and historical lineage disposition remain outstanding. This is not a merge or a claim of full #4508 acceptance; keep the PR and issue open.

[ScriptedAlchemy]

Refs #4508 — published a production fail-closed initialization repair in 1676b586bc15 on the sole existing #4800 branch. Independent branch and PR reads agree at the new head; the Git commit has exactly one parent 7218ed2638b0, and GitHub compare is ahead 1 / behind 0, only crates/tracedecay-cli/src/commands/index.rs (+62/-11). No force, history rewrite, retarget, alternate PR, merge, closure, or generated/CI policy edits.

Concrete bug: init swallowed any non-Git reconciliation error whose formatted message contained code_index_scheduler_unavailable, even if that was incidental text in an unrelated storage or transport failure. It then returned a successful unavailability receipt rather than the actual refusal. The owned CLI now recognizes only the canonical typed ProjectRoute.reason_code or ToolRefused.code. A Config failure or a different refusal code mentioning those words stays a failure. Regression cases preserve both real typed scheduler refusals and Git/nested-Git nonoptional behavior while asserting unrelated diagnostic substrings can never authorize success.

Newly verified exact parent-head CI: workflow 42776137560 finished: Repository gates, Dashboard, Clippy, and Feature gates succeeded; Linux fleet failed on an unrelated //crates/tracedecay-global-db:unit_test 300s timeout (182/183 test targets passed). No test/timeout changes were made because global-db has a different owner. New-head CI 42896769146 is in progress; Plugin Validation 42896768935 passed. No new-head nonzero Bazel Rust/JS result or native macOS pass is claimed.

Please independently review the exact-code-only optional-reconciliation boundary and its positive/negative regressions, together with remaining progress semantics. I did not assign or message anyone. Cold physical 6,136-file capture/parse/graph, hard SIGKILL before seal and restart, receipted durable-page interruption/resume, blocked↔recovered and no-work daemon→CLI/MCP→Bazel-generated React DOM proof, APPROVED review, historical ancestry disposition and MASTER acceptance are still missing. Keep #4508 and #4800 OPEN/UNMERGED, Refs only; HOLD MERGE.

[ScriptedAlchemy]

Coordination / Refs #4508, #4593: separate existing draft #4801 now has f1e2f5c, which retains authenticated submodule binding through reconcile.rs::capture_admitted_candidate and passes it from the candidate loop. Your #4800 modifies that same loop to emit preseal progress. These changes are on separate branches; #4800 has not been edited. Please preserve both the accepted-candidate progress observation and the bound-child pre/post-read authorization checks when the prerequisite stack is reconciled. Neither branch should be blindly rebased/merged over the other; native Bazel tests and peer review are still needed. No ready/merge request here.

[ScriptedAlchemy]

Refs #4508 — published a real CLI stall-watermark correctness fix in 9570de71ca62 on the sole existing open PR #4800 branch. GitHub object update had exactly one parent 1676b586bc15, compare ahead 1 / behind 0, exactly crates/tracedecay-cli/src/commands/index.rs (+52/−7); branch CAS used expected_sha=1676b586bc15, force=false. Independent PR/ref/raw-commit and owned-file reads now match the published commit. All CURRENT peer ancestry preserved; the original externally rewritten 609aff4 identity remains a separate merge hold.

Concrete production failure: In FirstGenerationWorkMarker::advance_from, a newer-epoch native graph snapshot with regressed accepted row/page counters returned Some(false) but replaced the previous coherent watermark. A subsequent snapshot merely replaying the already observed counter could then be credited as fresh native work and reset init --wait's 120-second silence clock indefinitely, concealing a stalled writer. The code now rejects same-native-attempt counter rollback without adopting it; real greater accepted counters still renew the wait. New falsifiable Rust regression checks a rollback at 60 seconds, reappearance of already observed rows at 120 seconds (must stall), and a genuine increment at 121 seconds (must renew). No timestamp or phase projection is used as work, no test removal, timeout increase, generated edits, CI policy changes, or unrelated owner-path changes.

Please independently review the same-attempt native counter monotonicity fence and its relationship to legitimate distinct-attempt restarts. Exact new-head nonzero Bazel Rust, JS, Clippy and rustfmt not yet claimed. The previous head's CI had Repository gates, Dashboard, Feature gates, Clippy and Windows SUCCESS but Linux fleet 181/183 targets with two failures outside the owned lane: runtime_acceptance_suite (LSP ack DeadlineExceeded) and dashboard_api_test (memory curation). Neither failure was hidden or altered here; native macOS skipped. Continue holding #4508 and #4800 OPEN UNMERGED, Refs #4508 only, pending the physical cold/SIGKILL/restart, daemon→CLI/MCP→generated-dashboard/React DOM, independent APPROVED review, full master acceptance, and original history disposition.

[ScriptedAlchemy]

Refs #4508 — exact-head hosted Bazel formatting failure repaired on the sole existing #4800 branch. For prior 9570de71, Repository gates executed 8 policy tests successfully but failed //crates/tracedecay-cli:rustfmt_check_2024 with one specific diagnostic at index.rs:819: Rustfmt requires the new same-native-attempt counter-rollback condition to be split into a multiline .iter().zip(...).any(...) chain. Published 020fa2babf70, applying only that exact formatter hunk (+5/-1) in the owned CLI source/test file. The meaningful producer rollback protection and its falsifiable tests from 9570de71 are preserved unchanged. No timeout, assertion, contract, generated code, CI policy, or outside-owner change.

GitHub verified one parent 9570de71, compare ahead1/behind0, expected-head force=false CAS, and independent post-update PR/ref/commit/file SHA agreement. Request independent review of native rollback semantics and the source-only formatter fix through this PR thread; no people assigned or messaged. The previous head's Dashboard passed and Linux/Clippy were still in progress at inspection; no new-head nonzero Bazel Rust/JS/format/Clippy pass is claimed. Historical externally rewritten 609aff4 lineage remains a merge hold; physical 6,136-file cold start, hard SIGKILL/restart, durable native staging interruption/recovery, blocked/recovered, master acceptance and independent APPROVED review still required. Keep #4508 and #4800 OPEN, UNMERGED, Refs #4508 only.

[ScriptedAlchemy]

Refs #4593 / #4508 — coordination only, no changes to #4800. The existing #4801 DRAFT branch now has nonforce commit 49fcebc on top of eed23c3. In the shared code_index_scheduler/reconcile.rs capture path, it changes previously Boolean child-binding pre/post checks and active/clean-HEAD reuse gates to propagate typed parent-Git I/O refusal. When reconciling the peer #4800 progress instrumentation with #4801, preserve BOTH the accepted-candidate progress observations AND the error-bearing pre/post parent/child authorization checks; no false absent success or skipped work marker. No merge/ready/approval claim: #4801 remains DRAFT, new Rust regression and exact-head native Bazel verification pending, #4593 OPEN. The unresolved per-entry parent-index revalidation cost is separately tracked in #4801 review.

[ScriptedAlchemy]

Refs #4508 — published additive producer-aware blocked/stall fix 32da7d815206 on the existing sole #4800 branch. Verified raw one-parent commit 020fa2b, compare ahead 1 / behind 0, exactly one owned Rust CLI source/test file (+143/−17), pre-update PR and Git ref both exact parent, update_ref(expected_sha=020fa2b,force=false) success, and independent post-update PR/ref/parent matching. No merge, rewrite, retarget, duplicate branch or protected PR change.

Concrete production failure: init --wait checked its retained CodeIndexBuildProgressV1.blocked_reason idle timeout BEFORE checking whether an independently owned graph/preseal/text producer had really advanced. A retained same-generation text refusal could therefore trigger a 120-second Blocked refusal even while the active native graph writer's authenticated row receipts kept increasing; the separate progress window could not save the wait.

Source correction: sample all independently fenced producer counters first, and clear the blocked-condition timer ONLY on actual counter advancement observed after the prior status. Initial nonzero snapshots are baselines, not recovery; phase/epoch/clock-only retries, status polling, and the unknown final Grafeo write do not fake work. New work during the unknown-native interval is also fenced to its independent text watermark. Existing blocked-cause timeout priority and real frozen-work stall are preserved. Two falsifiable Rust regression cases cover (a) independently advancing native row counts with a retained text refusal, followed by a genuinely frozen period that still times out; (b) epoch/timestamp-only native reports that must not reset the blocked timer. Existing assertions and timeout budgets unchanged; no generated contracts/CI policy/infra edits.

Please independently review the new new_work_since_prior_read baseline fence, unknown-native handling and blocked→recovered transition semantics. No people assigned or messaged. No local Bazel checkout; new-head nonzero Rust formatting, unit tests and exact-head full CI are not yet confirmed. Original externally rewritten 609aff4 history remains a separate merge hold; physical first-generation/SIGKILL/WAL restart, native macOS, independent APPROVED review and master acceptance are still missing. Keep #4508 and #4800 OPEN/UNMERGED, Refs only.

[ScriptedAlchemy]

Refs #4508 — published production correctness fix 48f1e5b3bd7b on the sole existing #4800 branch. Independent prewrite PR and Git-ref heads both matched 9b7b161; created one-parent Git commit on that exact parent, compare ahead 1 / behind 0, exactly one owned CLI Rust source/test file (+79/-1), update_ref(expected_sha=9b7b161,force=false) succeeded, and independent postwrite PR/ref/parent/source-blob readbacks all matched. No force, rewrite, merge, retarget, duplicate PR, or generated code change.

Confirmed source defect: FirstGenerationStall::of treated a retained same-generation lexical blocked_reason as an active build refusal even while the independently owned native writer was in its final Grafeo compact-container write, which is genuinely monolithic and has no intermediate callbacks. The progress window correctly recognized that native interval as unknown, but the separate blocked idle window still refused after 120s, falsely claiming the native graph writer stalled. This is distinct from the previous peer's Bazel rustfmt-only fix at 9b7b161.

Fix: when the typed native owner is active and has completed encoding or reached its verified-segment boundary, do not treat an old text refusal as evidence that the uninstrumented native write is blocked. Once the native owner retires, the identical typed lexical refusal is visible again. Existing actual writer counter/identity/epoch fences, blocked status for observable phases, no-work stall checks, time budgets and dashboard contracts remain unchanged. No synthetic heartbeat, progress, pages, clock, or durable compact-write claim.

Two falsifiable nonzero Rust cases added: the real serialized init --wait status loop stays pending through frozen lexical RetryBackoff while active final encoding or verified-segment work runs and succeeds only on the real Ready receipt; a ResidentMemory refusal reappears immediately after the graph writer is no longer active and fails the loop before a later Ready. The prior code fails both cases. Request independent review via this PR's discussion, especially the same-generation text/native authority boundary and durability semantics; no reviewers assigned.

Exact-new-head CI and Plugin Validation queued, so NO current-head nonzero Rust/Bazel/JS/Clippy/rustfmt pass is claimed. Original 609aff4 external ancestry divergence, independent APPROVED review, physical cold/SIGKILL/page-restart acceptance, and master acceptance all remain merge holds. Keep Refs #4508, #4508 and #4800 open/unmerged; Kev/model drafts untouched.

[ScriptedAlchemy]

Refs #4508 — published an additive CLI production and Rust regression repair in 88e17159908b on the sole existing #4800 branch.

Root-cause review: FirstGenerationProgressWindow::record advanced its global daemon owner fence before validating the specific producer marker with advance_from. An impossible retained text snapshot claiming a newer daemon but the same generation with a foreign sealed_source_digest is correctly rejected by the per-text identity fence; however, its unvalidated daemon ID still poisoned the global fence. Subsequent genuine text page commits from the authenticated existing daemon were discarded, so init --wait could falsely refuse a progressing build as stalled.

Production fix: adopt self.owner only after a producer marker is accepted and the independent per-producer watermark is updated. Invalid digest, duplicate, regressed, or stale reports can no longer mutate global authority. Existing real-work checks and timeout budgets are preserved; no fabricated work/epoch/clock, generated changes, unrelated paths, or test weakening.

Falsifiable native Rust regression: authentic daemon #3 text baseline, foreign digest report claiming daemon #900 (must not advance or poison), then authentic daemon #3's next committed page at 119s (must advance), then unchanged receipts at 238/239s (must stall exactly at 120s after genuine work). Previous code loses the valid page and fails the regression.

Verified exact independent prewrite PR+branch head 48f1e5b; Git blob/tree, single-parent commit; compare ahead=1 behind=0 exactly one owned source/test file (+50/-1); update_ref(expected_sha=48f1e5b,force=false) succeeded. Independent postwrite PR, branch, parent, tree and blob readbacks all matched 88e1715. All CURRENT peer ancestors retained, no rewrite/merge/closure. Original externally rewritten 609aff4 lineage remains a separate merge hold.

Independent review requested of daemon-wide adoption ordering and foreign sealed digest rejection (please review in this PR discussion; no reviewer assignments). This is SOURCE ONLY until exact-head hosted nonzero Bazel Rust/rustfmt/Clippy/JS completes, with full physical cold/SIGKILL/durable-page restart E2E still outstanding; keep #4508/#4800 open and unmerged.