baldart 5.2.0 → 5.3.0

package/CHANGELOG.md

@@ -5,6 +5,84 @@ All notable changes to BALDART will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.3.0] - 2026-07-03
+
+**Haiku banned fleet-wide + FEAT-0067 post-mortem fixes.** The FEAT-0067 audit
+(mayo, session `a8b6bc75`) found a haiku `general-purpose` commit agent running
+its first git command with `cd <worktree> &&` and its SECOND without — so the
+card-DONE bookkeeping commit executed in the MAIN checkout and landed on the
+trunk mid-run (`13aa63b62`), forking `ssot-registry.md`, raising a merge
+BLOCKER (a 5.3M-token repair), and blocking epic closure. Second haiku-class
+failure after the v4.42.0 worktree-setup fabrication → the plumbing carve-out
+is revoked.
+
+- **Model policy — haiku eliminated, sonnet is the floor** (`REGISTRY.md`
+  § Rules rewritten): no named specialist AND no `general-purpose` plumbing may
+  use haiku. Replaced in every spawn site: `new2.js` (`commit:`,
+  `integrate:commit`, `rollback:`, `review:*:codex` driver),
+  `new-final-review.js` + `new-card-review.js` (`codex-preflight`), and the
+  `seo-analytics-strategist` agent (→ sonnet, v1.1.0). Where an op is truly
+  deterministic the fix stays a script (`setup-worktree.sh`,
+  `revert-files.sh`), not a cheaper model.
+- **`new2.js` commit agents — cwd HARD RULE + placement verify**: every shell
+  command must be prefixed `cd <worktree> &&` in the same Bash invocation (the
+  cwd resets between calls), and the per-card commit agent now verifies the
+  returned sha equals `git -C <worktree> log -1 --format=%H`, reporting
+  `committed:false` with the stray sha instead of silently corrupting the
+  trunk.
+- **`new2.js` Phase-1 retriever — schema + drift false-positive fix**: the
+  prompt now states the exact required StructuredOutput shape (`ok` REQUIRED —
+  the FEAT-0067 run burned 5+3 schema-validation retries), and `missingPaths`
+  excludes paths the card itself CREATES (new migrations/tests were flagged as
+  drift and disproved downstream).
+- **`scripts/new-session-audit.mjs` — workflow-hosted agents counted**: the
+  analyzer now traverses `subagents/workflows/<wf>/agent-*.jsonl`; a new2 run
+  previously reported the orchestrator alone (FEAT-0067: 3.88M reported vs
+  53.89M real — 93% of the run invisible to TOTAL, baselines, and telemetry).
+
+Codex parity: portable / N/A — the three workflows are Claude-only by design
+(documented gap with inline fallback); the agent `model:` field is omitted in
+the Codex TOML transpile, so the model-policy change is Claude-side only; the
+audit script is maintainer tooling, not payload.
+
+## [5.2.1] - 2026-07-03
+
+**`/mw` local-trunk sync robustness.** The worktree merge's local-trunk sync
+(step 4c "Common", both `pr` and `local-push` strategies) failed to
+fast-forward on the majority of real checkouts, needlessly leaving
+`SYNC-DEFERRED` / `SYNC-NEEDS-DECISION`. Two targeted fixes, kept single-sourced
+across the executed SSOT (`framework/.claude/skills/worktree-manager/scripts/merge-worktree.sh`)
+and the prose (`worktree-manager/SKILL.md` step 4c) — **without `git stash`**,
+which stays forbidden here because `refs/stash` is shared across all worktrees
+via `git.commondir` (the FEAT-0522 incident): a stash from the main checkout can
+pop into the wrong worktree, and two parallel `/mw` runs race on the shared
+stash list.
+
+- **Fix 1 — safe ref-advance when main is on another branch.** Previously, if
+  the main repo's HEAD was not on `$TRUNK`, sync did a fetch-only and always
+  emitted `SYNC-DEFERRED`, never advancing the local `$TRUNK` ref. Now it
+  fast-forwards `refs/heads/$TRUNK` via a ref-only, ff-only fetch
+  (`git fetch origin $TRUNK:$TRUNK`) that **never touches any working tree** and
+  never checks out — turning a large class of deferrals into a clean sync
+  (`sync_marker: none`). If `$TRUNK` is checked out in another worktree, git
+  refuses and it falls back to fetch-only + defer.
+- **Fix 2 — accurate ff-fail disambiguation.** When the ff failed with a
+  tracked-clean tree and no owned/foreign dirt, the code fell to a misleading
+  "clean (diverged?)" marker (the dirty scan uses `--untracked-files=no`, so an
+  untracked-file collision was invisible to it). Now it disambiguates via
+  `merge-base --is-ancestor` between a **genuine branch divergence** (needs a
+  rebase/merge decision) and an **untracked-file collision** (the blocking files
+  are enumerated), emitting the correct actionable marker.
+
+Behaviour is strictly safer: cases #2 (foreign uncommitted work) and #3 (real
+divergence) still defer to ONE explicit user gate — never auto-committed, never
+stashed — which is the correct behaviour on a shared checkout.
+
+**Codex parity: portable.** The change is pure git plumbing inside the
+dual-runtime `merge-worktree.sh` (executed identically under Claude and Codex)
+plus its prose twin; no runtime-specific mechanic, no config key. The
+schema-change propagation rule does not apply (no `baldart.config.yml` key).
+
 ## [5.2.0] - 2026-07-03
 
 **The local design studio.** `/ui-design` is refounded from the root as the

package/VERSION

@@ -1 +1 @@
-5.2.0
+5.3.0

package/framework/.claude/agents/CHANGELOG.md

@@ -7,6 +7,14 @@ per-item agent merge, the doctor probes, and the discovery hooks — like
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · per-agent SemVer.
 
+## [seo-analytics-strategist v1.1.0] — 2026-07-03 (framework v5.3.0)
+
+- `model: haiku` → `model: sonnet` — haiku is banned fleet-wide (REGISTRY
+  § Rules, v5.3.0): the FEAT-0067 post-mortem showed a haiku plumbing agent
+  dropping the `cd <worktree>` invariant between two consecutive git commands
+  and committing to the main checkout's trunk. No named agent may run below
+  the sonnet floor. `version:` frontmatter added (was pre-v5.0 style).
+
 ## [ui-expert v2.1.0] — 2026-07-03 (framework v5.2.0)
 
 The `/ui-design` v2.0.0 studio refactor. No H2 moved; edits are within

package/framework/.claude/agents/REGISTRY.md

@@ -210,9 +210,9 @@ Use this table when spawning agents via the `Task` tool. The `model` field in ea
 | **hybrid-ml-architect** | opus | — (always opus) | ML architecture is complex by nature |
 | **senior-researcher** | sonnet | opus at orchestrator's discretion for `PROFILE=deep` surveys | Web-native retrieval + synthesis — sonnet is sufficient and fast; depth comes from the profile loop (`DEPTH=`), not the model |
 
-**Rules**: Never use haiku for any **named specialist agent** in the matrix above. Opus for code writing and creative/complex work. Sonnet for analysis, review, and documentation. `qa-sentinel` stays on sonnet even though it is a mechanical gate runner — its failure interpretation and SCOPED-vs-FULL tiering benefit from sonnet.
+**Rules**: **Haiku is BANNED fleet-wide** — never for the named specialist agents in the matrix above, and never for `general-purpose` plumbing either (see below). Opus for code writing and creative/complex work. **Sonnet is the floor** for everything else: analysis, review, documentation, AND mechanical plumbing. `qa-sentinel` stays on sonnet even though it is a mechanical gate runner — its failure interpretation and SCOPED-vs-FULL tiering benefit from sonnet.
 
-**Plumbing carve-out (haiku allowed):** the "never haiku" rule above governs the specialist agents. **Mechanical plumbing spawned as `general-purpose`** — with no reasoning and an explicit ROLE BOUNDARY — MAY use `model: "haiku"` via override. One sanctioned use today, in `/new`: the **file-scoped revert agent** that restores unauthorized files to their pre-commit state (`references/implement.md` Phase 2.4) — a deterministic git/file op, never code authoring. (The background **worktree-setup** subagent — `references/setup.md` §4b — was haiku through v4.41.0 but moved to **`model: "sonnet"`** in v4.42.0: it runs the multi-step `/nw` skill **via the Skill tool**, a sustained tool-execution chain a too-weak model fabricates rather than executes — the observed 2/2 `baseline: pass`-with-no-worktree failures. Its return is verified by the orchestrator's disk gate regardless, so a capable model is the right trade.)
+**Plumbing carve-out ABOLISHED (v5.3.0):** through v5.2.0 mechanical `general-purpose` plumbing MAY have used `model: "haiku"` via override. That carve-out is **revoked** after two independent haiku failures on "trivially mechanical" ops: (1) the worktree-setup fabrication (2/2 `baseline: pass` with nothing on disk — v4.42.0, moved to sonnet); (2) the FEAT-0067 commit corruption — the haiku commit agent ran its first git command with `cd <worktree> &&` and its SECOND without, so a card-DONE bookkeeping commit executed in the MAIN checkout and landed on the trunk mid-run, forking `ssot-registry.md`, triggering a merge BLOCKER, and blocking epic closure. The lesson generalizes: multi-step shell plumbing is a sustained tool-execution chain, and a too-weak model drops invariants (cwd, ROLE BOUNDARY, staging scope) between steps. Where the op is truly deterministic, the fix is a **script, not a cheaper model** (`setup-worktree.sh`, `revert-files.sh`); where a model stays in the loop, the floor is `sonnet`.
 
 ## Notes
 

package/framework/.claude/agents/seo-analytics-strategist.md

@@ -1,7 +1,8 @@
 ---
 name: seo-analytics-strategist
 description: "Use this agent when you need to define SEO strategy, metadata requirements, analytics event plans, or technical SEO specifications for a company website. This agent produces actionable requirements documents that coder agents can implement directly.\n\nExamples:\n\n<example>\nContext: User is building a new company website and needs SEO foundations.\nuser: \"We're launching our company website next month and need to make sure it's discoverable on Google.\"\nassistant: \"I'll use the SEO & Analytics Strategist agent to create a comprehensive SEO and analytics plan for your website launch.\"\n<Task tool invocation to launch seo-analytics-strategist agent>\n</example>\n\n<example>\nContext: User wants to add analytics tracking to existing pages.\nuser: \"We need to track user interactions on our website - button clicks, form submissions, that kind of thing.\"\nassistant: \"Let me invoke the SEO & Analytics Strategist agent to design a complete GA4/GTM event tracking plan with exact specifications for implementation.\"\n<Task tool invocation to launch seo-analytics-strategist agent>\n</example>\n\n<example>\nContext: User mentions search rankings or organic traffic concerns.\nuser: \"Our competitors are ranking higher than us for industry keywords. What should we do?\"\nassistant: \"I'll use the SEO & Analytics Strategist agent to develop a keyword and intent map along with a metadata strategy to improve your search visibility.\"\n<Task tool invocation to launch seo-analytics-strategist agent>\n</example>\n\n<example>\nContext: Developer needs SEO requirements before implementing pages.\nuser: \"I'm about to code the new services pages. What SEO elements do I need to include?\"\nassistant: \"Let me launch the SEO & Analytics Strategist agent to provide you with exact SEO requirements including metadata, schema markup, and internal linking specifications that you can implement directly.\"\n<Task tool invocation to launch seo-analytics-strategist agent>\n</example>"
-model: haiku
+version: 1.1.0
+model: sonnet
 color: pink
 ---
 

package/framework/.claude/skills/worktree-manager/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 Formato: [Keep a Changelog](https://keepachangelog.com/) · [SemVer](https://semver.org/).
 
+## 1.1.0 — 2026-07-03
+
+### Fixed — local-trunk sync robustness (step 4c "Common", both strategies)
+
+Il sync del trunk locale falliva l'ff nella maggior parte dei checkout reali,
+lasciando `SYNC-DEFERRED` / `SYNC-NEEDS-DECISION` inutilmente. Due fix mirati,
+**senza `git stash`** (vietato — `refs/stash` è condiviso tra worktree, incidente
+FEAT-0522). SSOT script `scripts/merge-worktree.sh` + prose SKILL.md tenuti in sync.
+
+- **Fix 1** — quando il main è su un branch ≠ `$TRUNK`, avanza il *ref* locale
+  `refs/heads/$TRUNK` con un fetch ref-only ff-only (`git fetch origin $TRUNK:$TRUNK`),
+  **senza toccare il working tree** e senza checkout. Converte una grossa fetta di
+  `SYNC-DEFERRED` in sync pulito (`sync_marker: none`). Se `$TRUNK` è checked out in
+  un altro worktree git rifiuta → fallback al fetch-only + defer.
+- **Fix 2** — quando l'ff fallisce con tree tracked-clean e nessun file owned/foreign,
+  disambigua via `merge-base --is-ancestor` tra **divergenza reale** del branch (serve
+  rebase/merge) e **collisione con file untracked** (elencati) — prima riportava sempre
+  il fuorviante "clean (diverged?)" (lo scan usa `--untracked-files=no`).
+
 ## 1.0.0 — 2026-07-01
 
 - Baseline: versioning per-skill introdotto al framework v4.82.0.

package/framework/.claude/skills/worktree-manager/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: worktree-manager
 effort: medium
-version: 1.0.0
+version: 1.1.0
 description: >
   Manage fully independent git worktrees for parallel coding agents.
   Commands: /nw (new worktree) creates an isolated workspace with its own
@@ -1168,16 +1168,37 @@ if [ "$CURRENT_BRANCH" = "$TRUNK" ]; then
         echo "[SYNC-NEEDS-DECISION] framework-managed reconcile rebase conflict on $TRUNK — orchestrator MUST raise ONE explicit user gate."
       fi
     else
-      echo "[SYNC-NEEDS-DECISION] main repo $TRUNK cannot fast-forward and the working tree is clean (diverged?) — orchestrator MUST raise ONE explicit user gate."
+      # Fix 2 — tracked tree clean, nothing owned/foreign dirty, yet ff failed.
+      # Disambiguate a genuine branch divergence from an untracked-file collision the
+      # incoming ff would overwrite (origin/$TRUNK is current — the pull fetched it).
+      # NEVER stash to clear it (refs/stash is shared across worktrees — FEAT-0522).
+      if git -C "$MAIN" merge-base --is-ancestor "$TRUNK" "origin/$TRUNK" 2>/dev/null; then
+        COLLIDE=""
+        for f in $(git -C "$MAIN" ls-files --others --exclude-standard); do
+          git -C "$MAIN" cat-file -e "origin/$TRUNK:$f" 2>/dev/null && COLLIDE="$COLLIDE $f"
+        done
+        echo "[SYNC-NEEDS-DECISION] main repo $TRUNK is fast-forwardable but untracked file(s) block the merge:${COLLIDE:- (unknown)} — orchestrator MUST raise ONE explicit user gate."
+      else
+        echo "[SYNC-NEEDS-DECISION] main repo $TRUNK has diverged from origin/$TRUNK (local commits not on origin) — needs a rebase/merge decision; orchestrator MUST raise ONE explicit user gate."
+      fi
     fi
   fi
 else
-  echo "ℹ️ Main repo HEAD is '$CURRENT_BRANCH' — not switching. Next manual \`git pull\` on $TRUNK will sync."
-  git -C "$MAIN" fetch origin "$TRUNK" --quiet
-  # Structured marker for upstream orchestrators (e.g. /new Phase 6c).
-  # `/mw` standalone keeps fetch-only behavior (terminal isolation); orchestrators
-  # parse this marker and route reconciliation through an explicit user gate.
-  echo "[SYNC-DEFERRED] main repo HEAD=${CURRENT_BRANCH}, local $TRUNK not fast-forwarded — orchestrator workspace-hygiene phase must reconcile."
+  # Fix 1 — main is on another branch: do NOT checkout $TRUNK. Fast-forward the local
+  # $TRUNK *ref* without touching any working tree via a ref-only, ff-only fetch.
+  # `git fetch origin $TRUNK:$TRUNK` advances refs/heads/$TRUNK only on a fast-forward
+  # and fails cleanly otherwise (never a checkout, never a stash). If $TRUNK is checked
+  # out in another worktree git refuses → we fall back to fetch-only + defer.
+  if git -C "$MAIN" fetch origin "$TRUNK:$TRUNK" --quiet 2>/dev/null; then
+    echo "✅ Local $TRUNK ref fast-forwarded to origin/$TRUNK (main HEAD='$CURRENT_BRANCH' untouched)."
+  else
+    echo "ℹ️ Main repo HEAD is '$CURRENT_BRANCH' — not switching. Next manual \`git pull\` on $TRUNK will sync."
+    git -C "$MAIN" fetch origin "$TRUNK" --quiet
+    # Structured marker for upstream orchestrators (e.g. /new Phase 6c).
+    # `/mw` standalone keeps fetch-only behavior (terminal isolation); orchestrators
+    # parse this marker and route reconciliation through an explicit user gate.
+    echo "[SYNC-DEFERRED] main repo HEAD=${CURRENT_BRANCH}, local $TRUNK not fast-forwarded (diverged or checked out elsewhere) — orchestrator workspace-hygiene phase must reconcile."
+  fi
 fi
 ```
 

package/framework/.claude/skills/worktree-manager/scripts/merge-worktree.sh

@@ -492,12 +492,34 @@ if [ "$CURRENT_BRANCH" = "$TRUNK" ]; then
         M_SYNCMARK="SYNC-NEEDS-DECISION"; M_SYNCDETAIL="framework-managed reconcile rebase conflict on $TRUNK"
       fi
     else
-      M_SYNCMARK="SYNC-NEEDS-DECISION"; M_SYNCDETAIL="main repo $TRUNK cannot fast-forward and the working tree is clean (diverged?)"
+      # Fix 2 — tracked tree clean, nothing owned/foreign dirty, yet ff failed.
+      # Disambiguate a genuine branch divergence from an untracked-file collision
+      # the incoming ff would overwrite (origin/$TRUNK is current — pull fetched it).
+      # NEVER stash to clear it (refs/stash is shared across worktrees — FEAT-0522).
+      if git -C "$MAIN" merge-base --is-ancestor "$TRUNK" "origin/$TRUNK" 2>/dev/null; then
+        COLLIDE=""
+        for f in $(git -C "$MAIN" ls-files --others --exclude-standard 2>/dev/null); do
+          git -C "$MAIN" cat-file -e "origin/$TRUNK:$f" 2>/dev/null && COLLIDE="$COLLIDE $f"
+        done
+        M_SYNCMARK="SYNC-NEEDS-DECISION"; M_SYNCDETAIL="main repo $TRUNK is fast-forwardable but untracked file(s) block the merge:${COLLIDE:- (unknown)} — orchestrator MUST raise ONE explicit user gate"
+      else
+        M_SYNCMARK="SYNC-NEEDS-DECISION"; M_SYNCDETAIL="main repo $TRUNK has diverged from origin/$TRUNK (local commits not on origin) — needs a rebase/merge decision, orchestrator MUST raise ONE explicit user gate"
+      fi
     fi
   fi
 else
-  git -C "$MAIN" fetch origin "$TRUNK" --quiet 2>>"$LOG" || true
-  M_SYNCMARK="SYNC-DEFERRED"; M_SYNCDETAIL="main repo HEAD=${CURRENT_BRANCH}, local $TRUNK not fast-forwarded"
+  # Fix 1 — main is on another branch: do NOT checkout $TRUNK. Fast-forward the local
+  # $TRUNK *ref* (refs/heads/$TRUNK) WITHOUT touching any working tree via a ref-only,
+  # ff-only fetch. `git fetch origin $TRUNK:$TRUNK` advances the local branch ref only
+  # on a fast-forward and fails cleanly (non-destructive) otherwise — never a checkout,
+  # never a stash. If $TRUNK is checked out in another worktree git refuses and we fall
+  # back to the deferred fetch below.
+  if git -C "$MAIN" fetch origin "$TRUNK:$TRUNK" --quiet 2>>"$LOG"; then
+    M_SYNCMARK="none"; M_SYNCDETAIL="local $TRUNK ref fast-forwarded to origin (main HEAD=${CURRENT_BRANCH}, working tree untouched)"
+  else
+    git -C "$MAIN" fetch origin "$TRUNK" --quiet 2>>"$LOG" || true
+    M_SYNCMARK="SYNC-DEFERRED"; M_SYNCDETAIL="main repo HEAD=${CURRENT_BRANCH}, local $TRUNK not fast-forwarded (diverged or checked out elsewhere)"
+  fi
 fi
 
 # 7. Cleanup worktree + registry (only after a verified land). Individual cmds.

package/framework/.claude/workflows/new-card-review.js

@@ -321,7 +321,7 @@ if (typeof a.codexScriptPath === 'string' && /codex-companion\.mjs$/.test(a.code
       `Resolve the Codex companion script path. Run EXACTLY this one Bash command and nothing else:\n` +
         "  ls -d ~/.claude/plugins/marketplaces/openai-codex/plugins/codex/scripts/codex-companion.mjs ~/.claude/plugins/cache/openai-codex/codex/*/scripts/codex-companion.mjs 2>/dev/null | sort -V | tail -1\n" +
         `Return codexScriptPath = the trimmed stdout (a single absolute path), or "" if the command printed nothing. Do NOT run Codex, do NOT read any other file, do NOT reason about availability — just report the command's stdout.`,
-      { label: 'codex-preflight', phase: 'Discovery', model: 'haiku', schema: PREFLIGHT_SCHEMA }
+      { label: 'codex-preflight', phase: 'Discovery', model: 'sonnet', schema: PREFLIGHT_SCHEMA }
     )
     codexScriptPath = (pf && typeof pf.codexScriptPath === 'string') ? pf.codexScriptPath.trim() : ''
   } catch (_) { codexScriptPath = '' }

package/framework/.claude/workflows/new-final-review.js

@@ -302,7 +302,7 @@ if (typeof a.codexScriptPath === 'string' && /codex-companion\.mjs$/.test(a.code
       `Resolve the Codex companion script path. Run EXACTLY this one Bash command and nothing else:\n` +
         "  ls -d ~/.claude/plugins/marketplaces/openai-codex/plugins/codex/scripts/codex-companion.mjs ~/.claude/plugins/cache/openai-codex/codex/*/scripts/codex-companion.mjs 2>/dev/null | sort -V | tail -1\n" +
         `Return codexScriptPath = the trimmed stdout (a single absolute path), or "" if the command printed nothing. Do NOT run Codex, do NOT read any other file, do NOT reason about availability — just report the command's stdout.`,
-      { label: 'codex-preflight', phase: 'Review', model: 'haiku', schema: PREFLIGHT_SCHEMA }
+      { label: 'codex-preflight', phase: 'Review', model: 'sonnet', schema: PREFLIGHT_SCHEMA }
     )
     codexScriptPath = (pf && typeof pf.codexScriptPath === 'string') ? pf.codexScriptPath.trim() : ''
   } catch (_) { codexScriptPath = '' }

package/framework/.claude/workflows/new2.js

@@ -505,7 +505,7 @@ async function rollbackCard(cardId, mayEdit) {
   try {
     const r = await agentSafe(
       `In the worktree ${sharedCtx.worktreePath}, restore the working tree to a CLEAN state for a FAILED card: \`git restore --source=HEAD --worktree --staged -- ${scope}\` then \`git clean -fd ${scope === '.' ? '' : '-- ' + scope}\` (with scope '.' this cleans the whole worktree — safe: all committed work lives in HEAD). Do NOT touch other cards' committed work. Confirm \`git status --porcelain\` is empty for the scope.`,
-      { label: `rollback:${cardId}`, phase: 'Implement', agentType: 'general-purpose', model: 'haiku',
+      { label: `rollback:${cardId}`, phase: 'Implement', agentType: 'general-purpose', model: 'sonnet',
         schema: { type: 'object', required: ['clean'], additionalProperties: true, properties: { clean: { type: 'boolean' }, note: { type: 'string' } } } }
     )
     return !!(r && r.clean)
@@ -562,7 +562,8 @@ async function runCard(cardId, cardPath) {
         // agents/analysis-profiles.md § 3 caller routing table.
         `PROFILE=${node.hasMockup ? 'ui' : 'feature'} OUTPUT=terse — resolve your analysis profile per agents/analysis-profiles.md (Grep "### PROFILE: ${node.hasMockup ? 'ui' : 'feature'}", Read only that section + its cited shared blocks).\n\n${cardBrief}\n\n` +
         `Explore the codebase exactly as your system prompt + profile mandate for this card's scope (requirements + files_likely_touched: ${JSON.stringify(node.filesLikelyTouched || [])}). Write your COMPLETE untruncated findings (file paths, type signatures, patterns, high-risk paths) to ${baselinePath} — refresh it if a stale copy exists. The owner agent and the per-card reviewers will Read that file; keep your structured return MINIMAL.\n\n` +
-        `Also report missingPaths: every path in files_likely_touched that does NOT exist in the worktree (factual ls/test check — no judgement). Return: { ok, missingPaths:[...], note }`,
+        `Also report missingPaths: every path in files_likely_touched that the card expects to ALREADY exist but does NOT exist in the worktree (factual ls/test check — no judgement). EXCLUDE paths the card itself CREATES (NEW files: migrations with placeholder timestamps, new tests, new components declared in scope) — those are not drift (FEAT-0067 false-positive class).\n\n` +
+        `Your StructuredOutput MUST be exactly this shape — the boolean property \`ok\` is REQUIRED at the top level (missing it fails schema validation and burns a retry): { "ok": true|false, "missingPaths": ["..."], "note": "..." }. ok:false ONLY if you could not explore the worktree at all.`,
       { label: `architect:${cardId}`, phase: 'Implement', agentType: 'codebase-architect',
         schema: { type: 'object', required: ['ok'], additionalProperties: true, properties: { ok: { type: 'boolean' }, missingPaths: { type: 'array', items: { type: 'string' } }, note: { type: 'string' } } } }
     )
@@ -853,11 +854,12 @@ async function runCard(cardId, cardPath) {
             `Read the Codex output ONLY through a [codex]-trace-stripping filter. **Fallback**: if it exits non-zero / prints CODEX_NOT_FOUND / stays empty, return note:'codex-unavailable' with EMPTY blocks/scopeExpansion — do NOT review yourself (role boundary); the workflow spawns the real code-reviewer.\n\n` +
             `Map Codex BLOCKER/HIGH findings to blocks:[{gate:'codex-light',domain,evidence}] (each non-empty gate AND evidence — F-014). Map legitimate findings BEYOND this card's AC to scopeExpansion:[{evidence,domain,withinOwnership,newAC}].\n\n` +
             `Return: { blocks:[...], scopeExpansion:[...], note }`,
-          // Haiku, not the inherited opus: this agent is a pure DRIVER — it runs the Codex companion
+          // Sonnet, not the inherited opus: this agent is a pure DRIVER — it runs the Codex companion
           // (node + --wait), strips [codex] traces, and maps the companion's findings into the schema.
           // The review INTELLIGENCE is Codex (a different model, run externally); driving it needs no
-          // opus reasoning, same as the other mechanical git/ops steps.
-          { label: `review:${cardId}:codex`, phase: 'Implement', agentType: 'general-purpose', model: 'haiku', schema: reviewSchema }
+          // opus reasoning. Haiku is BANNED fleet-wide since v5.3.0 (FEAT-0067 post-mortem: a haiku
+          // plumbing agent dropped the `cd` on its second git command and committed to the MAIN repo).
+          { label: `review:${cardId}:codex`, phase: 'Implement', agentType: 'general-purpose', model: 'sonnet', schema: reviewSchema }
         ).catch(onErr)
       }
       return stdReview(ra)
@@ -929,10 +931,11 @@ async function runCard(cardId, cardPath) {
   try {
     commitRes = await agentSafe(
       `Commit card ${cardId} in worktree ${sharedCtx.worktreePath}. MECHANICAL — do NOT re-read reference modules. ROLE BOUNDARY: you NEVER modify file contents except the card YAML status/note fields, the parent-epic YAML status (epic-closure gate only), and the ssot-registry entries — source/doc changes are not yours.\n` +
-        `Steps: (1) \`git status --porcelain\`; (2) stage = MAY-EDIT (${JSON.stringify(mayEdit)}) ∩ dirty — NEVER \`git add -A\`, NEVER \`git stash\`; if dirty has files OUTSIDE MAY-EDIT, do NOT stage them and set reconcileNote; (3) commit message \`[${cardId}] <concise>\`; ${doneStep} (5) 'nothing to commit' = already committed (record HEAD).\n` +
+        `HARD RULE — cwd: EVERY shell command MUST begin with \`cd ${sharedCtx.worktreePath} && \` IN THE SAME Bash invocation. The shell cwd RESETS between Bash calls to the MAIN repo: a bare \`git commit\` executes against the main checkout's current branch and corrupts it (observed in FEAT-0067 — a card-DONE commit landed on the trunk mid-run). No exceptions, including 'quick' status/log commands.\n` +
+        `Steps: (1) \`git status --porcelain\`; (2) stage = MAY-EDIT (${JSON.stringify(mayEdit)}) ∩ dirty — NEVER \`git add -A\`, NEVER \`git stash\`; if dirty has files OUTSIDE MAY-EDIT, do NOT stage them and set reconcileNote; (3) commit message \`[${cardId}] <concise>\`; ${doneStep} (5) 'nothing to commit' = already committed (record HEAD); (6) VERIFY placement: \`cd ${sharedCtx.worktreePath} && git log -1 --format=%H\` MUST equal the sha you return — if it does not, your commit landed outside the worktree: report committed:false with reconcileNote naming the stray sha, do NOT retry blindly.\n` +
         `On COMMIT_LOCK: clear stale lock + retry once. Still locked → committed:false.\n\n` +
         `Return: { committed, commit, filesChanged, reconcileNote }`,
-      { label: `commit:${cardId}`, phase: 'Implement', agentType: 'general-purpose', model: 'haiku',
+      { label: `commit:${cardId}`, phase: 'Implement', agentType: 'general-purpose', model: 'sonnet',
         schema: { type: 'object', required: ['committed'], additionalProperties: true, properties: { committed: { type: 'boolean' }, commit: { type: 'string' }, filesChanged: { type: 'array', items: { type: 'string' } }, reconcileNote: { type: 'string' } } } }
     )
   } catch (e) {
@@ -1116,10 +1119,10 @@ async function integrateCrossCard() {
   // ONE integration commit (the fixes cross card boundaries); mark fully-freed cards DONE in YAML.
   try {
     await agentSafe(
-      `Commit the cross-card integration fixes in worktree ${sharedCtx.worktreePath}. MECHANICAL — do NOT modify source beyond what is already changed on disk. Steps:\n` +
+      `Commit the cross-card integration fixes in worktree ${sharedCtx.worktreePath}. MECHANICAL — do NOT modify source beyond what is already changed on disk. HARD RULE — cwd: EVERY shell command MUST begin with \`cd ${sharedCtx.worktreePath} && \` in the SAME Bash invocation (the shell cwd resets to the MAIN repo between calls; a bare git command corrupts the main checkout). Steps:\n` +
         `(1) \`git status --porcelain\`; (2) stage ONLY dirty files within the batch union ${JSON.stringify(batchUnion)} — NEVER \`git add -A\`, NEVER \`git stash\`; (3) for each fully-freed card YAML [${fullyFreed.join(', ') || '(none)'}] set status to DONE and add implementation_note "cross-card integration: deferred AC resolved with batch-union ownership (new2 v4.30.0)"${SESSION_ID ? ' and set provenance.implementation_session: "' + SESSION_ID + '" (do NOT touch planning_session)' : ''}; (4) commit message \`[integrate] cross-card residual fixes${fullyFreed.length ? ' (' + fullyFreed.join(', ') + ')' : ''}\`; (5) 'nothing to commit' = the resolve already committed (record HEAD).\n` +
         `Return: { committed, commit, filesChanged }`,
-      { label: 'integrate:commit', phase: 'Integrate', agentType: 'general-purpose', model: 'haiku',
+      { label: 'integrate:commit', phase: 'Integrate', agentType: 'general-purpose', model: 'sonnet',
         schema: { type: 'object', required: ['committed'], additionalProperties: true, properties: { committed: { type: 'boolean' }, commit: { type: 'string' }, filesChanged: { type: 'array', items: { type: 'string' } } } } }
     )
   } catch (e) { if (e && e.transientExhausted) noteDegraded('outage') }
@@ -1259,7 +1262,7 @@ if (!committed.length) {
       // YAML status reconciliation + grep-based epic closure + leave-and-report hygiene gates), and
       // the correctness-critical checks (F-029 forcedDone guard, F-040 deferred guard) are enforced
       // in JS AFTER it returns — they do NOT depend on the agent's reasoning. Opus here is pure cost;
-      // haiku would be too weak for the conditional epic-closure / G19-23 divergence logic.
+      // sonnet is also the fleet-wide plumbing floor (haiku banned since v5.3.0).
       { label: 'merge', phase: 'Merge', agentType: 'general-purpose', model: 'sonnet', schema: MERGE_SCHEMA }
     )
   } catch (e) { if (e && e.transientExhausted) noteDegraded('outage'); mergeResult = null }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baldart",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Claude Agent Framework - Reusable framework for coordinating AI agents and humans in software projects",
   "bin": {
     "baldart": "./bin/baldart.js"