correx/qa/audit-report-2026-06-08.md

correx QA / Audit Report — 2026-06-08

Live operator session (Phase 3). Provider: local llama-server via env-var fallback (llama-cpp:default @ 127.0.0.1:10000). Target: qa/sample-repo/ (tag clean).

Run context / repro prompt

Workflow: role_pipeline (analyst→architect→planner→implementer⇄reviewer). Target workspace (TUI Hello workingDir): /home/kami/Programs/correx/qa/sample-repo (reset between runs with git -C qa/sample-repo reset --hard clean). Provider: env-var fallback llama-cpp:default @ 127.0.0.1:10000 (start llama-server first).

Operator prompt used for every run so far:

Fix the failing test in this repository. Running `python3 -m pytest` shows
tests/test_calc.py::test_average_empty failing: calc.average([]) raises
ZeroDivisionError, but it should return 0.0 for an empty list. Diagnose the
cause in src/sampleapp/calc.py, implement the fix, and verify all tests pass.

Patches applied this session (rebuild + restart server to load):

• F-001: LlamaCppInferenceProvider.kt — drop grammar when tools present.
• F-005: FileReadConfig/Main workspace builder/FileReadTool — workingDir-relative path resolution.
• F-007: validator content-map (drops CAS dep) + ArtifactContentStoredEvent slot→hash recording. No server restart needed for validation correctness.
• F-008: TomlWorkflowLoader — propagate stage token_budget → generationConfig.maxTokens.
• F-009: FileReadTool file-not-found → recoverable=true; SessionOrchestrator feeds recoverable tool errors back into the loop instead of failing the stage.
• F-010: SessionOrchestrator — reject premature stage_complete when an LLM-emitted slot is unfilled; nudge the model to emit the artifact.
• F-011: artifact schemas (analysis/design/impl_plan) — list fields string → array. Live config under ~/.config/correx/schemas/ + repo docs/schemas/ synced.
• F-012: SessionOrchestrator.stripCodeFence — strip outer ``` fence from LLM-emitted artifacts before hash/store/validate.
• F-013: ValidationPipeline — payload-validation failures retryable, structural ones not.
• F-014 + diff: FileEditTool — schema matches real params (target/replacement/patch); successful edits emit a unified diff.
• F-015: SessionOrchestrator — record tool-execution events + materialise a real file_written artifact from the on-disk write; gate validation so a no-write stage cannot be rubber-stamped.
• F-016: Main.kt — stageTimeoutMs 60s → 180s (still a hardcode; should be config-wired).
• F-018: SessionOrchestrator — write-nudge: when a stage owes a file_written artifact but the model ended a turn with content (or called stage_complete) without writing, push back a corrective tool-result instructing it to invoke file_edit/file_write (bounded by MAX_TOOL_ROUNDS). Extends the F-010 premature-completion guard to file-write stages. Regression fix: FileReadToolTest updated for the F-009 recoverable=true change.
• F-019: FileWrittenArtifact/FileWrittenKind gain a diff field; file_edit+file_write emit a unified diff (shared DiffUtil.unifiedDiff); materializeFileWritten threads it into the artifact the reviewer reads, so the reviewer can verify the change.
• F-020: FileEditTool — model-correctable failures (bad patch, target-not-found, bad params, unknown op) now recoverable=true (feed back, don't abort); tool/operation descriptions + implementer prompt steer toward replace/file_write over the fragile patch op.
• F-021: FIXED — resume rehydrate() now consumes ArtifactContentStoredEvent (slot→hash) and fetches CAS bytes by content hash instead of passing the slot name to the hash-keyed store.

Key reproducibility note: the live config the server reads is ~/.config/correx/ (configDir = ConfigLoader.configPath().parent), NOT the repo. Code fixes load via repo build jars on the classpath; all config/prompts/schemas come from ~/.config/correx/. The repo docs/schemas/ were stale relative to live — a clean-checkout reproduction will differ.

Findings

F-001 — grammar + tools sent together → llama.cpp 400, every tool+artifact stage dies

• invariant/contract: functional (workflows run end-to-end) / #7 path (artifact constraint)
• subsystem: infrastructure/inference (llama_cpp)
• severity: blocker
• evidence: logs/current.log analyst stage: llama-server returned 400 Bad Request: "Cannot use custom grammar constraints with tools.". Request body carries both "grammar": "root ::= ..." and "tools":[file_read, stage_complete].
• repro: correx run role_pipeline (any prompt) against sample-repo. Analyst declares allowed_tools=[file_read, ShellTool] AND produces=[analysis]. Fails immediately.
• root cause: LlamaCppInferenceProvider.kt:103-104 sets grammar and tools unconditionally. llama.cpp's server forbids the combination. ANY stage that both has tools and a JSON responseFormat is unrunnable on llama.cpp. role_pipeline analyst + implementer both do → pipeline cannot start.
• fix direction: when tools are present, drop the GBNF grammar and rely on post-hoc schema validation + retry (invariant #7 still holds — output is validated); OR gate the artifact emission into a separate tool-free final inference turn.
• status: PATCHED (workaround) — LlamaCppInferenceProvider.kt: grammar suppressed when tools are present; artifact now constrained by validation+retry only. Requires server restart to take effect. Proper fix tracked below.
• follow-up TODO (proper fix): add a first-class artifact-emission tool — the LLM calls emit_artifact(path, content, description) like it calls file_read/file_write, making artifact production an explicit schema-checked tool call instead of a grammar constraint that can't coexist with tools. TODO left in code at the patch site.

F-002 — non-retryable 400 is retried to exhaustion

• invariant/contract: functional (retry accounting)
• subsystem: core/kernel (orchestration retry policy)
• severity: minor
• evidence: orchestrator marks the 400 retryable=true; retries 1/3, 2/3, 3/3 all identical 400s within ~80ms, then WorkflowFailedEvent retryExhausted=true.
• suspected cause: retry classifier treats all provider failures as retryable. A 400 invalid_request_error is deterministic request-construction failure → should be terminal.
• status: confirmed

F-003 — ~ not expanded in default_system prompt path

• subsystem: core/kernel (prompt loading) / core/config
• severity: minor
• evidence: failed to load prompt '~/.config/correx/prompts/default_system.md': Prompt not found (searched: .../prompts/~/.config/correx/prompts/default_system.md) — tilde concatenated literally onto the config dir. Logged ERROR on every attempt. Non-fatal (run proceeds) but noisy + the default system prompt is silently absent.
• status: confirmed

F-005 — file_read jails relative paths against process cwd, not the workspace

• invariant/contract: functional (tool jailing) / two-plane consistency (#9)
• subsystem: infrastructure/tools/filesystem (FileReadTool) + apps/server wiring
• severity: major (blocks any file_read of a relative path unless server launched from inside the workspace)
• evidence: logs/current.log session c0eab7ba: analyst emitted file_read(path=tests/test_calc.py). Plane-2 PATH_CONTAINMENT PROCEEDed (resolved=.../qa/sample-repo/tests/test_calc.py, inWorkspace=true), but the tool's own validateRequest rejected it: Path 'tests/test_calc.py' is not in the allowed list → stage produced no artifact → surfaced as the misleading no transition condition matched from stage analyst.
• root cause: FileReadTool resolved the relative path via Paths.get(p).toAbsolutePath() = JVM process cwd (the correx repo root, where the server was launched), not the bound workspace. FileReadConfig had no workingDir field at all, unlike FileWrite/FileEdit which carry workingDir and call resolvePath(). So the two file-access planes anchored relative paths to different roots.
• status: PATCHED — added workingDir to FileReadConfig, wired workspace.workingDir in Main's per-workspace tool builder, and gave FileReadTool a resolvePath() mirroring FileWriteTool. Requires server restart.
• note: the operator-facing failure reason (no transition condition matched) masked the real cause (tool denial). See F-004 family — failure-reason surfacing is lossy.

F-007 — ArtifactPayloadValidator conflates slot name with CAS content-hash → crash

• invariant/contract: functional (artifacts validate) / #7 (LLM output untrusted until validated — the validation step itself is broken)
• subsystem: core/validation + core/artifacts-store contract vs infrastructure CAS
• severity: BLOCKER (every workflow with a typed produces slot crashes at the first post-stage validation against the real CAS store)
• evidence: logs/current.log session 28c818c1: analyst COMPLETED (responseArtifactId=82da21d5…, a real blake3 hash), then runSession ... failed: hex string must have even length — CasArtifactStore.hexToBytes at CasArtifactStore.kt:102, called from ArtifactPayloadValidator.validateSlot:36.
• root cause: ArtifactPayloadValidator.validateSlot calls artifactStore.get(slot.name). slot.name is the LOGICAL slot id ("analysis"), but CasArtifactStore.get requires ArtifactId.value to be a hex content-hash (id.value.hexToBytes()). "analysis" → odd-length → require throws. The validator has no slot-name→content-hash mapping: ValidationContext carries only the static graph + SessionState, and SessionState holds NO produced-artifact map. So the validator cannot locate the bytes it is supposed to validate.
• deeper implication: this path has apparently never been exercised end-to-end against the real content-addressed CAS — it only "works" if the ArtifactStore is keyed by literal slot name (an in-memory test double). The ArtifactStore.get(ArtifactId) contract is ambiguous: the validator treats ArtifactId as a logical name, the CAS treats it as a hash.
• fix direction (NOT a one-liner): the run's produced-artifact mapping (slot name → ArtifactId(hash)) must be derived from the event log (an ArtifactProduced-type event projection per invariant #1) and threaded into ValidationContext, so the validator resolves slot.name → stored hash before get. Cross-module change (events → projection → context builder → validator). Audit-only: NOT patched.
• status: FIXED.
• fix applied: two changes (validation crash + durable mapping).
  1. Validator no longer touches the CAS. ValidationContext gained producedArtifactContent: Map<String,String> (slot.name.value → payload). The orchestrator populates it from the in-memory artifactContentCache for every produced slot across graph.stages (scoped to the session). ArtifactPayloadValidator reads from that map and dropped its ArtifactStore dependency entirely — the slot-name vs content-hash conflation is gone. Main.kt wiring updated. Validation stays live-only (never runs during replay) so invariant #8 is unaffected.
  2. Slot→CAS-hash mapping now recorded as an event (invariant #9 — env observation recorded at the moment it runs). New ArtifactContentStoredEvent(artifactId=logical slot, contentHash=CAS blake3 hash, sessionId, stageId), registered in Serialization.kt, emitted at both CAS write sites (LLM-emitted slot path + tool/ process_result path; the tool path previously discarded the put() return value). This is the durable record that lets content be recovered from CAS by hash after a cold start.
• remaining follow-up (not in this fix): the validator/needs-rehydration still read the in-memory artifactContentCache, which is lost on restart (the F-001 rehydration-gap suspect). Closing that means resolving slot→hash→CAS from the new ArtifactContentStoredEvent on cold start / re-validation. Foundation is now in place.

F-006 — TUI input pane render glitch

• subsystem: apps/tui-go
• severity: minor (cosmetic)
• evidence: operator screenshot 16:07 — a garbled/smeared rectangular artifact in the bottom-right of the input pane (uncleared region / stale cell buffer) while the prompt text rendered normally on the left.
• repro: operator confirms it appears only on multi-line paste into the input box; single-line / typed input renders clean. Likely the input widget doesn't repaint the full region when a pasted block changes line count.
• status: confirmed, repro narrowed (multi-line paste only)

F-004 — InferenceFailedEvent / RetryAttemptedEvent unmapped to TUI bridge

• invariant/contract: functional (operator observability)
• subsystem: apps/server (DomainEventMapper)
• severity: minor
• evidence: DomainEventMapper: unmapped payload type=InferenceFailedEvent and =RetryAttemptedEvent repeated. Operator sees failure only via router narration, not a structured failure/retry surface in the TUI.
• status: confirmed
• note: ArtifactContentStoredEvent is also unmapped (DomainEventMapper: unmapped payload type=ArtifactContentStoredEvent) — same class of gap, new event added this session.

F-008 — stage token_budget not propagated to provider max_tokens → truncation

• invariant/contract: functional (workflows run end-to-end) / #7 (validatable output)
• subsystem: infrastructure/workflow (TomlWorkflowLoader) + core/transitions (StageConfig)
• severity: major
• evidence: session f5046936: role_pipeline.toml analyst declares token_budget=16384, but every request carried "max_tokens":2048 (the StageConfig default). The analyst's 2nd inference hit completionTokens=2048 finishReason=length → JSON truncated mid-string → artifact validation failed → no transition condition matched.
• root cause: TomlWorkflowLoader.toWorkflowGraph set StageConfig.tokenBudget from the TOML but never populated generationConfig, so the 2048 default maxTokens reached the provider. token_budget fed context budgeting only, never the completion cap.
• status: FIXED — loader sets generationConfig.maxTokens = s.tokenBudget. Confirmed live (session 1876d22a: 337 completion tokens, no truncation).

F-009 — tool-execution errors abort the stage instead of feeding back to the model

• invariant/contract: functional / #3 (tools suggest; core records and continues)
• subsystem: infrastructure/tools/filesystem (FileReadTool) + core/kernel (orchestrator loop)
• severity: major
• evidence: session 1876d22a: analyst speculatively read tests/__init__.py (doesn't exist); FileReadTool returned recoverable=false → orchestrator treated it as FATAL → stage failed reason=File not found: tests/__init__.py retryable=false. Both FATAL and recoverable ERROR tool results aborted the stage (the ERROR: feedback entry was built then discarded) — the model never got to adapt.
• root cause: FileReadTool marked missing-file recoverable=false; SessionOrchestrator loop returned StageExecutionResult.Failure for any ERROR/FATAL tool entry instead of appending recoverable errors to context and continuing.
• status: FIXED — missing file → recoverable=true; recoverable errors flow back into the tool loop (bounded by MAX_TOOL_ROUNDS); only FATAL aborts. Confirmed live.

F-010 — premature stage_complete stores an empty artifact → validation fails

• invariant/contract: functional / #7 (the artifact-emission contract)
• subsystem: core/kernel (SessionOrchestrator)
• severity: major (direct consequence of the F-001 grammar drop)
• evidence: session ea968b72: after reading files the analyst called stage_complete with empty content, never emitting the analysis JSON. The orchestrator captured response.text (empty, hash af1349b9…) as the artifact → validation failed.
• root cause: once the GBNF grammar is dropped for tool-bearing stages (F-001), nothing forces artifact emission; the model can end the stage via stage_complete without producing its declared slot.
• status: FIXED — stage_complete is rejected while an LLM-emitted slot is unfilled; a corrective tool-result nudges the model to emit the artifact (bounded by MAX_TOOL_ROUNDS). Confirmed live (session c02cf17e: nudge worked, real artifact emitted on the 3rd turn).
• follow-up (proper fix): the first-class emit_artifact tool from the F-001 TODO would make artifact production an explicit schema-checked tool call.

F-011 — artifact schemas over-constrain list fields as string → validation rejects arrays

• invariant/contract: functional (artifacts validate)
• subsystem: config schemas (~/.config/correx/schemas/) + core/validation
• severity: major (latent — masked by F-007/F-008/F-010 until artifacts validated cleanly)
• evidence: session c02cf17e: analyst emitted a complete analysis with requirements as a JSON array; schema declared requirements/affected_areas as "type":"string" (newline-separated). JsonSchemaValidator (single-type, no unions) rejected the array. The model emits arrays every run.
• root cause: schema design mismatch with natural model output; the minimal validator cannot express a string|array union.
• status: FIXED — requirements/affected_areas (analysis), components/risks (design), steps/verification (impl_plan) changed string→array. Live config + repo docs synced. review_report.verdict left string (the verdict == approved transition depends on it).
• note: validation strictness itself is correct (#7 held — it rejected mismatched output).

F-012 — LLM wraps artifact JSON in a markdown code fence → unparseable

• invariant/contract: functional (artifacts validate)
• subsystem: core/kernel (SessionOrchestrator)
• severity: major (model-nondeterministic — any stage, any run)
• evidence: session 231179c5: planner emitted ```json … ``` for impl_plan; the validator parses raw JSON → parse failure → validation failed. analyst/architect that run emitted bare JSON and passed — the difference is pure model nondeterminism.
• status: FIXED — stripCodeFence in runInference removes an outer fence wrapper before the artifact is hashed/stored/validated (CAS, cache, validation stay consistent). Conservative: only fires when the whole response is a fenced block.

F-013 — validation failures never retried → one bad LLM output kills the workflow

• invariant/contract: #7 ("Rejected + retried (max_retries)") — the plan's stated contract
• subsystem: core/validation (ValidationPipeline)
• severity: BLOCKER (robustness — the dominant failure mode with a nondeterministic model)
• evidence: session 67776482: analyst emitted a malformed artifact (a tool-call shape as JSON content); validation rejected it retryable=false and the workflow died, despite max_retries=2. The previous run's analyst was flawless — pure nondeterminism with zero recovery.
• root cause: ValidationPipeline marked all ERROR-severity validation outcomes retryable=false ("structural errors must be fixed"), conflating graph misconfiguration with transient bad LLM output.
• status: FIXED — payload-validation failures (artifact_payload section) are now retryable (stage re-runs up to max_retries); structural/graph errors stay terminal. This wired the invariant-#7 contract that was never actually implemented. Stabilised the pipeline end-to-end (session c6212fd0 completed 9 stages after this).

F-014 — file_edit schema misdescribes its own parameters → edits never apply

• invariant/contract: functional (tool side effects) / #5
• subsystem: infrastructure/tools/filesystem (FileEditTool)
• severity: BLOCKER
• evidence: session c6212fd0: implementer called file_edit operation=patch with old_str/new_str (exactly what the schema advertised) → Missing 'patch' parameter for 'patch' operation. Across all 4 implementer rounds, not one edit applied; the file stayed unchanged.
• root cause: schema documented content/old_str/new_str; the code reads content (append), target/replacement (replace), patch (unified diff, via patch -p1). old_str/new_str are read by nothing; target/replacement/patch are documented nowhere. A schema-following model can never replace or patch.
• status: FIXED — schema now documents the real params (target/replacement/patch), drops the dead old_str/new_str. Plus: successful edits emit a diff -u unified diff (operator-requested), surfaced in ToolReceipt.diff and the file_written artifact.

F-015 — tool-output artifacts auto-validated without verifying the side effect → false success

• invariant/contract: #5 (all side effects captured in events) / functional (real output)
• subsystem: core/kernel (SessionOrchestrator emitToolArtifacts + dispatch)
• severity: BLOCKER (a green done run that changed nothing — worst-case for a kernel)
• evidence: session c6212fd0: workflow completed terminalStage=done, verdict=approved, 9 stages, but git status clean and calc.average bug intact. emitToolArtifacts unconditionally emitted ArtifactCreated→Validating→Validated for the patch slot every implementer round regardless of any write; validateSlotAsFileWritten early-returns when the slot has no content (it never had any) → rubber-stamped. The reviewer then approved a no-op.
• root cause: file-mutating tools never produced a file_written artifact (unlike shell tools → ProcessResultArtifact); tool executions emitted no completion/file-write events at all, so nothing tied the patch slot to a real write.
• status: FIXED — dispatch now emits ToolExecutionCompleted/Failed + FileWrittenEvent, and materialises a real file_written artifact (path, content hash, size, diff) from the on-disk result. emitToolArtifacts gates the file_written slot on that content: no write → no artifact → verifyProduces fails the stage → retry → honest failure (confirmed live, session 57d5795d: did not produce declared artifacts: patch retryExhausted=true).

F-016 — stageTimeoutMs hardcoded at 60s, too tight for local models + not configurable

• invariant/contract: functional (operability)
• subsystem: core/kernel (OrchestrationConfig) + apps/server (Main)
• severity: major
• evidence: session 57d5795d: ~15 TIMEOUT: Timed out waiting for 60000 ms across the run (7–8 on implementer alone). Large implementer/reviewer turns (plan + design + file contents) were cut off mid-generation, burning all retries → did not produce patch.
• root cause: OrchestrationConfig.stageTimeoutMs defaults to 60_000L and is hardcoded in Main (defaultOrchestrationConfig) with no config wiring.
• status: PARTIAL — raised to 180_000L in Main. Should be surfaced as a config knob (TODO left at the patch site).

F-017 (observation, not a correx defect) — local model does not reliably issue write tools

• invariant/contract: n/a (model capability)
• subsystem: n/a (provider model llama-cpp:default)
• severity: informational
• evidence: session 57d5795d implementer: 6 inference attempts, only file_read calls — zero file_edit/file_write, zero stage_complete. Even on turns that completed within timeout, the model read repeatedly and never attempted the edit it was instructed to make.
• note: correx offers file_write/file_edit correctly and the implementer prompt explicitly instructs tool-based writing. This is a model-selection conclusion: role_pipeline's correctness is sound, but this local model is too weak for the implementer stage. Re-test the implementer with a stronger model before drawing functional conclusions about that stage.

---

F-018 — implementer emits the change as prose instead of invoking the write tool

• invariant/contract: functional (workflows write expected files) — mitigation for F-017
• subsystem: core/kernel (SessionOrchestrator tool loop)
• severity: major (robustness; the stage silently failed instead of coaxing a write)
• evidence: sessions 57d5795d, fef41879: implementer dispatched only file_read (2–3 calls), then ended turns with finishReason=stop/length — emitting the corrected code as message content, never calling file_edit/file_write. The write tools WERE offered in the request (confirmed: file_edit/file_write present in the implementer's tools array). The stage then failed did not produce declared artifacts: patch with no attempt to redirect the model.
• status: FIXED (staged) — the tool loop now nudges: a content turn (or a stage_complete) while a file_written slot is unfilled triggers a corrective tool-result ("you MUST call file_edit/file_write …") and a re-run, bounded by MAX_TOOL_ROUNDS. If the model never complies it fails honestly at the round cap — a clean signal that the model (not correx) is the wall. Unit tests green; awaiting a live run to confirm it tips this model into tool-calling.

F-019 — file_written artifact carries only metadata → reviewer can't see the change, loops forever

• invariant/contract: functional (refinement loop / reviewer can verify work)
• subsystem: core/artifacts (FileWrittenArtifact) + core/kernel (needs-injection) + the diff path
• severity: major
• evidence: session 265f5fe6 — the implementer wrote correctly (file_write, real diff; calc.average fixed, all 7 pytest pass). But the reviewer (needs=[patch, impl_plan]) saw only the FileWrittenArtifact metadata and returned changes_requested: "Cannot verify the patch content — only metadata (hash, size, mode) was provided, not the actual code changes." The refinement loop hit its 2-iteration cap → WorkflowFailed: refinement loop exceeded 2 iterations.
• root cause: FileWrittenArtifact is (path, contentHash, size, mode) — no diff, no content. The diff added in F-014 lives on ToolReceipt.diff / the tool output, but is NOT threaded into the artifact the reviewer's needs injection reads. (Also: the implementer used file_write, which produces no diff at all.) So the reviewer is structurally unable to review the change — the flip side of the operator's original "patch tool should provide a diff" point.
• status: FIXED (staged) — FileWrittenArtifact gained a diff field; both file_edit and file_write now compute a diff -u unified diff (shared unifiedDiff helper in DiffUtil.kt) and surface it via ToolResult.metadata["diff"]; materializeFileWritten threads it into the artifact the reviewer's needs-injection reads. Unit tests green (artifacts 6, filesystem 38, kernel, validation). Awaiting a live run to confirm the reviewer can now verify the change and the loop converges.
• secondary observation: reviewer verdicts were nondeterministic — one turn emitted verdict=approved ("approved at tier T3…"), later turns changes_requested. With no diff to anchor on, the verdict is essentially ungrounded.

F-020 — file_edit failures are fatal + model defaults to the fragile patch op

• invariant/contract: functional (tool robustness) / #3 (tools suggest, core records & continues)
• subsystem: infrastructure/tools/filesystem (FileEditTool) + implementer prompt
• severity: major
• evidence: session 6ebe0c50 — the implementer correctly called file_edit (F-014 works) but chose operation=patch and produced a non-applying unified diff → patch -p1 exit 2 → Patch failed with exit code 2. The failure was recoverable=false (FATAL) → the stage aborted with no chance for the model to fall back to replace/file_write. File unchanged. (Also observed: a client-side Request timeout has expired independent of stageTimeoutMs.)
• root cause: (a) model-correctable file_edit failures (bad patch, target-not-found, bad params, unknown op) were all marked recoverable=false, so they aborted instead of feeding the error back (same class as F-009); (b) nothing steered the finicky local model away from the fragile patch op toward the reliable replace/file_write.
• status: FIXED (staged) — (a) those failures are now recoverable=true → fed back into the loop so the model can self-correct or fall back (and F-018's write-nudge re-engages); the patch failure message now explicitly suggests replace/file_write. (b) Tool description + operation description recommend replace/file_write over patch; implementer prompt rewritten to call a write tool (prefer file_write/replace, avoid patch) and not stage_complete before writing. Filesystem tests green (38). Awaiting a live run.
• note (model-swap groundwork): correx already has per-stage model selection in the data model (StageConfig.modelId, capability routing, multi-provider config) but it is unwired — the TOML loader parses neither a per-stage model nor capabilities, and DefaultInferenceRouter's modelId overload falls back to capability routing. Enabling the llm_pipeline-style per-stage model swap (e.g. a tool-strong model for implementer/reviewer) needs only targeted wiring, not new architecture. Deferred pending the robustness-first decision.

F-021 — resume-after-restart rehydrate() reuses the F-007 slot-name-vs-CAS-hash conflation

• invariant/contract: #1 (event log is the only source of truth) / #8 (replay/restore is environment-independent) — resume-after-restart
• subsystem: core/kernel (DefaultSessionOrchestrator.rehydrate)
• severity: major
• evidence (static, not yet probed live): DefaultSessionOrchestrator.rehydrate (line 171) walks ArtifactValidatedEvents and calls artifactStore.get(p.artifactId) to repopulate artifactContentCache. p.artifactId is the logical slot id ("analysis", "patch"), but CasArtifactStore.get requires a content hash (id.value.hexToBytes()). get("analysis") → non-hex → throws → rehydrate throws → resumeSession (rehydrate) logs failure. So a mid-session resume cannot restore produced-artifact content; downstream needs-injection and artifact validation (which read artifactContentCache) would then be empty/broken.
• root cause: identical to F-007 — slot name vs CAS content-hash. The F-007 fix added ArtifactContentStoredEvent(artifactId=slot, contentHash=hash) as the durable bridge, but rehydrate does not consult it; it still passes the slot id straight to the hash-keyed CAS.
• fix direction: rehydrate from ArtifactContentStoredEvent — artifactStore.get(contentHash) then artifactContentCache["sessionId:slot"] = content. The F-007/F-015 events already record the needed slot→hash mapping; this just consumes it on cold start.
• status: FIXED — rehydrate now scans ArtifactContentStoredEvent (the durable slot→CAS-hash bridge added in F-007) and calls artifactStore.get(p.contentHash), keying the cache by the logical slot name (p.artifactId). The slot name is never passed to the hash-keyed CAS, so the odd-length-hex crash is gone and content is restored on cold start. RehydrateTest reworked to use a content-addressed fake store (slot name ≠ content hash) so it actually exercises the bug; both cases green. Replay (#8) unaffected — rehydrate is live-resume-only. Still wants a live #1/#8 resume probe to confirm end-to-end restoration.

Steering (functional contract) — partially exercised live

• During the live operator sessions, approval-with-steering was informally validated: the operator steered toward a specific indentation; the initial attempt was made without that guidance and the steered re-attempt incorporated it. So the steering note entered the journal and affected the run. Not yet a controlled probe (no event-level assertion captured), but not untouched either.

Audit outcome summary

role_pipeline is now fully green, end-to-end. Session 4679ed1e (the final run) completed WorkflowCompleted, terminalStage=done, 5 stages in a single clean pass — analyst → architect → planner → implementer → reviewer → done, no review-loop bounce:

• the implementer followed the F-020 steering and used file_write (4 calls, 3 FileWrittenEvents, no patch botching);
• calc.average was correctly fixed (if len(values) == 0: return 0.0), real git diff, all 7 pytest pass;
• the file_written artifact carried the diff (F-019), the reviewer's needs-injection showed Input artifact: patch with the diff, so the reviewer could actually verify the change and approved on the first pass.

Every correctness defect found (F-001, F-005, F-007 through F-016, F-018, F-019, F-020) is fixed and now confirmed live. The earlier failures (265f5fe6 reviewer loop, 6ebe0c50 bad patch) were the last two blockers; both are closed.

Still to PROBE (implementations mostly exist; the audit hasn't run the adversarial checks — "outstanding" here means un-probed, not unimplemented):

• #8 offline replay — implemented and unit-tested (ReplayOrchestrator + testing/replay/ suite). Needs the adversarial probe (export log, replay with network/LLM off) to confirm.
• #1 resume-after-restart — wiring implemented (POST /sessions/{id}/resume, resume(), rehydrate()) but F-021 shows rehydrate() is broken (slot-name-vs-CAS-hash, same as F-007). Strongly expected to fail a live probe until F-021 is fixed.
• #2 projection isolation, #4 policy-vs-approval, #6 compression non-authority, #9 env-observation replay — not yet probed this audit.
• undo / cancel / approval-gate — functional contracts not yet exercised. Steering was partially exercised live (operator steered indentation; re-attempt incorporated it).

There is now a real recorded, validated file change (4679ed1e) to point the undo/replay/resume probes at — though resume needs F-021 first. Optional groundwork: wire per-stage model selection (F-020 note); the model remained the flaky element even on this passing run.