jeo-code 0.7.14 → 0.7.16

package/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 The README mirrors the latest 5 entries — regenerate with `bun run changelog:sync`.
 
 
+## [0.7.16] - 2026-06-25
+_Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite._
+
+### Added
+- **`jeo skills sync` installs and reconciles the bundled workflow skills into `~/.jeo/skills`.** New `syncBundledSkills(dir, { check, force })` (`src/commands/skills.ts`) reconciles the built-in `SKILLS` against a target dir — defaulting to `userSkillsDir()` (`~/.jeo/skills`, honoring `JEO_CONFIG_DIR`/`$HOME`, matching the highest-precedence flat dir in `skillDirs`). Missing skills are installed; a differing local copy is **preserved** by default (gjc `setup defaults` parity) unless `--force` overwrites it. `--check` is a pure drift report that writes nothing and sets a non-zero exit code on drift, so CI can gate on bundled-skill staleness. `--json` emits the structured `SkillSyncResult` (per-skill `status`/`action`, `drift`, `wrote`, `mode`). A new `bundledSkillFileContent` helper (`src/skills/catalog.ts`) defines the canonical on-disk bytes (raw `SKILL.md` when present, decorated render otherwise) shared by `sync` and the existing `--write` path. The `skills` command summary/usage (`src/cli/runner.ts`) and the list footer now advertise the subcommand.
+
+### Verified
+- `bun run typecheck` clean; full suite green — 1960 pass / 0 fail across 233 files — including the new `test/skills-sync.test.ts` (fresh install, idempotent re-run, `--check` drift report without writing, default-preserve vs `--force` overwrite, single-file reinstall, non-zero `--check` exit via `JEO_CONFIG_DIR`, and `--json` shape).
+
+
+## [0.7.15] - 2026-06-25
+_Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9._
+
+### Changed
+- **`src/` and `test/` reverted to the v0.7.9 tree.** Every runtime and test file is byte-identical to the `v0.7.9` tag; the post-0.7.9 test `test/mutated-files-artifacts.test.ts` is removed along with the feature it covered.
+
+### Notes
+- Release tooling (`scripts/ci-release-build-binaries.ts`, keeping the `bun-darwin-x64-baseline` target for older-CPU compatibility) and documentation history (this CHANGELOG, READMEs) are intentionally **not** rolled back, since they are not part of the user-facing runtime and reverting them would regress binary compatibility or erase the record of what was shipped.
+
 ## [0.7.14] - 2026-06-25
 _Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators._
 

package/README.ja.md

@@ -205,11 +205,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
+- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
 - **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 - **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
-- **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
-- **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -205,11 +205,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
+- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
 - **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 - **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
-- **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
-- **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -207,11 +207,11 @@ Huge thanks to [gajae-code](https://github.com/Yeachan-Heo/gajae-code) for the i
 ## Changelog
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
+- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
 - **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 - **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
-- **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
-- **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -205,11 +205,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.16]** (2026-06-25) — Bundled skills get a safe installer: `jeo skills sync` materializes the built-in workflow skills into `~/.jeo/skills`, preserving local edits by default, with a CI-friendly `--check` drift report and a `--force` overwrite.
+- **[0.7.15]** (2026-06-25) — Rollback release: the runtime source and test suite are restored to the **0.7.9** state. The intervening 0.7.10–0.7.14 runtime changes (quiet-mode/`-q`, `/resume` transcript rework, `mutatedFiles` plumbing, Ollama `num_ctx`, tmux REPL reaping, and related engine/provider/TUI edits) are reverted. Published as a new version because npm cannot re-issue an existing version number; `latest` now serves code identical to 0.7.9.
 - **[0.7.14]** (2026-06-25) — Quieter, cleaner output: a new `-q`/`--quiet` flag strips launch banners and courtesy logs, `/resume` no longer dumps walls of raw escaped JSON into scrollback, and a turn that edits files now reliably surfaces those paths to orchestrators.
 - **[0.7.9]** (2026-06-24) — Local model providers actually run, and OAuth/login hygiene: Ollama requests now carry an explicit `num_ctx` so jeo's large system prompt no longer overflows Ollama's small default window (the "ollama 모델이 안 돌아간다" blocker), LM Studio reasoning models that emit the whole reply on the reasoning channel are recovered instead of dying empty, GGUF chat templates that can't render the `tools` array are retried with native tools stripped, the OAuth success tab auto-closes with a clear hint, the effective-credential picker prefers a verified OAuth login over a stray API key, and abandoned idle `jeo` tmux REPL sessions are reaped on launch.
 - **[0.7.8]** (2026-06-24) — Long-session performance & resource hygiene: the detached memory-distill worker now always terminates itself (closing the `jeo memory-distill` orphan pileup that pinned each session's transcript in RSS), the live reasoning/output block re-wraps only its trailing window (O(tail) per frame instead of O(len²) over a long stream), the team loop stops reprinting the todo guide every iteration, and the readline caret stays aligned after an image attach.
-- **[0.7.7]** (2026-06-23) — Long-running-process hygiene & input robustness: backgrounded grandchildren (`next dev &`, daemons) are now reaped at the turn boundary via per-command process groups — closing the climbing `next-server` RSS leak — while the prompt gains recursive fuzzy `@path` search, ANSI-safe and idle-merged bracketed paste, a configurable OSC 52 clipboard cap, per-role ralplan model routing, and leaked-reasoning-tag stripping on salvaged answers.
-- **[0.7.6]** (2026-06-23) — Release & docs plumbing: the running version's release notes now travel inside the `--compile` single binary (so `/whats-new` works offline and from a global install), the in-TUI markdown table renderer stops splitting on escaped `\|` pipes, and the release pipeline gains a cross-compiled standalone-binary matrix — macOS/Linux **plus a first-class Windows x64 `.exe`** — built on one Linux runner and auto-attached to each GitHub release.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",
   "main": "src/cli.ts",

package/src/agent/engine.ts

@@ -272,11 +272,6 @@ export interface AgentLoopResult {
   doneReason?: string;
   /** Summed provider token usage across the turn's steps, when reported. */
   usage?: { inputTokens: number; outputTokens: number };
-  /** Repo-relative paths of files this turn SUCCESSFULLY wrote/edited, sorted and
-   *  de-duplicated. Lets a caller (task/team subagent, external orchestrator) collect
-   *  the run's code artifacts instead of inferring an empty change set after real edits.
-   *  Omitted when the turn mutated no file. */
-  mutatedFiles?: string[];
 }
 
 
@@ -369,14 +364,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
   let step = 1;
   const acc = { inputTokens: 0, outputTokens: 0 };
   let sawUsage = false;
-  // Repo-relative paths of files this turn successfully wrote/edited. Surfaced on the
-  // result so callers can collect the run's code artifacts rather than report an empty
-  // change set after real edits (the "finalArtifacts is empty" orchestrator failure).
-  const mutatedFiles = new Set<string>();
-  const finish = (r: AgentLoopResult): AgentLoopResult => {
-    const withArtifacts = mutatedFiles.size ? { ...r, mutatedFiles: [...mutatedFiles].sort() } : r;
-    return sawUsage ? { ...withArtifacts, usage: { ...acc } } : withArtifacts;
-  };
+  const finish = (r: AgentLoopResult): AgentLoopResult => (sawUsage ? { ...r, usage: { ...acc } } : r);
   // Salvage a spin-stop into a useful answer (C): instead of returning a bare
   // "Stopped: …" — throwing away everything found this turn — do ONE final no-tools
   // call asking the model to answer with what it already has. Mirrors the
@@ -1054,15 +1042,7 @@ export async function runAgentLoop(history: Message[], opts: AgentLoopOptions):
     for (let i = 0; i < toolCalls.length; i++) {
       if (!results[i].executed || !results[i].success) continue;
       const t = toolCalls[i].tool;
-      if (t === "write" || t === "edit") {
-        sawMutation = true;
-        // Record the actual file so the run's artifacts can be collected/returned.
-        const rawPath = toolCalls[i].arguments?.filePath ?? toolCalls[i].arguments?.path;
-        if (typeof rawPath === "string" && rawPath.trim()) {
-          const rel = path.relative(cwd, path.resolve(cwd, rawPath)) || rawPath;
-          mutatedFiles.add(rel.split(path.sep).join("/"));
-        }
-      }
+      if (t === "write" || t === "edit") sawMutation = true;
       else if (t === "bash") {
         const cmd = String(toolCalls[i].arguments?.command ?? "");
         if (isVerificationSignal(cmd, results[i].output)) sawVerification = true;

package/src/agent/task-tool.ts

@@ -207,12 +207,12 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     const trace: string[] = [];
     let lastTarget = "";
     let currentStep = 0;
-    // Round-8 (architect ref 7-Round7Workflow): track whether the subagent ran any
-    // bash so the parent can audit a "Changed Files:" claim against observed reality.
-    // The actual set of written/edited files comes from the engine result
-    // (result.mutatedFiles); bash is tracked apart because read-only bash (e.g.
-    // `bun test`) is not edit evidence, yet bash CAN mutate — so the audit can tell
-    // "no action at all" from "only bash ran".
+    // Round-8 (architect ref 7-Round7Workflow): count the subagent's SUCCESSFUL
+    // calls so the parent can audit a "Changed Files:" claim against observed
+    // reality. File-writing tools (write/edit/mkdir/delete) are tracked apart from
+    // bash: read-only bash (e.g. `bun test`) MUST NOT count as edit evidence, but
+    // bash CAN mutate, so the audit message distinguishes the two cases.
+    let fileMutations = 0;
     let bashRuns = 0;
     emit({ role: role.id, kind: "start", detail: taskText, maxSteps, model });
     const result = await runAgentLoop(history, {
@@ -236,7 +236,10 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
           }
         },
         onToolResult: (tool, success, output) => {
-          if (success && tool === "bash") bashRuns++;
+          if (success) {
+            if (tool === "write" || tool === "edit" || tool === "mkdir" || tool === "delete") fileMutations++;
+            else if (tool === "bash") bashRuns++;
+          }
           const label = lastTarget || tool;
           const summary = firstUsefulLine(output);
           const suffix = summary ? ` — ${summary}` : "";
@@ -260,24 +263,16 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
     const tokNote = result.usage ? `, ${result.usage.inputTokens + result.usage.outputTokens} tok` : "";
     const header = `[${role.title} subagent] ${complete ? "completed" : "stopped"} in ${result.steps} step(s) on ${model}${tokNote}.`;
     const body = trace.length ? `\nSteps:\n${trace.join("\n")}` : "";
-    // Collect/return the run's code artifacts: the engine reports every file the
-    // subagent actually wrote/edited, so the parent (and any orchestrator above it)
-    // gets a CONCRETE change set instead of an unverifiable "Changed Files:" prose
-    // claim. Empty list ⇒ no observed file mutation.
-    const changedFiles = result.mutatedFiles ?? [];
-    const artifactNote = changedFiles.length
-      ? `\nChanged files (${changedFiles.length}): ${changedFiles.join(", ")}`
-      : "";
     // Parent-side audit: a mutating role that "completed" without a successful file
-    // mutation (write/edit) likely changed nothing — flag the claim. bash is tracked
-    // separately: it CAN mutate, so an only-bash run downgrades to "verify
-    // independently" instead of the stronger UNVERIFIED.
-    const audit = complete && !role.readOnly && changedFiles.length === 0
+    // mutation (write/edit/mkdir/delete) likely changed nothing — flag the claim.
+    // bash is tracked separately: it CAN mutate, so an only-bash run downgrades to
+    // "verify independently" instead of the stronger UNVERIFIED.
+    const audit = complete && !role.readOnly && fileMutations === 0
       ? bashRuns === 0
         ? `\n[parent audit] No successful write/edit/bash was observed in this run — treat any "Changed Files:" claims above as UNVERIFIED.`
         : `\n[parent audit] No successful write/edit was observed (only bash ran); bash may or may not have mutated files — verify any "Changed Files:" claims above independently.`
       : "";
-    return { success: complete, output: `${header}${body}${artifactNote}\n\nResult:\n${fenceSubagentReport(detail)}${audit}` };
+    return { success: complete, output: `${header}${body}\n\nResult:\n${fenceSubagentReport(detail)}${audit}` };
   };
 
   return async (args: Record<string, any>, cwd: string): Promise<ToolResult> => {

package/src/agent/tool-output.ts

@@ -83,7 +83,7 @@ export async function spillToolResult(tool: string, output: string, cwd: string)
   await fs.mkdir(dir, { recursive: true });
   const safeTool = tool.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 32) || "tool";
   const stamp = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const rel = `.jeo/artifacts/tool-results/${stamp}-${safeTool}.txt`;
+  const rel = path.join(".jeo", "artifacts", "tool-results", `${stamp}-${safeTool}.txt`);
   await fs.writeFile(path.join(cwd, rel), output, "utf-8");
   // Retention so a long session can't grow the artifact dir without bound.
   await pruneToolArtifacts(dir);

package/src/ai/model-manager.ts

@@ -533,8 +533,7 @@ export function streamIdleMs(env?: Record<string, string | undefined>): number {
  *  built-in default. Mirrors streamIdleMs so a slow non-interactive turn (callLlm without
  *  onToken) can relax the cap via JEO_CALL_TIMEOUT_MS without a code change. */
 export function callTimeoutMs(env?: Record<string, string | undefined>): number {
-  const e = env ?? process.env;
-  const raw = jeoEnv("CALL_TIMEOUT_MS", e) ?? e["ANTHROPIC_TIMEOUT"];
+  const raw = jeoEnv("CALL_TIMEOUT_MS", env);
   const n = raw !== undefined ? parseInt(raw, 10) : NaN;
   return Number.isFinite(n) && n > 0 ? n : DEFAULT_CALL_TIMEOUT_MS;
 }

package/src/ai/providers/anthropic.ts

@@ -135,7 +135,7 @@ function anthropicThinkingMode(model: string): AnthropicThinkingMode {
   const v = parseAnthropicVersion(model);
   if (!v) return "budget";
   if (v.major > 4 || (v.major === 4 && v.minor >= 6)) return "adaptive";
-  
+  if (v.major === 4 && v.minor === 5) return "budget-effort";
   return "budget";
 }
 
@@ -266,7 +266,7 @@ export function anthropicPayload(
       // Budget-based extended thinking. `display: "summarized"` keeps human-readable thought
       // streaming. The 4.5 (budget-effort) transport also carries an output_config effort.
       payload.thinking = { type: "enabled", budget_tokens: thinkingBudget, display: "summarized" };
-      
+      if (thinkingMode === "budget-effort") payload.output_config = { effort: anthropicAdaptiveEffort(effort) };
     }
   } else if (includeTemperature && options.temperature !== undefined) {
     payload.temperature = options.temperature;
@@ -281,7 +281,6 @@ export function anthropicPayload(
   if (stream) payload.stream = true;
   const system = anthropicSystemBlocks(systemPrompt, model, credential, payload);
   if (system) payload.system = system;
-  console.log("PAYLOAD:", JSON.stringify(payload));
   return JSON.stringify(payload);
 }
 

package/src/cli/runner.ts

@@ -103,8 +103,8 @@ export const COMMANDS: readonly CommandSpec[] = [
   },
   {
     name: "skills",
-    summary: "List bundled workflow skills (jeo skills <name> for details).",
-    usage: "skills [name]",
+    summary: "List bundled workflow skills, or sync them into ~/.jeo/skills (jeo skills <name> for details).",
+    usage: "skills [list|read <name>|sync [--check|--force] [dir]|--write [dir]] [--json]",
     loader: async () => {
       const m = await import("../commands/skills");
       return args => m.runSkillsCommand(args);
@@ -299,7 +299,6 @@ export function renderHelp(ctx: DispatchContext): string {
   lines.push("Options:");
   lines.push("  -v, --version    Show version.");
   lines.push("  -h, --help       Show help.");
-  lines.push("  -q, --quiet      Suppress startup banners and logs.");
   lines.push("      --model <id>             Use a session model for launch/one-shot.");
   lines.push("      --provider <name>        Start launch on a provider default (anthropic/openai/gemini/antigravity/ollama).");
   lines.push("      --smol|--slow|--plan     Start launch with the configured model role tier.");
@@ -321,7 +320,7 @@ export function renderCommandHelp(spec: CommandSpec, ctx: DispatchContext): stri
 const VALUE_FLAGS = new Set(["--worktree", "--model", "--provider", "--thinking", "--max-steps", "--append-system-prompt", "--skills", "--tools", "--system-prompt"]);
 const OPTIONAL_UUID_FLAGS = new Set(["--resume", "--continue", "-c"]);
 const VALUE_PREFIXES = ["--worktree=", "--model=", "--provider=", "--thinking=", "--max-steps=", "--append-system-prompt=", "--skills=", "--tools=", "--system-prompt="];
-const LAUNCH_ONLY_FLAGS = new Set(["--tmux", "--no-tui", "--no-session", "--list", "--smol", "--slow", "--plan", "-p", "--print", "-q", "--quiet", "--no-skills", "--no-tools"]);
+const LAUNCH_ONLY_FLAGS = new Set(["--tmux", "--no-tui", "--no-session", "--list", "--smol", "--slow", "--plan", "-p", "--print", "--no-skills", "--no-tools"]);
 const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 
 function flagName(arg: string): string {

package/src/commands/launch/flags.ts

@@ -20,7 +20,6 @@ export interface LaunchFlags {
   thinking?: ThinkLevel;
   errors: string[];
   print?: boolean;
-  quiet: boolean;
   appendSystemPromptRaw?: string;
   appendSystemPrompt?: string;
   noSkills: boolean;
@@ -64,7 +63,7 @@ export function fastThinkingLevelForModel(modelId: string): ThinkLevel | undefin
 }
 
 export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchFlags {
-  const flags: LaunchFlags = { list: false, resume: false, noSession: false, noTui: false, maxSteps: 0, message: "", tmux: false, errors: [], print: false, quiet: false, noSkills: false, noTools: false };
+  const flags: LaunchFlags = { list: false, resume: false, noSession: false, noTui: false, maxSteps: 0, message: "", tmux: false, errors: [], print: false, noSkills: false, noTools: false };
   const rest: string[] = [];
   const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
   for (let i = 0; i < args.length; i++) {
@@ -78,8 +77,6 @@ export function parseFlags(args: string[], cwd: string = process.cwd()): LaunchF
     } else if (a === "-p" || a === "--print") {
       flags.print = true;
       flags.noTui = true;
-    } else if (a === "-q" || a === "--quiet") {
-      flags.quiet = true;
     } else if (a === "--tmux") {
       flags.tmux = true;
     } else if (a === "--worktree") {

package/src/commands/launch.ts

@@ -309,7 +309,6 @@ export function formatResumeHint(sessionId: string): string {
 export async function runLaunchCommand(args: string[]): Promise<void> {
   let cwd = process.cwd();
   const flags = parseFlags(args, cwd);
-  const isQuiet = flags.quiet || flags.print || jeoEnv("QUIET") === "1";
   if (flags.errors.length) {
     for (const err of flags.errors) {
       console.error(`error: ${err}`);
@@ -323,7 +322,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     if (wt !== cwd) {
       process.chdir(wt);
       cwd = wt;
-      if (jeoEnv("TMUX_LAUNCHED") !== "1" && !isQuiet) console.log(`Using worktree: ${wt}`);
+      if (jeoEnv("TMUX_LAUNCHED") !== "1") console.log(`Using worktree: ${wt}`);
     }
   }
   let branch: string | undefined;
@@ -657,7 +656,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     if (flags.resume) {
       const id = flags.resumeId ?? (await latestSessionId(cwd));
       if (!id) {
-        if (!isQuiet) console.log("No session to resume. Starting a new one.");
+        console.log("No session to resume. Starting a new one.");
         sessionId = (await createSession(cwd, undefined, sessionModel)).id;
       } else {
         try {
@@ -668,9 +667,9 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
           // pinned one (flags.model/role/provider → initialSessionModel wins).
           if (!initialSessionModel && header.model) sessionModel = header.model;
           const modelNote = sessionModel ? ` · model ${sessionModel}` : "";
-          if (!isQuiet) console.log(`Resumed session ${id} (${messages.length} messages).${modelNote}`);
+          console.log(`Resumed session ${id} (${messages.length} messages).${modelNote}`);
         } catch (err) {
-          if (!isQuiet) console.log(`Could not resume ${id}: ${(err as Error).message}. Starting fresh.`);
+          console.log(`Could not resume ${id}: ${(err as Error).message}. Starting fresh.`);
           sessionId = (await createSession(cwd, undefined, sessionModel)).id;
         }
       }
@@ -1267,7 +1266,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     renderWelcome({ ...welcomeData, cols: terminalSize().cols });
   // gjc-style fresh-start clear so the banner opens atop a clean screen. TTY only,
   // never mid-turn (scrollback flood). ponytail: add an opt-out env if anyone misses their scrollback.
-  if (process.stdout.isTTY && !isQuiet) process.stdout.write(clearScreen());
+  if (process.stdout.isTTY) process.stdout.write(clearScreen());
   // Launch sweep: the forge mark's gradient loops seamlessly (default 2 full
   // cycles, JEO_WELCOME_ANIM_CYCLES overrides), ending on the static banner.
   // Truecolor TTYs only; JEO_NO_WELCOME_ANIM=1 opts out.
@@ -1277,10 +1276,8 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
     detectColorLevel(process.env, true) === ColorLevel.TrueColor &&
     jeoEnv("NO_WELCOME_ANIM") !== "1";
   const sweepCycles = Math.min(10, Math.max(1, Number(jeoEnv("WELCOME_ANIM_CYCLES")) || 2));
-  if (!isQuiet) {
-    if (sweepable) await playWelcomeSweep(welcomeData, { cycles: sweepCycles });
-    else console.log(renderWelcome(welcomeData).join("\n"));
-  }
+  if (sweepable) await playWelcomeSweep(welcomeData, { cycles: sweepCycles });
+  else console.log(renderWelcome(welcomeData).join("\n"));
 
   // Surface the "New version" banner reliably: render ONCE from the on-disk cache
   // instantly (no network wait, works offline — the common path after the first
@@ -1288,7 +1285,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // bump still shows it this launch. Both must run BEFORE the prompt is armed.
   let updateBannerShown = false;
   const showUpdateBanner = (u: { current: string; latest: string; updateAvailable: boolean } | null): void => {
-    if (updateBannerShown || !u?.updateAvailable || isQuiet) return;
+    if (updateBannerShown || !u?.updateAvailable) return;
     updateBannerShown = true;
     console.log(renderUpdateBox(u.current, u.latest).join("\n"));
   };
@@ -1297,17 +1294,15 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // First launch after a version bump: surface the bundled release notes ONCE
   // (offline, from the new package's CHANGELOG.md) and record the seen version
   // so it never repeats. Screen-safe: prints BEFORE the prompt is armed.
-  if (!isQuiet) {
-    try {
-      const whatsNew = await consumeLaunchWhatsNew({
-        cols: Math.min(100, Math.max(40, (process.stdout.columns ?? 80) - 2)),
-        unicode: supportsUnicode(),
-        color: welcomeTheme.color,
-      });
-      if (whatsNew && whatsNew.length) console.log(whatsNew.join("\n"));
-    } catch { /* release notes are a courtesy; never block launch */ }
-  }
-  if (!LaunchTui.usable(flags.noTui) && !isQuiet) console.log("(plain output)");
+  try {
+    const whatsNew = await consumeLaunchWhatsNew({
+      cols: Math.min(100, Math.max(40, (process.stdout.columns ?? 80) - 2)),
+      unicode: supportsUnicode(),
+      color: welcomeTheme.color,
+    });
+    if (whatsNew && whatsNew.length) console.log(whatsNew.join("\n"));
+  } catch { /* release notes are a courtesy; never block launch */ }
+  if (!LaunchTui.usable(flags.noTui)) console.log("(plain output)");
 
   const useTui = LaunchTui.usable(flags.noTui);
   const runSkillInvocation = async (skill: SkillDoc, intent: string, invokedAs?: string): Promise<void> => {
@@ -4430,11 +4425,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // of blocking up to 20s on a final LLM call. The child writes MEMORY.md atomically.
   if (sessionUsage.turns > 0) {
     const spawned = await spawnDetachedDistill(history, cwd, sessionModel || defaultModel);
-    if (spawned && !isQuiet) console.log(chalk.gray("(session memory distilling in background)"));
+    if (spawned) console.log(chalk.gray("(session memory distilling in background)"));
   }
   // gjc-parity resume pointer (logs/gjc-tui-study analysis Gap C): leave the exact
   // resume command in scrollback on exit, mirroring the --list handler's convention.
-  if (sessionId && !flags.noSession && !isQuiet) console.log(formatResumeHint(sessionId));
+  if (sessionId && !flags.noSession) console.log(formatResumeHint(sessionId));
   process.removeListener("SIGINT", handleCtrlC);
   process.stdin.off("data", handleCtrlCByte);
   drainPromptListeners();

package/src/commands/skills.ts

@@ -1,7 +1,109 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs } from "../skills/catalog";
+import * as os from "node:os";
+import { SKILLS, getSkillFrom, formatSkill, loadSkills, skillDirs, bundledSkillFileContent } from "../skills/catalog";
 import { getLocalJeoDir } from "../agent/state";
+import { jeoEnv } from "../util/env";
+
+/** User-level bundled-skills install dir (`~/.jeo/skills`, honoring JEO_CONFIG_DIR /
+ *  $HOME overrides) — the destination `jeo skills sync` reconciles against, matching
+ *  the highest-precedence flat dir in {@link skillDirs}. */
+export function userSkillsDir(): string {
+  const userHome = process.env.HOME || os.homedir();
+  const home = jeoEnv("CONFIG_DIR") || path.join(userHome, ".jeo");
+  return path.join(home, "skills");
+}
+
+export type SkillSyncStatus = "missing" | "up-to-date" | "differs";
+export type SkillSyncAction = "installed" | "overwritten" | "preserved" | "unchanged" | "none";
+
+export interface SkillSyncEntry {
+  name: string;
+  /** State of the on-disk file BEFORE any write this run. */
+  status: SkillSyncStatus;
+  /** What sync did (or, for --check, "none"). */
+  action: SkillSyncAction;
+  path: string;
+}
+
+export interface SkillSyncResult {
+  dir: string;
+  entries: SkillSyncEntry[];
+  /** true when any bundled skill is missing or differs from its on-disk copy. */
+  drift: boolean;
+  /** Number of files actually written this run. */
+  wrote: number;
+}
+
+/** Reconcile the bundled workflow skills against `dir` (default {@link userSkillsDir}).
+ *  Default install preserves existing local files (gjc `setup defaults` parity):
+ *  missing skills are installed, differing ones preserved unless `force`. `check`
+ *  is a pure drift report — it writes nothing. Returns a structured result so the
+ *  CLI wrapper owns all console output / exit codes. */
+export async function syncBundledSkills(
+  dir: string,
+  opts: { check?: boolean; force?: boolean } = {},
+): Promise<SkillSyncResult> {
+  const entries: SkillSyncEntry[] = [];
+  let wrote = 0;
+  if (!opts.check) await fs.mkdir(dir, { recursive: true });
+  for (const s of SKILLS) {
+    const file = path.join(dir, `${s.name}.md`);
+    const want = bundledSkillFileContent(s);
+    let have: string | null = null;
+    try { have = await fs.readFile(file, "utf-8"); } catch { /* missing */ }
+    const status: SkillSyncStatus = have === null ? "missing" : have === want ? "up-to-date" : "differs";
+    let action: SkillSyncAction = "none";
+    if (!opts.check) {
+      if (status === "missing") {
+        await fs.writeFile(file, want, "utf-8");
+        action = "installed";
+        wrote++;
+      } else if (status === "differs") {
+        if (opts.force) {
+          await fs.writeFile(file, want, "utf-8");
+          action = "overwritten";
+          wrote++;
+        } else {
+          action = "preserved";
+        }
+      } else {
+        action = "unchanged";
+      }
+    }
+    entries.push({ name: s.name, status, action, path: file });
+  }
+  return { dir, entries, drift: entries.some(e => e.status !== "up-to-date"), wrote };
+}
+
+async function runSkillsSync(cleanArgs: string[], isJson: boolean, cwd: string): Promise<void> {
+  const check = cleanArgs.includes("--check");
+  const force = cleanArgs.includes("--force");
+  const dirArg = cleanArgs.slice(1).find(a => !a.startsWith("--"));
+  const dir = dirArg ? path.resolve(cwd, dirArg) : userSkillsDir();
+  const result = await syncBundledSkills(dir, { check, force });
+
+  if (isJson) {
+    console.log(JSON.stringify({ ...result, mode: check ? "check" : force ? "force" : "install" }, null, 2));
+  } else if (check) {
+    console.log(`\n=== jeo skills sync --check ===\nTarget: ${dir}\n`);
+    for (const e of result.entries) console.log(`  ${e.status.padEnd(11)} ${e.name}`);
+    console.log(
+      result.drift
+        ? `\nDrift detected. Run 'jeo skills sync' to install missing skills, or '--force' to overwrite differing local copies.`
+        : `\nAll ${result.entries.length} bundled skills are in sync.`,
+    );
+  } else {
+    console.log(`\n=== jeo skills sync ===\nTarget: ${dir}\n`);
+    for (const e of result.entries) console.log(`  ${e.action.padEnd(11)} ${e.name}`);
+    const preserved = result.entries.filter(e => e.action === "preserved").length;
+    console.log(`\nWrote ${result.wrote} file(s)${preserved ? `, preserved ${preserved} local copy(ies) (use --force to overwrite)` : ""}.`);
+  }
+
+  // --check is CI-usable: non-zero exit signals drift (gjc `setup defaults --check` parity).
+  if (check && result.drift) process.exitCode = 1;
+}
+
 
 function editDistance(a: string, b: string): number {
   const m = a.length, n = b.length;
@@ -40,12 +142,20 @@ export async function runSkillsCommand(args: string[] = []): Promise<void> {
     await fs.mkdir(dir, { recursive: true });
     for (const s of SKILLS) {
       const file = path.join(dir, `${s.name}.md`);
-      await fs.writeFile(file, s.raw || `# ${s.name}\n\n${formatSkill(s)}\n`, "utf-8");
+      await fs.writeFile(file, bundledSkillFileContent(s), "utf-8");
     }
     console.log(`Wrote ${SKILLS.length} skill docs to ${dir}`);
     return;
   }
 
+  // `jeo skills sync [--check|--force] [dir]` — bundled skill inspection & safe install
+  // (gjc `setup defaults --check/--force` parity): install missing bundled skills into
+  // ~/.jeo/skills, preserve existing local copies by default, and report drift.
+  if (cleanArgs[0] === "sync") {
+    await runSkillsSync(cleanArgs, isJson, cwd);
+    return;
+  }
+
   // List/lookup over the MERGED set (bundled + ~/.jeo/skills + ~/.agents/skills + project dirs), matching the REPL /skill.
   const skills = await loadSkills(cwd);
   const command = cleanArgs[0];
@@ -60,6 +170,7 @@ export async function runSkillsCommand(args: string[] = []): Promise<void> {
         console.log(`  ${s.name.padEnd(16)} ${s.summary}`);
       }
       console.log("\nInvoke: /skill <name> [intent]  ·  $<name> [intent]  ·  skill-owned slash aliases (e.g. /speckit.plan)");
+      console.log("Install/inspect bundled defaults: 'jeo skills sync' (preserve local) · '--check' (drift report) · '--force' (overwrite local)");
       console.log("Discovery dirs (later wins on name clash; JEO_SKILLS_DIR adds more):");
       for (const d of skillDirs(cwd)) console.log(`  ${d}`);
       console.log("");

package/src/commands/team.ts

@@ -431,8 +431,8 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     // LLM summary failure does not halt team
   }
 
+  let fileMutations = 0; // round-8 parent audit: successful write/edit/mkdir/delete
   let bashRuns = 0;      // bash counted apart so read-only bash isn't edit evidence
-                        // (the actual write/edit set comes from result.mutatedFiles)
   const result = await runAgentLoop(history, {
     cwd: ctx.cwd,
     model,
@@ -458,7 +458,10 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
         }
       },
       onToolResult: (tool, ok) => {
-        if (ok && tool === "bash") bashRuns++;
+        if (ok) {
+          if (tool === "write" || tool === "edit" || tool === "mkdir" || tool === "delete") fileMutations++;
+          else if (tool === "bash") bashRuns++;
+        }
         log(formatRalphStreamEvent(ok ? "complete" : "error", `tool ${tool}`, renderOpts));
       },
       onNotice: msg => log(formatRalphStreamEvent("step", msg, renderOpts)),
@@ -483,15 +486,7 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
     return false;
   }
 
-  // Collect/return the run's code artifacts: the engine reports every file the
-  // subagent actually wrote/edited, so the task's change set is concrete instead of
-  // an unverifiable prose claim. An empty list ⇒ no observed file mutation.
-  const changedFiles = result.mutatedFiles ?? [];
-  if (changedFiles.length > 0) {
-    log(formatRalphStreamEvent("complete", `${role.title} changed ${changedFiles.length} file(s): ${changedFiles.join(", ")}`, renderOpts));
-  }
-
-  if (!role.readOnly && changedFiles.length === 0) {
+  if (!role.readOnly && fileMutations === 0) {
     // Round-8: a mutating role finished without a successful file mutation — the
     // task may be legitimately read-only, but its "Changed Files:" claim is
     // unverified. bash is tracked apart: an only-bash run MIGHT have mutated.

package/src/skills/catalog.ts

@@ -70,6 +70,13 @@ export function formatSkill(s: SkillDoc): string {
   ].filter(Boolean).join("\n");
 }
 
+/** Canonical on-disk content for a bundled skill — the exact bytes `jeo skills
+ *  --write` / `jeo skills sync` materialize into a `<name>.md` file. Prefers the
+ *  original SKILL.md text; falls back to a decorated render for skills without raw. */
+export function bundledSkillFileContent(s: SkillDoc): string {
+  return s.raw || `# ${s.name}\n\n${formatSkill(s)}\n`;
+}
+
 function compactSkillExecutionBrief(skill: SkillDoc): string {
   const aliases = skillSlashAliases(skill);
   let details = skill.details;

package/src/tui/components/transcript.ts

@@ -108,45 +108,19 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
       continue;
     }
     // assistant: a JSON tool call (compact ledger lines) or a prose/done reply.
-    // A tool-call message is a JSON object that may be preceded by a ```json fence
-    // AND/OR by model "think-aloud" prose — gpt/qwen-style replies narrate a sentence
-    // and then append the JSON tool call in the SAME message. Extract the embedded
-    // call from anywhere in the content (mirroring the engine's own extractJsonObject)
-    // instead of gating on a leading `{`: that gate classified every prose-prefixed
-    // call as plain prose and dumped the raw object — including escaped multi-line
-    // edit/write payloads — verbatim into scrollback (the "/resume reads a wall of
-    // broken escaped data" bug). The narration is kept (dimmed); the raw JSON never is.
-    const parsed = tryExtractJsonObject<{ tool?: unknown; tools?: unknown; arguments?: unknown }>(
-      m.content,
-      { preferKeys: ["tool", "tools"] },
-    );
-    const isCall = !!parsed && (typeof parsed.tool === "string" || Array.isArray(parsed.tools));
-    // The protocol allows a leading `"reasoning"` field on a tool call; surface that
-    // narration (clipped) instead of losing it, and never re-dump it as raw JSON.
-    const reasoningText = parsed && typeof (parsed as { reasoning?: unknown }).reasoning === "string"
-      ? String((parsed as { reasoning?: unknown }).reasoning).trim()
-      : "";
-    // `looksLikeToolAttempt` flags a (possibly malformed/truncated) tool call so its
-    // raw JSON is suppressed even when parsing fails — e.g. a bounced reply the model
-    // later resent. Prose narrating a call is the text BEFORE the first `{` (the start
-    // of the parsed object): a prose-prefixed call keeps its lead-in; a JSON-first or
-    // reasoning-first call has none (its narration comes from `reasoningText`).
-    const looksLikeToolAttempt = /\{\s*"tools?"\s*:/.test(m.content);
-    const firstBrace = m.content.indexOf("{");
-    const prosePrefix = firstBrace > 0
-      ? m.content.slice(0, firstBrace).replace(/```(?:json)?[ \t]*\r?\n?/i, "").trim()
-      : "";
-
-    // A reply whose content (after an optional ```json fence) STARTS with `{` is a JSON
-    // emission, not prose — even a giant malformed reasoning blob the model couldn't close.
-    const startsWithJson = m.content.trimStart().replace(/^```(?:json)?[ \t]*\r?\n?/i, "").startsWith("{");
-    // Any JSON object/tool-call emission — fenced, prose-prefixed, reasoning-prefixed,
-    // or one we could not parse into a renderable call — must never reach scrollback as
-    // raw escaped JSON (the "/resume reads a wall of broken data" report).
-    const isJsonEmission = looksLikeToolAttempt || startsWithJson;
-    const narration = prosePrefix || reasoningText;
-
-
+    // A tool-call message IS a JSON object (optionally inside a ```json fence) — so
+    // only parse when the content actually begins with `{` after stripping a leading
+    // fence. This renders fenced/decorated tool calls as cards (the "/resume shows
+    // raw JSON and breaks the TUI" bug — naive JSON.parse failed on any fence and
+    // dumped the block) while prose that merely CONTAINS tool-like JSON stays prose.
+    const stripped = m.content.trim().replace(/^```(?:json)?[ \t]*\r?\n?/i, "").trimStart();
+    const looksLikeCall = stripped.startsWith("{");
+    const parsed = looksLikeCall
+      ? tryExtractJsonObject<{ tool?: unknown; tools?: unknown; arguments?: unknown }>(
+          m.content,
+          { preferKeys: ["tool", "tools"] },
+        )
+      : null;
     const calls: { tool: string; arguments?: unknown }[] =
       parsed && typeof parsed.tool === "string"
         ? [{ tool: parsed.tool, arguments: parsed.arguments }]
@@ -156,27 +130,13 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
               .map(c => ({ tool: c.tool as string, arguments: c.arguments }))
           : [];
     const toolCalls = calls.filter(c => c.tool !== "done");
-    // A genuine tool-call turn is FOLLOWED by its `Tool [x] result` user message and the
-    // JSON is the final token; an illustrative JSON snippet quoted inside a prose reply is
-    // not, and it carries meaningful prose AFTER the object. Use both signals so a real
-    // prose-prefixed call renders as a ledger line while a sentence that merely shows
-    // `{"tool":...}` as an example stays prose.
-    const next = messages[i + 1];
-    const hasResult = next?.role === "user" && TOOL_RESULT_RE.test(next.content);
-    const lastBrace = m.content.lastIndexOf("}");
-    const trailing = lastBrace >= 0 ? m.content.slice(lastBrace + 1).trim() : "";
-    // A reply that STARTS with `{` is never illustrative prose — it is a (possibly
-    // malformed) JSON emission whose raw body must stay out of scrollback.
-    const looksIllustrative = !startsWithJson && !hasResult && trailing.length > 12 && /[A-Za-z]/.test(trailing);
-
-    if (toolCalls.length > 0 && !looksIllustrative) {
+    if (toolCalls.length > 0) {
       if (lines.length > 0 && lines[lines.length - 1] !== "") {
         lines.push("");
       }
-      // Pre-call narration (dimmed) keeps the "why" of each step without the raw JSON.
-      if (narration) for (const l of clipBody(narration, bodyCap)) lines.push(dim(l));
-      // For a batch the result is ONE user message with several blocks; parse verdicts
-      // in call order.
+      // The matching `Tool [x] result (ok|fail)` user message follows; for a batch it
+      // is ONE message with several blocks. Parse verdicts in call order.
+      const next = messages[i + 1];
       const verdicts = next?.role === "user" ? parseToolVerdicts(next.content) : [];
       toolCalls.forEach((c, ci) => {
         const v = verdicts[ci] ?? verdicts.find(x => x.tool === c.tool);
@@ -187,22 +147,14 @@ export function formatTranscript(messages: readonly Message[], opts: TranscriptO
       });
       continue;
     }
-    // No rendered tool call → a lone `done` call (reason + narration), a malformed/raw
-    // JSON or tool-call emission (show narration only — never dump the raw object), or
-    // genuine prose (which may merely quote a JSON snippet).
-    const doneCall = calls.find(c => c.tool === "done");
-    const doneReason = doneCall
-      ? String((doneCall.arguments as { reason?: unknown } | undefined)?.reason ?? "")
-      : "";
-    const reason = doneCall
-      ? [narration, doneReason].filter(s => s.trim()).join("\n\n")
-      : isJsonEmission && !looksIllustrative
-        ? narration // JSON/tool-call emission we couldn't render — keep narration, drop raw JSON
-        : m.content;
-
-
-
-
+    // No tool calls → a lone `{tool:"done", reason}` (show its reason), a JSON object
+    // that isn't a renderable call (skip — never dump raw JSON), or genuine prose.
+    const reason =
+      parsed && parsed.tool === "done"
+        ? String((parsed.arguments as { reason?: unknown } | undefined)?.reason ?? "")
+        : looksLikeCall
+          ? ""
+          : m.content;
     if (!reason.trim()) continue;
     // Persisted thinking (gjc "think → answer" order): show the turn's reasoning,
     // dimmed, above the reply so the durable record carries it across /resume + export.