Bring the AMICODE_* stdout grammar under the shared-fixture roundtrip discipline

[jack-champagne]

Problem

The run-dir contract has three producer↔consumer boundaries. Two are guarded; the stdout grammar is the one that escaped the discipline.

Boundary	Producer	Consumer	Guard
orchestrator ↔ schema (TOML)	amico-run	schema	✅ producer_roundtrip.sh + SchemaPackage
host ↔ webview (inspector msgs/DOM)	RunsManager	RunInspector	⏳ frozen; gated by #62
solver ↔ host (AMICODE_* stdout)	solve_template.jl (@printf)	run_dir_reader.ts (regex)	❌ unguarded

The AMICODE_PULSE_META / AMICODE_ITER / AMICODE_PULSE grammar (#66, self-labeled prototype-grade at solve_template.jl:45) is encoded three independent times:

1. @printf in packages/extension/templates/solve_template.jl
2. regexes in packages/extension/src/run_dir_reader.ts
3. hand-copied string templates in packages/extension/test/corpus/fake-julia (1.4a: smoke corpus — seconds-scale end-to-end fixtures (Scheduler → executor → RunsManager → Inspector) #78)

The #78 smoke corpus proves fake ↔ parser agreement (wiring). It does not guard template ↔ parser: if solve_template.jl changes its emit format and the parser isn't updated, fake-julia doesn't change either, so the suite stays green while real solves silently break.

Why the existing roundtrip does not already cover this

packages/schema/julia/emit_fixture.jl is a 14-line, TOML-stdlib-only stub. Its lone AMICODE line is a hardcoded literal —

println("AMICODE_ITER iter=1 f=1.000000e-03 inf_pr=1.0e-9 inf_du=1.0e-6"); flush(stdout)

— that exists only so amico-run's tail has something to drain while producer_roundtrip.sh validates result.toml against the schema. It is not the template's emit code, and it is never fed to the TS parser. So producer_roundtrip.sh guards TOML↔schema only; there is no consumer-side (parser) step in it today. This is new coverage modeled on the schema fixture pattern — not an extension of that script.

Proposed fix (right-sized to 3 line types)

1. Extract the template's emit into shared Julia helpers — emit_pulse_meta / emit_iter / emit_pulse — so solve_template.jl has one emit site instead of scattered @printf (mirrors the emit_formulation helper from feat(contract): pre-solve formulation.toml (additive; scoped counterpart to #64) #81).
2. One canonical fixture (one sample line per type) checked in once, that both sides reference — same mechanism as the schema test fixtures.
3. Two small tests + AC6 perturbation:
   • Julia: the emit helpers reproduce exactly the fixture lines.
   • TS: run_dir_reader parses the fixture lines into the expected records.
   • Perturb the fixture → both must fail. That's what makes template↔parser format drift impossible to land green on the shared emit path.
4. Point fake-julia at the same fixtures (generate from / diff against) so the fake can't drift from the template either — all three encodings trace to one source.

Explicit non-goals / limits (so a future reader doesn't over-trust it)

• Format drift only, not semantic drift. A row-major↔column-major flip in a=, or a dt unit change, still parses — green — but means something different. A format roundtrip cannot catch that.
• "Impossible to land green" holds only for emit that goes through the shared helper. A new inline @printf in the template bypasses the guard (same residual as hand-writing TOML instead of using the schema writer).
• Optional slow-tier canary (one real tiny Julia solve, nightly/on-demand) is the only thing that exercises genuine end-to-end emit — but it earns its Julia cost only if it asserts parsed pulse values, not liveness. A canary that checks "ran + FINISHED" catches nothing the format roundtrip doesn't. Specify golden-value assertions or skip it.

Sequencing & placement

• Land with the 1.3 grammar rework, not now. The grammar is prototype-grade and still moving; the emit code is already open during that rework, and the format is closer to freezing then. Hardening a moving target now buys change-friction on every prototype iteration.
• Separate, single-concern issue — not folded into 1.4b — CI gates: run smoke corpus + inspector-contract checks on PR #62. 1.4b — CI gates: run smoke corpus + inspector-contract checks on PR #62 gates frozen contracts + CI plumbing; extracting shared Julia emit helpers is a producer refactor. 1.4b — CI gates: run smoke corpus + inspector-contract checks on PR #62 should reference this, not absorb it.

Relationship

Same species as #81 (formulation.toml additive contract) and the readTerminal/ingestRunDir duplication caught in #70 review: parallel copies of one truth drift. The repo already knows the cure (SchemaPackage + fixture roundtrip); this applies it to the last uncovered piece of the run-dir contract.

Surfaced by the #78 smoke-corpus review (finding #1).

[jack-champagne]

Re-scope after the #81 + #72 reviews — three adjustments:

1. Strike the "1.3 grammar rework" landing target. 1.3 (#58 / #72) is the RunInspector → multi-run webview-protocol rework — a different boundary than this issue's solver↔host stdout grammar. There is no tracked "AMICODE_* grammar rework." The concrete trigger already exists in #81: the shared AmicoRunDir.jl package lands "when #75/#76 add a second real template" — the only share mechanism that survives the single-file template copy (#81 documents this and now guards it with template_deploy_contract.test.ts). Anchor to that, not to 1.3.

2. Unbundle test from refactor. The test (canonical fixture + Julia emit test + TS parse test + AC6 perturbation) is cheap and needs only a thin format-fn extraction — no package. It can land when #78 makes fake-julia the third grammar copy, which is when the "green suite while real solves break" hazard actually appears. Only the multi-template refactor (the package + adoption) waits for the second emitter. Splitting these is what lets the guard land near the hazard instead of being blocked behind a refactor that isn't justified yet.

3. The table is missing a boundary. It lists stdout as the last unguarded producer↔consumer seam, but the run-dir files ↔ N extension readers (ingestRunDir / onFinished / completeRun / hydrateFromRunDir) are an unguarded consumer fan-out that #70 and #81 keep tripping. Tracked separately in #84 to keep this issue single-concern (stdout).