jeo-code 0.7.33 → 0.7.35

package/CHANGELOG.md

@@ -6,6 +6,30 @@ 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.35] - 2026-07-04
+_`jeo team` now runs every plan step through the SAME subagent execution core as the `task`/`subagent` tools, and gains gjc-style concurrent workers: a plan can mark a contiguous run of independent steps to execute in parallel, each isolated in its own git worktree, merged back in order._
+
+### Added
+- **`parallel_group` — opt-in concurrent plan-step execution for `jeo team` (gjc `team` concurrency parity), git-worktree isolated.** `src/agent/plan.ts`'s `StepSchema` gains an optional `parallel_group: string` field; `PlanSchema` validates that steps sharing the same non-empty value are mutually CONTIGUOUS (a split group has no coherent execution position and is rejected with a clear Zod issue). `jeo team`'s executor (`runParallelGroup` in `src/commands/team.ts`) dispatches a contiguous group concurrently: each step gets its own git worktree (via the existing `resolveWorktree`, same helper `jeo launch --worktree` uses) and runs through `new SubagentRegistry()` + `runSubagentOnce()` — the identical core the `task`/`subagent` tools and the serial team path use. On full group success, each worker's committed branch is merged back into the current branch IN ARRAY ORDER (`git merge --no-ff`); any step failure OR merge conflict stops immediately, aborts any in-flight merge (`git merge --abort`, never auto-resolved), and leaves every remaining worktree/branch untouched for manual inspection. `jeo ralplan`'s plan-generation prompt now documents `parallel_group` (off by default; only for steps touching disjoint files with no cross-step dependency) so the field is reachable from the normal spec-first workflow, not just hand-authored plans.
+
+### Changed
+- **`jeo team`'s step executor now runs through the SAME execution core as the `task`/`subagent` tools instead of a second hand-rolled copy of the subagent loop.** `runSubagentOnce` (new, exported from `src/agent/task-tool.ts`) is the extracted single execution core — it builds the role's history, runs `runAgentLoop`, validates the done-reason contract, audits mutation evidence, and fences the report against prompt injection — used by `task-tool.ts`'s single/fan-out/detached paths AND `jeo team`'s `executeTaskWithAgent`/`runParallelGroup`. `SubagentRunResult` (a superset of `ToolResult` exposing the raw done reason, contract-ok flag, and mutation-audit counters) lets `jeo team` keep its own role-gate-verdict parsing (architect BLOCK / critic REQUEST CHANGES) and `--strict-mutations` policy on top without re-deriving them from formatted report text. A previously team-only LLM-summarization compaction pass (`maybeCompact`) is no longer called — team subagents now rely solely on the agent loop's own built-in context guard, the same as every other subagent, instead of a second, divergent compaction strategy.
+
+### Verified
+- `bun run typecheck` clean; full suite green (2282 tests).
+- New coverage: `test/team-parallel.test.ts` (real git operations in throwaway temp repos — no git mocking — covering a successful 2-step concurrent group merging both branches, a failing step leaving the group unmerged with the succeeding step's worktree intact, and a genuine merge conflict aborting cleanly with no partial state) plus `PlanSchema` contiguity validation cases. `test/team-run.test.ts` updated for the consolidated execution core's report formatting (contract-incomplete detail now embedded in the fenced report; the obsolete `maybeCompact`-invocation test was removed as an intentional behavior change, not a regression).
+
+## [0.7.34] - 2026-07-04
+_gajae-code 0.8.0/0.8.1 parity audit: closes a real cross-provider lone-surrogate JSON bug and makes turn-boundary compaction Esc-cancellable; the rest of gjc's 0.8.x release (Telegram daemon, ACP, cmux, coordinator MCP, tool-discovery-mode, an internal paged transcript viewport) is gjc-specific architecture jeo intentionally does not replicate, or was already-equivalent (confirmed by a 4-way parallel audit: ast_grep formatting, session-picker empty-filter clamping, PageUp/PageDown)._
+
+### Fixed
+- **A lone (unpaired) UTF-16 surrogate anywhere in tool-call arguments, tool-result output, or message content could break an outgoing provider request (gjc 0.8.1 parity).** Truncating tool output by UTF-16 code units (`tool-output.ts`/`output-util.ts`) can split an emoji's surrogate pair; the orphaned half survived `JSON.stringify` as an unpaired `\ud8xx`-style escape that strict provider JSON parsers reject (e.g. Anthropic 400 "no low surrogate in string"). New `src/util/sanitize-json.ts` (`sanitizeJsonStrings`, a `WeakMap`-guarded recursive walker applying `String.prototype.toWellFormed()` to every string value and object key, ported from gajae-code's shared sanitizer) is now applied at every provider's terminal request-body `JSON.stringify` — Anthropic, Gemini (+ Gemini CLI), OpenAI, OpenAI Responses/Codex, Antigravity, and Ollama.
+- **Turn-boundary compaction could not be cancelled with Esc/Ctrl+C (gjc 0.8.0 "Escape now reliably cancels active context maintenance" parity).** `maybeCompact`'s preflight call in `runTurn` ran before the turn's main abort harness existed, so a slow/hung compaction summarization LLM call had no cancellation path. It now runs under a short-lived abort harness (disposed in a `finally` immediately after) whose signal is threaded into `maybeCompact`, without changing when or how the main per-turn harness is created.
+
+### Verified
+- `bun run typecheck` clean; full suite green.
+- New coverage: `test/sanitize-json.test.ts` (lone high/low surrogate values, a well-formed emoji pair preserved unchanged, nested-object/array-element/object-key surrogates, reference-cycle safety, and an end-to-end Anthropic request-body round-trip); `test/compaction.test.ts` extended with a mid-flight abort case and a structural guard on the `launch.ts` call site's signal wiring.
+
 ## [0.7.33] - 2026-07-04
 _Adds `browser` — headless Chromium automation (gjc `browser` parity) — completing the gjc tool-surface parity pass started in 0.7.32._
 
@@ -41,7 +65,6 @@ _A guardrail audit of the agent loop, subagent spawn gate, and file-edit tools t
 
 ## [0.7.31] - 2026-07-03
 _Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity._
-
 ### Performance
 - **Bash tool output streaming no longer accumulates without bound.** `drainPipe` (`src/agent/tools.ts`) stops growing its buffer once it reaches the `bashTool` truncation cap and keeps only a small rolling 16KB tail for the live view afterward — a chatty long-running command no longer holds hundreds of MB in memory for the whole timeout window, and the live `onChunk` callback receives a bounded string instead of the full cumulative buffer (was making every downstream sanitize/wrap pass O(n²) over stream length).
 - **Engine stream emission is throttled (~80ms) instead of firing per token.** `onModelStream`/`onReasoningStream` in `src/agent/engine.ts` no longer re-flatten the growing response rope and re-scan it in the TUI on every streamed token; a guaranteed final flush (`flushStreams()`) delivers the complete text before parse/commit so no content is ever lost to the throttle. Per-step call-signature digests are now computed once and reused across the repeat/cycle/step-budget novelty checks instead of being re-hashed three times.

package/README.ja.md

@@ -207,11 +207,11 @@ CI は `.github/workflows/npm-publish.yml` で公開します — GitHub リリ
 ## 変更履歴 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.35]** (2026-07-04) — `jeo team` now runs every plan step through the SAME subagent execution core as the `task`/`subagent` tools, and gains gjc-style concurrent workers: a plan can mark a contiguous run of independent steps to execute in parallel, each isolated in its own git worktree, merged back in order.
+- **[0.7.34]** (2026-07-04) — gajae-code 0.8.0/0.8.1 parity audit: closes a real cross-provider lone-surrogate JSON bug and makes turn-boundary compaction Esc-cancellable; the rest of gjc's 0.8.x release (Telegram daemon, ACP, cmux, coordinator MCP, tool-discovery-mode, an internal paged transcript viewport) is gjc-specific architecture jeo intentionally does not replicate, or was already-equivalent (confirmed by a 4-way parallel audit: ast_grep formatting, session-picker empty-filter clamping, PageUp/PageDown).
 - **[0.7.33]** (2026-07-04) — Adds `browser` — headless Chromium automation (gjc `browser` parity) — completing the gjc tool-surface parity pass started in 0.7.32.
 - **[0.7.32]** (2026-07-03) — gjc tool-surface parity — ast_grep/ast_edit, lsp/lsp_rename, debug, irc, job, and goal tools — plus a `launch.ts` slash-command refactor and four agent-loop guardrail hardenings (destructive-bash denylist, spawn-gate justification quality check, done-verification abuse guard, and a blind unanchored line-range-edit guard).
 - **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
-- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
-- **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.ko.md

@@ -207,11 +207,11 @@ CI는 `.github/workflows/npm-publish.yml`로 배포합니다 — GitHub 릴리
 ## 변경 이력 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.35]** (2026-07-04) — `jeo team` now runs every plan step through the SAME subagent execution core as the `task`/`subagent` tools, and gains gjc-style concurrent workers: a plan can mark a contiguous run of independent steps to execute in parallel, each isolated in its own git worktree, merged back in order.
+- **[0.7.34]** (2026-07-04) — gajae-code 0.8.0/0.8.1 parity audit: closes a real cross-provider lone-surrogate JSON bug and makes turn-boundary compaction Esc-cancellable; the rest of gjc's 0.8.x release (Telegram daemon, ACP, cmux, coordinator MCP, tool-discovery-mode, an internal paged transcript viewport) is gjc-specific architecture jeo intentionally does not replicate, or was already-equivalent (confirmed by a 4-way parallel audit: ast_grep formatting, session-picker empty-filter clamping, PageUp/PageDown).
 - **[0.7.33]** (2026-07-04) — Adds `browser` — headless Chromium automation (gjc `browser` parity) — completing the gjc tool-surface parity pass started in 0.7.32.
 - **[0.7.32]** (2026-07-03) — gjc tool-surface parity — ast_grep/ast_edit, lsp/lsp_rename, debug, irc, job, and goal tools — plus a `launch.ts` slash-command refactor and four agent-loop guardrail hardenings (destructive-bash denylist, spawn-gate justification quality check, done-verification abuse guard, and a blind unanchored line-range-edit guard).
 - **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
-- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
-- **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.md

@@ -234,11 +234,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.35]** (2026-07-04) — `jeo team` now runs every plan step through the SAME subagent execution core as the `task`/`subagent` tools, and gains gjc-style concurrent workers: a plan can mark a contiguous run of independent steps to execute in parallel, each isolated in its own git worktree, merged back in order.
+- **[0.7.34]** (2026-07-04) — gajae-code 0.8.0/0.8.1 parity audit: closes a real cross-provider lone-surrogate JSON bug and makes turn-boundary compaction Esc-cancellable; the rest of gjc's 0.8.x release (Telegram daemon, ACP, cmux, coordinator MCP, tool-discovery-mode, an internal paged transcript viewport) is gjc-specific architecture jeo intentionally does not replicate, or was already-equivalent (confirmed by a 4-way parallel audit: ast_grep formatting, session-picker empty-filter clamping, PageUp/PageDown).
 - **[0.7.33]** (2026-07-04) — Adds `browser` — headless Chromium automation (gjc `browser` parity) — completing the gjc tool-surface parity pass started in 0.7.32.
 - **[0.7.32]** (2026-07-03) — gjc tool-surface parity — ast_grep/ast_edit, lsp/lsp_rename, debug, irc, job, and goal tools — plus a `launch.ts` slash-command refactor and four agent-loop guardrail hardenings (destructive-bash denylist, spawn-gate justification quality check, done-verification abuse guard, and a blind unanchored line-range-edit guard).
 - **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
-- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
-- **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/README.zh.md

@@ -207,11 +207,11 @@ CI 通过 `.github/workflows/npm-publish.yml` 发布 — GitHub 发布 release
 ## 更新日志 (Changelog)
 
 <!-- CHANGELOG:START (auto-generated from CHANGELOG.md — run `bun run changelog:sync`) -->
+- **[0.7.35]** (2026-07-04) — `jeo team` now runs every plan step through the SAME subagent execution core as the `task`/`subagent` tools, and gains gjc-style concurrent workers: a plan can mark a contiguous run of independent steps to execute in parallel, each isolated in its own git worktree, merged back in order.
+- **[0.7.34]** (2026-07-04) — gajae-code 0.8.0/0.8.1 parity audit: closes a real cross-provider lone-surrogate JSON bug and makes turn-boundary compaction Esc-cancellable; the rest of gjc's 0.8.x release (Telegram daemon, ACP, cmux, coordinator MCP, tool-discovery-mode, an internal paged transcript viewport) is gjc-specific architecture jeo intentionally does not replicate, or was already-equivalent (confirmed by a 4-way parallel audit: ast_grep formatting, session-picker empty-filter clamping, PageUp/PageDown).
 - **[0.7.33]** (2026-07-04) — Adds `browser` — headless Chromium automation (gjc `browser` parity) — completing the gjc tool-surface parity pass started in 0.7.32.
 - **[0.7.32]** (2026-07-03) — gjc tool-surface parity — ast_grep/ast_edit, lsp/lsp_rename, debug, irc, job, and goal tools — plus a `launch.ts` slash-command refactor and four agent-loop guardrail hardenings (destructive-bash denylist, spawn-gate justification quality check, done-verification abuse guard, and a blind unanchored line-range-edit guard).
 - **[0.7.31]** (2026-07-03) — Three-round speed & memory pass across streaming, memory retrieval, and the TUI render loop (O(n²) → O(n) in several hot paths), a deep-interview repeat-question loop guard, and gajae-code managed-tmux launch sizing parity.
-- **[0.7.30]** (2026-07-02) — GPT/Codex OAuth calls work again, and the 30-minute turn budget now limits no-progress stalls instead of killing genuinely progressing autonomous runs.
-- **[0.7.29]** (2026-07-02) — gajae-code safety-refusal retry parity: Anthropic/OAuth content-classifier refusals no longer end the turn with a fatal "declined to answer" message after the context-reset ladder.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full history.
 <!-- CHANGELOG:END -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jeo-code",
-  "version": "0.7.33",
+  "version": "0.7.35",
 
   "description": "Clean, highly optimized AI coding agent using spec-first loop",
   "type": "module",

package/src/agent/AGENTS.md

@@ -48,7 +48,7 @@ The core runtime loop, tool registry, session management, and state persistence
 | `subagent-registry.ts` | Brief description of purpose |
 | `subagent-tool.ts` | Brief description of purpose |
 | `subagents.ts` | Brief description of purpose |
-| `task-tool.ts` | Brief description of purpose |
+| `task-tool.ts` | `task` tool (single/fan-out/detached delegation) — exports `runSubagentOnce`, the single subagent execution core (history/runAgentLoop/contract validation/mutation audit/fenced report) shared with `jeo team`'s executor in `src/commands/team.ts` |
 | `todo-tool.ts` | Brief description of purpose |
 | `tokenizer.ts` | Brief description of purpose |
 | `tool-output.ts` | Brief description of purpose |

package/src/agent/plan.ts

@@ -13,6 +13,11 @@ export const StepSchema = z.object({
   name: z.string(),
   /** Optional subagent role for this step (executor/planner/architect/critic). */
   role: z.string().optional(),
+  /** Optional opt-in marker for a CONTIGUOUS run of steps `jeo team` may execute
+   *  concurrently (git-worktree isolated) instead of strictly serially. Steps
+   *  sharing the same non-empty value must be mutually consecutive — validated
+   *  on `PlanSchema` below, since contiguity is a plan-wide property. */
+  parallel_group: z.string().optional(),
 }).passthrough().superRefine((step, ctx) => {
   for (const key of UNSUPPORTED_DEP_KEYS) {
     if (key in step) {
@@ -27,7 +32,28 @@ export const StepSchema = z.object({
 export const PlanSchema = z.object({
   name: z.string().optional(),
   steps: z.array(StepSchema).min(1),
-}).passthrough();
+}).passthrough().superRefine((plan, ctx) => {
+  // `parallel_group` steps must form a CONTIGUOUS run: once a group value is
+  // seen and then interrupted by a different (or absent) group, that value must
+  // never reappear later — `jeo team` dispatches a group as one concurrent batch
+  // located at a single position in the array, so a split group has no coherent
+  // execution position.
+  const closedGroups = new Set<string>();
+  let prevGroup: string | undefined;
+  for (const step of plan.steps) {
+    const group = step.parallel_group?.trim() || undefined;
+    if (group && group !== prevGroup && closedGroups.has(group)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `plan step "${step.name}" reuses parallel_group "${group}" after a non-"${group}" step interrupted it — parallel_group steps must be contiguous.`,
+      });
+    }
+    if (prevGroup !== undefined && prevGroup !== group) {
+      closedGroups.add(prevGroup);
+    }
+    prevGroup = group;
+  }
+});
 
 /**
  * Tolerate common planning-model deviations so a valid-enough plan still executes:

package/src/agent/task-tool.ts

@@ -187,13 +187,171 @@ export function fenceSubagentReport(detail: string): string {
   ].join("\n");
 }
 
+/**
+ * Build a `task` ToolHandler bound to a config + (optional) abort signal. The
+ * handler accepts `{ role?, task | prompt | assignment, context? }`.
+ */
+export interface RunSubagentOptions {
+  /** Resolves per-role model/step/thinking overrides; `defaultModel` is the fallback. */
+  config: Pick<Config, "defaultModel" | "subagents" | "thinkingLevel">;
+  /** Forwarded to the subagent's own runAgentLoop so Ctrl-C cancels nested work too. */
+  signal?: AbortSignal;
+  /** Optional live sink (e.g. plain-stream rendering of nested progress). */
+  onEvent?: (ev: TaskSubEvent) => void;
+  /** Mid-turn steering drain — see TaskToolOptions.steer for the exact contract. */
+  steer?: () => string[];
+  /** 1-based position within a fan-out/parallel batch, for event tagging. */
+  slot?: { index: number; total: number };
+  /** Pre-loaded project context to avoid re-scanning AGENTS.md per batch item. */
+  projectContext?: Awaited<ReturnType<typeof loadProjectContext>>;
+}
+
+/** `runSubagentOnce`'s result — a superset of `ToolResult` exposing the raw
+ *  (unwrapped, unfenced) done reason and mutation-audit counters so a caller with
+ *  its OWN pass/fail policy on top (e.g. `jeo team`'s role-gate-verdict parsing and
+ *  `--strict-mutations`) doesn't have to re-derive them by parsing the formatted
+ *  report text. `task`/`subagent` tool callers only ever need `success`/`output`/
+ *  `error`, which stay structurally identical to plain `ToolResult`. */
+export interface SubagentRunResult extends ToolResult {
+  /** Raw subagent done reason, before contract validation or fencing. */
+  doneReason: string;
+  /** True when the subagent actually called `done` (vs. exhausting its step
+   *  budget or being force-stopped by an engine guard, e.g. a repeat-call loop). */
+  done: boolean;
+  /** Whether the done reason satisfied the role's required-marker contract. */
+  contractOk: boolean;
+  /** Required markers missing from the done reason, when `contractOk` is false. */
+  missingMarkers?: string[];
+  /** Successful write/edit/mkdir/delete calls observed (mutation audit evidence). */
+  fileMutations: number;
+  /** Successful bash calls observed (tracked apart — bash CAN mutate but isn't proof). */
+  bashRuns: number;
+}
+
+/**
+ * Run ONE subagent role to completion against `taskText`/`context` and format its
+ * report (fenced against prompt injection). This is the single execution core
+ * shared by the `task` tool's single/fan-out/detached paths AND `jeo team`'s plan
+ * executor (`src/commands/team.ts`) — there is exactly one way a jeo-code subagent
+ * runs, whether it was launched interactively, in a batch, detached, or as a team
+ * plan step.
+ */
+export async function runSubagentOnce(
+  role: ReturnType<typeof getSubagentRole> & {},
+  taskText: string,
+  context: string,
+  cwd: string,
+  opts: RunSubagentOptions,
+): Promise<SubagentRunResult> {
+  const { steer, slot, projectContext: preloadedContext, signal } = opts;
+  // Tag every live event with its fan-out slot so a parent monitor can tell
+  // task 1 from task 3 when several same-role subagents stream concurrently.
+  const emit = (ev: TaskSubEvent) =>
+    opts.onEvent?.(slot ? { ...ev, index: slot.index, total: slot.total } : ev);
+  const model = resolveSubagentModel(role.id, opts.config);
+  const maxSteps = resolveSubagentMaxSteps(role.id, opts.config);
+  // gjc parity: a role may pin its own reasoning budget; absent = inherit the
+  // session/global thinking level (the "(inherit)" row in the picker).
+  const thinking = resolveSubagentThinking(role.id, opts.config) ?? opts.config.thinkingLevel;
+  const projectContext = preloadedContext ?? await loadProjectContext(cwd);
+  const memorySection = await memoryPromptSection(cwd, taskText);
+  const systemBase = withProjectContext(subagentSystemPrompt(role), projectContext);
+  const history: Message[] = [
+    { role: "system", content: memorySection ? `${systemBase}\n\n${memorySection}` : systemBase },
+    { role: "user", content: `${taskText}${context}` },
+  ];
+
+  const trace: string[] = [];
+  let lastTarget = "";
+  let currentStep = 0;
+  // 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, {
+    cwd,
+    model,
+    maxSteps,
+    maxTokens: resolveMaxOutputTokens(model, thinking),
+    // Per-run prompt-cache key: the subagent replays its own growing history each
+    // step, so a stable per-run key gets provider cache hits (gjc sub-session parity).
+    sessionKey: crypto.randomUUID(),
+    // Bounded delegation: a subagent's step contract stays exact — the parent
+    // owns any retry/extension decision, so the gjc retry flow is disabled here.
+    budget: { maxExtensions: 0 },
+    signal,
+    steer,
+    tools: subagentToolset(role),
+    events: {
+      onStep: n => { currentStep = n; },
+      onAssistant: (_raw, invocation) => {
+        if (invocation && invocation.tool && invocation.tool !== "done") {
+          lastTarget = toolTarget(invocation.tool, invocation.arguments);
+          trace.push(`  step ${currentStep}/${maxSteps}: ${lastTarget}`);
+          emit({ role: role.id, kind: "step", detail: lastTarget, step: currentStep, maxSteps, model });
+        }
+      },
+      onToolResult: (tool, success, output) => {
+        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}` : "";
+        trace.push(`  ${success ? "✓" : "✗"} ${label}${suffix}`);
+        emit({ role: role.id, kind: "tool", detail: label, success, summary, step: currentStep, maxSteps, model });
+        lastTarget = "";
+      },
+      // Retry notices (rate-limit backoff etc.) surface as live "step" beats so the
+      // parent's monitor shows WHY a subagent is pausing instead of going silent.
+      onNotice: msg => emit({ role: role.id, kind: "step", detail: msg, step: currentStep, maxSteps, model }),
+      // Mid-turn steering reached this subagent: surface it as a live beat so the
+      // parent's monitor shows the redirect instead of an unexplained behavior change.
+      onSteer: text => emit({ role: role.id, kind: "step", detail: `↳ steer: ${text}`, step: currentStep, maxSteps, model }),
+    },
+  });
+  const reason = result.doneReason?.trim() || `(subagent reached the ${result.steps}-step limit without signaling done)`;
+  const validation = validateSubagentDoneReason(role, reason);
+  const complete = result.done && validation.ok;
+  const detail = validation.ok ? reason : `${reason}\n\n[contract incomplete: missing ${validation.missing?.join(", ")}]`;
+  emit({ role: role.id, kind: "done", detail, success: complete, step: result.steps, maxSteps, model, tokens: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens } : undefined });
+  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")}` : "";
+  // Parent-side audit: a mutating role that "completed" without a successful file
+  // 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}\n\nResult:\n${fenceSubagentReport(detail)}${audit}`,
+    doneReason: reason,
+    done: result.done,
+    contractOk: validation.ok,
+    missingMarkers: validation.ok ? undefined : validation.missing,
+    fileMutations,
+    bashRuns,
+  };
+}
+
 /**
  * Build a `task` ToolHandler bound to a config + (optional) abort signal. The
  * handler accepts `{ role?, task | prompt | assignment, context? }`.
  */
 export function createTaskTool(opts: TaskToolOptions): ToolHandler {
-  /** Run ONE subagent to completion and format its result (the original single-task path). */
-  const runOne = async (
+  /** Run ONE subagent via the shared execution core, binding this tool instance's
+   *  config/signal/onEvent (the original single-task path). */
+  const runOne = (
     role: ReturnType<typeof getSubagentRole> & {},
     taskText: string,
     context: string,
@@ -206,98 +364,15 @@ export function createTaskTool(opts: TaskToolOptions): ToolHandler {
        *  is cancellable independently of the parent turn. */
       signal?: AbortSignal;
     } = {},
-  ): Promise<ToolResult> => {
-    const { steer, slot, projectContext: preloadedContext, signal: signalOverride } = extra;
-    // Tag every live event with its fan-out slot so a parent monitor can tell
-    // task 1 from task 3 when several same-role subagents stream concurrently.
-    const emit = (ev: TaskSubEvent) =>
-      opts.onEvent?.(slot ? { ...ev, index: slot.index, total: slot.total } : ev);
-    const model = resolveSubagentModel(role.id, opts.config);
-    const maxSteps = resolveSubagentMaxSteps(role.id, opts.config);
-    // gjc parity: a role may pin its own reasoning budget; absent = inherit the
-    // session/global thinking level (the "(inherit)" row in the picker).
-    const thinking = resolveSubagentThinking(role.id, opts.config) ?? opts.config.thinkingLevel;
-    const projectContext = preloadedContext ?? await loadProjectContext(cwd);
-    const memorySection = await memoryPromptSection(cwd, taskText);
-    const systemBase = withProjectContext(subagentSystemPrompt(role), projectContext);
-    const history: Message[] = [
-      { role: "system", content: memorySection ? `${systemBase}\n\n${memorySection}` : systemBase },
-      { role: "user", content: `${taskText}${context}` },
-    ];
-
-    const trace: string[] = [];
-    let lastTarget = "";
-    let currentStep = 0;
-    // 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, {
-      cwd,
-      model,
-      maxSteps,
-      maxTokens: resolveMaxOutputTokens(model, thinking),
-      // Per-run prompt-cache key: the subagent replays its own growing history each
-      // step, so a stable per-run key gets provider cache hits (gjc sub-session parity).
-      sessionKey: crypto.randomUUID(),
-      // Bounded delegation: a subagent's step contract stays exact — the parent
-      // owns any retry/extension decision, so the gjc retry flow is disabled here.
-      budget: { maxExtensions: 0 },
-      signal: signalOverride ?? opts.signal,
-      steer,
-      tools: subagentToolset(role),
-      events: {
-        onStep: n => { currentStep = n; },
-        onAssistant: (_raw, invocation) => {
-          if (invocation && invocation.tool && invocation.tool !== "done") {
-            lastTarget = toolTarget(invocation.tool, invocation.arguments);
-            trace.push(`  step ${currentStep}/${maxSteps}: ${lastTarget}`);
-            emit({ role: role.id, kind: "step", detail: lastTarget, step: currentStep, maxSteps, model });
-          }
-        },
-        onToolResult: (tool, success, output) => {
-          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}` : "";
-          trace.push(`  ${success ? "✓" : "✗"} ${label}${suffix}`);
-          emit({ role: role.id, kind: "tool", detail: label, success, summary, step: currentStep, maxSteps, model });
-          lastTarget = "";
-        },
-        // Retry notices (rate-limit backoff etc.) surface as live "step" beats so the
-        // parent's monitor shows WHY a subagent is pausing instead of going silent.
-        onNotice: msg => emit({ role: role.id, kind: "step", detail: msg, step: currentStep, maxSteps, model }),
-        // Mid-turn steering reached this subagent: surface it as a live beat so the
-        // parent's monitor shows the redirect instead of an unexplained behavior change.
-        onSteer: text => emit({ role: role.id, kind: "step", detail: `↳ steer: ${text}`, step: currentStep, maxSteps, model }),
-      },
+  ): Promise<ToolResult> =>
+    runSubagentOnce(role, taskText, context, cwd, {
+      config: opts.config,
+      signal: extra.signal ?? opts.signal,
+      onEvent: opts.onEvent,
+      steer: extra.steer,
+      slot: extra.slot,
+      projectContext: extra.projectContext,
     });
-    const reason = result.doneReason?.trim() || `(subagent reached the ${result.steps}-step limit without signaling done)`;
-    const validation = validateSubagentDoneReason(role, reason);
-    const complete = result.done && validation.ok;
-    const detail = validation.ok ? reason : `${reason}\n\n[contract incomplete: missing ${validation.missing?.join(", ")}]`;
-    emit({ role: role.id, kind: "done", detail, success: complete, step: result.steps, maxSteps, model, tokens: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens } : undefined });
-    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")}` : "";
-    // Parent-side audit: a mutating role that "completed" without a successful file
-    // 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}\n\nResult:\n${fenceSubagentReport(detail)}${audit}` };
-  };
 
   return async (args: Record<string, any>, cwd: string): Promise<ToolResult> => {
     const roleArg = typeof args.role === "string" ? args.role.trim() : "";

package/src/ai/providers/anthropic.ts

@@ -4,6 +4,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { ProviderHttpError, parseRetryAfter, parseRetryFromBody, providerHttpError } from "./errors";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
+import { sanitizeJsonStrings } from "../../util/sanitize-json";
 
 const ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 
@@ -306,7 +307,7 @@ export function anthropicPayload(
   if (stream) payload.stream = true;
   const system = anthropicSystemBlocks(systemPrompt, model, credential, payload, options.baseUrl);
   if (system) payload.system = system;
-  return JSON.stringify(payload);
+  return JSON.stringify(sanitizeJsonStrings(payload));
 }
 
 export function anthropicRequest(

package/src/ai/providers/antigravity.ts

@@ -4,6 +4,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { serializeToolCalls } from "../../agent/tool-schemas";
+import { sanitizeJsonStrings } from "../../util/sanitize-json";
 import { geminiThinkingConfig, getGeminiCliHeaders, type GeminiThinkingConfig } from "./gemini";
 
 const ANTIGRAVITY_DAILY_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
@@ -204,14 +205,14 @@ export function antigravityRequest(messages: Message[], options: CallOptions, cr
     request.toolConfig = { functionCallingConfig: { mode: "AUTO" } };
   }
 
-  const body = JSON.stringify({
+  const body = JSON.stringify(sanitizeJsonStrings({
     project,
     model,
     request,
     requestType: "agent",
     userAgent: "antigravity",
     requestId: `agent-${randomUUID()}`,
-  });
+  }));
   return {
     url: `${endpoint}/v1internal:streamGenerateContent?alt=sse`,
     headers: {

package/src/ai/providers/gemini.ts

@@ -4,6 +4,7 @@ import { readSse } from "../sse";
 import { providerHttpError, fetchWithArtifactFailSafe } from "./errors";
 import { jeoEnv } from "../../util/env";
 import { serializeToolCalls } from "../../agent/tool-schemas";
+import { sanitizeJsonStrings } from "../../util/sanitize-json";
 
 /** Gemini 2.5+/latest models think by default and BILL thought tokens against
  *  `maxOutputTokens` — a small-budget call can burn its entire budget on thoughts
@@ -205,7 +206,7 @@ export function geminiRequest(messages: Message[], options: CallOptions, credent
   const headers: Record<string, string> = oauth
     ? { "content-type": "application/json", authorization: `Bearer ${oauth}` }
     : { "content-type": "application/json" };
-  return { url, headers, body: JSON.stringify(payload) };
+  return { url, headers, body: JSON.stringify(sanitizeJsonStrings(payload)) };
 }
 
 const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
@@ -236,7 +237,7 @@ export function geminiCliRequest(messages: Message[], options: CallOptions, acce
       accept: "text/event-stream",
       ...getGeminiCliHeaders(geminiModel),
     },
-    body: JSON.stringify({ project: projectId, model: geminiModel, request: payload }),
+    body: JSON.stringify(sanitizeJsonStrings({ project: projectId, model: geminiModel, request: payload })),
   };
 }
 

package/src/ai/providers/ollama.ts

@@ -2,6 +2,7 @@ import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readLines } from "../sse";
 import { providerHttpError } from "./errors";
 import { createThinkSplitter } from "../think-tags";
+import { sanitizeJsonStrings } from "../../util/sanitize-json";
 
 /**
  * Resolve the Ollama base URL. `OLLAMA_HOST` is documented as a bare host:port
@@ -52,7 +53,7 @@ function ollamaRequest(messages: Message[], options: CallOptions, stream: boolea
   };
   if (options.jsonMode) payload.format = "json";
   const base = normalizeOllamaBaseUrl(options.baseUrl);
-  return { url: `${base}/api/chat`, body: JSON.stringify(payload) };
+  return { url: `${base}/api/chat`, body: JSON.stringify(sanitizeJsonStrings(payload)) };
 }
 
 /** Round-5 #1: surface done_reason when a 200 carries no text (uniform contract). */

package/src/ai/providers/openai-responses.ts

@@ -15,6 +15,7 @@ import type { CallOptions, Message } from "../types";
 import { readSse } from "../sse";
 import { providerHttpError, fetchWithArtifactFailSafe } from "./errors";
 import { serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
+import { sanitizeJsonStrings } from "../../util/sanitize-json";
 import os from "node:os";
 import pkg from "../../../package.json";
 
@@ -141,7 +142,7 @@ export function codexResponsesRequest(
     return {
       url: `${base}/responses`,
       headers: { "content-type": "application/json", authorization: `Bearer ${token}`, accept: "text/event-stream", "user-agent": codexUserAgent() },
-      body: JSON.stringify(payload),
+      body: JSON.stringify(sanitizeJsonStrings(payload)),
     };
   }
   const accountId = extractChatgptAccountId(token);
@@ -161,7 +162,7 @@ export function codexResponsesRequest(
     headers.conversation_id = promptCacheKey;
     headers["x-client-request-id"] = promptCacheKey;
   }
-  return { url: CODEX_RESPONSES_URL, headers, body: JSON.stringify(payload) };
+  return { url: CODEX_RESPONSES_URL, headers, body: JSON.stringify(sanitizeJsonStrings(payload)) };
 }
 
 /** gjc parity (normalizeOpenAIResponsesPromptCacheKey): well-formed unicode, ≤64 chars

package/src/ai/providers/openai.ts

@@ -4,6 +4,7 @@ import { readSse } from "../sse";
 import { providerHttpError } from "./errors";
 import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
+import { sanitizeJsonStrings } from "../../util/sanitize-json";
 import { createThinkSplitter, stripLeakedReasoningTags } from "../think-tags";
 
 /** True for OpenAI reasoning models (o-series + gpt-5+ family). Digit-count agnostic
@@ -96,7 +97,7 @@ export function openaiRequest(messages: Message[], options: CallOptions, credent
   return {
     url: `${base}/chat/completions`,
     headers: { "content-type": "application/json", Authorization: `Bearer ${bearerFor(credential)}` },
-    body: JSON.stringify(payload),
+    body: JSON.stringify(sanitizeJsonStrings(payload)),
   };
 }
 

package/src/commands/AGENTS.md

@@ -28,7 +28,7 @@ Concrete implementations of `jeo` subcommands (e.g., launch, setup, team, ultrag
 | `skills.ts` | Brief description of purpose |
 | `state.ts` | Brief description of purpose |
 | `status.ts` | Brief description of purpose |
-| `team.ts` | Multi-agent coordination command |
+| `team.ts` | `jeo team` — executes an approved ralplan plan step-by-step via the SAME `runSubagentOnce` core the `task`/`subagent` tools use; a contiguous run of steps sharing a plan `parallel_group` runs concurrently in isolated git worktrees (`runParallelGroup`), merged back in order (gjc `team` concurrency parity) |
 | `ultragoal.ts` | Brief description of purpose |
 | `update.ts` | Brief description of purpose |
 

package/src/commands/launch.ts

@@ -880,10 +880,33 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
       // Refresh injected OKF memory with THIS turn's query before the model call so
       // failure-first ranking fires and same-session dead ends resurface.
       await refreshSessionMemory(userInput);
-      const compRes = await maybeCompact(history, {
-        model: activeModel,
-        contextTokens,
+      // Esc-cancellable turn-boundary compaction preflight: a slow/hung summarization
+      // LLM call must not be un-cancellable just because it runs before the main
+      // per-turn abort harness (created below) exists yet. A short-lived harness scoped
+      // to just this call gives Esc/Ctrl+C the same abort path without wiring the full
+      // mid-turn steering machinery this early (which needs turn-scoped vars not
+      // constructed until after compaction/history mutation settles).
+      const compactHarness = createInFlightAbortHarness({
+        captureEsc: !!tui,
+        onAbortNotice: msg => {
+          if (tui) tui.events().onNotice?.(msg);
+          else console.log(msg);
+        },
+        onHardExit: () => {
+          if (tui) tui.finish("Cancelled.", { ok: false });
+          process.exit(130);
+        },
       });
+      let compRes: Awaited<ReturnType<typeof maybeCompact>>;
+      try {
+        compRes = await maybeCompact(history, {
+          model: activeModel,
+          contextTokens,
+          signal: compactHarness.controller.signal,
+        });
+      } finally {
+        compactHarness.dispose();
+      }
       if (compRes.error) {
         throw new Error(compRes.error);
       }
@@ -3587,6 +3610,26 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         }
         continue;
       }
+      if (input === "/wiki" || input.startsWith("/wiki ")) {
+        const decision = decideWikiSlash(
+          input,
+          resolveWikiRoot(await readGlobalConfig()),
+          !!jeoEnv("WIKI_ROOT"),
+        );
+        for (const line of decision.lines) console.log(line);
+        if (decision.kind === "clear") {
+          await saveConfigPatch(() => ({ wikiRoot: undefined }));
+          delete process.env.JEO_WIKI_ROOT;
+          sessionWikiRoot = undefined;
+          await refreshSessionMemory("");
+        } else if (decision.kind === "set") {
+          await saveConfigPatch(() => ({ wikiRoot: decision.persistArg }));
+          process.env.JEO_WIKI_ROOT = decision.root;
+          sessionWikiRoot = decision.root;
+          await refreshSessionMemory("");
+        }
+        continue;
+      }
       if (input === "/evolve") {
         await runEvolveSimulation(animateAsciiArt);
         continue;

package/src/commands/ralplan.ts

@@ -142,7 +142,17 @@ export async function runRalplanEngine(opts: RalplanEngineOptions = {}): Promise
     `  - name: "<imperative task, e.g. Implement reverse() in src/reverse.ts>"\n` +
     `    role: executor   # one of: executor | planner | architect | critic\n` +
     `    target: "<primary file path>"\n` +
-    `Provide 3-8 concrete, ordered steps. Output ONLY the YAML.`;
+    `    parallel_group: "<optional short id, e.g. g1>"\n` +
+    `Provide 3-8 concrete, ordered steps. Output ONLY the YAML.\n\n` +
+    `parallel_group is OPTIONAL and OFF by default — omit it unless you are certain. ` +
+    `'jeo team' executes steps strictly in array order, EXCEPT a contiguous (adjacent, ` +
+    `no other step in between) run of steps sharing the SAME non-empty parallel_group value, ` +
+    `which it runs CONCURRENTLY in isolated git worktrees and merges back. Only mark steps ` +
+    `parallel_group when they are TRULY independent: each touches DISJOINT files with no step ` +
+    `reading or building on another's output. Never mark two steps parallel if one depends on, ` +
+    `reads, or extends a file another writes. When unsure, leave parallel_group out — a plain ` +
+    `serial step is always correct; a wrongly-parallel step risks a merge conflict that halts ` +
+    `execution.`;
 
   const PLANNER = `You are the PLANNER. From the crystallized spec, sequence the work into a logical, outcome-based progression of concrete, ordered tasks.\n` + SCHEMA_SPEC;
   const ARCHITECT = `You are the ARCHITECT. Review the Planner's draft for technical feasibility, correct file targets, directory structure, and any missing setup/wiring/test steps. Return an improved plan (same shape).\n` + SCHEMA_SPEC;

package/src/commands/team.ts

@@ -1,4 +1,5 @@
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { createHash } from "node:crypto";
 import chalk from "chalk";
 import { PlanSchema, normalizePlanShape, parseYaml } from "../agent/plan";
@@ -8,24 +9,21 @@ import {
   writeWorkflowState,
   acquireWorkflowRunLock,
   type WorkflowState,
+  type Config,
 } from "../agent/state";
-import { runAgentLoop } from "../agent/engine";
-import { maybeCompact } from "../agent/compaction";
-import { catalogMetadata } from "../ai";
-import { gitDirtyCount } from "./launch/tmux";
+import { runSubagentOnce, type SubagentRunResult } from "../agent/task-tool";
+import { SubagentRegistry } from "../agent/subagent-registry";
+import { gitDirtyCount, resolveWorktree } from "./launch/tmux";
 import { readGlobalConfig } from "../agent/state";
 import {
   defaultSubagentRole,
   getSubagentRole,
   resolveSubagentModel,
   resolveSubagentMaxSteps,
-  subagentSystemPrompt,
-  subagentToolset,
   subagentRoleIds,
-  validateSubagentDoneReason,
+  type SubagentRole,
 } from "../agent/subagents";
-import type { Message } from "../agent/loop";
-import { loadProjectContext, withProjectContext } from "../agent/context-files";
+import { loadProjectContext } from "../agent/context-files";
 import { categoryBadge } from "../tui/components/category-index";
 
 export type RalphStreamKind = "step" | "complete" | "error" | "warn";
@@ -343,12 +341,65 @@ export async function runTeamEngine(opts: TeamEngineOptions = {}): Promise<{ ok:
         return { ok: false, reason: "aborted" };
       }
 
-      const currentTask = teamState.pending_tasks[0];
-      log(`\n${categoryBadge("progress")} Current task: "${currentTask}"`);
       const activeIndex = activeStepIndex(tasks.length, teamState.pending_tasks);
       // Guide printed once above; per-task lines convey progress. No per-iteration
       // reprint — it was O(N²) lines, climbing the embedded-terminal renderer's CPU.
 
+      // Look ahead from the current position: if this step's `parallel_group`
+      // extends into one or more of the NEXT pending steps (the group's full
+      // contiguous run is, by construction, always still all-pending here —
+      // `activeIndex` is derived from how many tasks remain), dispatch the WHOLE
+      // group concurrently. A group of size 1 (no group, or a lone member) falls
+      // straight through to the existing serial path, unchanged.
+      const groupVal = parsed.data.steps[activeIndex]?.parallel_group?.trim() || undefined;
+      const groupIndices = [activeIndex];
+      if (groupVal) {
+        let i = activeIndex + 1;
+        while (i < tasks.length && (parsed.data.steps[i]?.parallel_group?.trim() || undefined) === groupVal) {
+          groupIndices.push(i);
+          i++;
+        }
+      }
+
+      if (groupIndices.length > 1) {
+        const groupSteps = groupIndices.map(i => ({ index: i, name: tasks[i]!, roleId: roleByIndex[i] }));
+        log(`\n${categoryBadge("progress")} Current parallel group "${groupVal}": ${groupSteps.map(s => `"${s.name}"`).join(", ")}`);
+        if (opts.onProgress) {
+          opts.onProgress({ skill: "team", phase: "executing", detail: `Current parallel group: ${groupSteps.map(s => s.name).join(", ")}` });
+        }
+
+        const groupResult = await runParallelGroup(groupSteps, {
+          cwd,
+          teamCfg,
+          tasks,
+          completed: teamState.completed_tasks ?? [],
+          strictMutations: opts.strictMutations ?? false,
+          log,
+          slug: planState.slug ?? teamState.slug ?? "team",
+        });
+
+        if (opts.signal?.aborted) {
+          return { ok: false, reason: "aborted" };
+        }
+
+        if (groupResult.ok) {
+          teamState.completed_tasks = [...(teamState.completed_tasks ?? []), ...groupSteps.map(s => s.name)];
+          teamState.pending_tasks = teamState.pending_tasks.slice(groupSteps.length);
+          await writeWorkflowState("team", teamState, cwd);
+          log(`${categoryBadge("done")} Completed parallel group: ${groupSteps.map(s => `"${s.name}"`).join(", ")}`);
+        } else {
+          teamState.current_phase = "failed";
+          teamState.failed_task = groupResult.failedTaskName;
+          await writeWorkflowState("team", teamState, cwd);
+          log(`${categoryBadge("error")} Failed on parallel group step: "${groupResult.failedTaskName}". Halting execution.`);
+          return { ok: false, reason: `Failed on task: "${groupResult.failedTaskName}"` };
+        }
+        continue;
+      }
+
+      const currentTask = teamState.pending_tasks[0];
+      log(`\n${categoryBadge("progress")} Current task: "${currentTask}"`);
+
       if (opts.onProgress) {
         opts.onProgress({ skill: "team", phase: "executing", detail: `Current task: ${currentTask}` });
       }
@@ -417,89 +468,68 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
   const maxSteps = resolveSubagentMaxSteps(role.id, config);
   log(`  └─ Subagent: ${role.title} · model ${model} · ≤${maxSteps} steps`);
 
-  const contextTokens = catalogMetadata(model)?.contextTokens;
-
   const projectContext = await loadProjectContext(ctx.cwd);
-  const history: Message[] = [
-    { role: "system", content: withProjectContext(subagentSystemPrompt(role), projectContext) },
-    { role: "user", content: buildRalphSubagentPrompt(ctx) },
-  ];
 
-  try {
-    await maybeCompact(history, { model, contextTokens });
-  } catch (err) {
-    // 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
-  const result = await runAgentLoop(history, {
-    cwd: ctx.cwd,
-    model,
-    maxSteps,
-    // Per-run prompt-cache key: each worker replays its own growing history every
-    // step, so a stable per-run key gets provider cache hits (gjc sub-session parity).
-    sessionKey: crypto.randomUUID(),
-    // Bounded delegation: ralph/team subagents keep an exact step contract; the
-    // orchestrator owns retries, so the gjc step-extension flow is disabled here.
-    budget: { maxExtensions: 0 },
-    tools: subagentToolset(role),
-    events: {
-      onAssistant: (_raw, invocation) => {
-        if (!invocation) {
-          log(formatRalphStreamEvent("error", "invalid tool-call json; retrying", renderOpts));
-        } else if (invocation.tool !== "done") {
-          log(formatRalphStreamEvent("step", `tool ${invocation.tool} requested`, renderOpts));
-        }
-      },
-      onStep: async step => {
-        log(formatRalphStreamEvent("step", `${role.title} thinking ${step}/${maxSteps}`, renderOpts));
-        try {
-          await maybeCompact(history, { model, contextTokens });
-        } catch (err) {
-          // LLM summary failure does not halt team
-        }
-      },
-      onToolResult: (tool, ok) => {
-        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)),
+  // `jeo team` now runs every step through the SAME execution core as the `task`/
+  // `subagent` tools (`runSubagentOnce`) — one way a jeo-code subagent runs,
+  // whether launched interactively, in a fan-out batch, detached, or as a team
+  // plan step. This gets team plan steps the same fenced-report protection
+  // (prompt-injection-safe) and done-reason contract validation the interactive
+  // tools already had, instead of a second hand-rolled copy of that logic.
+  const result = await runSubagentOnce(role, buildRalphSubagentPrompt(ctx), "", ctx.cwd, {
+    config,
+    projectContext,
+    onEvent: ev => {
+      if (ev.kind === "step") {
+        log(formatRalphStreamEvent("step", ev.detail ?? `${role.title} thinking ${ev.step ?? "?"}/${ev.maxSteps ?? maxSteps}`, renderOpts));
+      } else if (ev.kind === "tool") {
+        const suffix = ev.summary ? ` — ${ev.summary}` : "";
+        log(formatRalphStreamEvent(ev.success ? "complete" : "error", `tool ${ev.detail}${suffix}`, renderOpts));
+      }
     },
   });
 
-  const reason = result.doneReason?.trim() || `${role.title} did not converge within ${result.steps} steps`;
-  if (!result.done) {
-    log(formatRalphStreamEvent("error", reason, renderOpts));
-    return false;
-  }
+  return evaluateSubagentResult(result, role, ctx.strictMutations ?? false, log, renderOpts);
+}
 
-  const contract = validateSubagentDoneReason(role, reason);
-  if (!contract.ok) {
-    log(formatRalphStreamEvent("error", `${role.title} report incomplete: missing ${contract.missing?.join(", ")}`, renderOpts));
+/**
+ * Shared pass/fail verdict for ONE subagent's `SubagentRunResult`: contract
+ * failure, role-gate rejection (architect BLOCK / critic REQUEST CHANGES), and
+ * `--strict-mutations` hard-fail. Used by BOTH the serial path
+ * (`executeTaskWithAgent`) and the parallel-group path (`runParallelGroup`) so
+ * the two never diverge on what counts as a passing step.
+ */
+function evaluateSubagentResult(
+  result: SubagentRunResult,
+  role: SubagentRole,
+  strictMutations: boolean,
+  log: (line: string) => void,
+  renderOpts: RalphRenderOptions,
+): boolean {
+  if (!result.success) {
+    log(formatRalphStreamEvent("error", result.error || result.output, renderOpts));
     return false;
   }
 
-  const gate = parseRoleGateVerdict(role.id, reason);
+  // Role gate verdict (architect BLOCK / critic REQUEST CHANGES) is parsed from the
+  // subagent's RAW done reason, not the fenced/wrapped report text around it.
+  const gate = parseRoleGateVerdict(role.id, result.doneReason);
   if (!gate.ok) {
     log(formatRalphStreamEvent("error", gate.message ?? `${role.title} blocked execution`, renderOpts));
     return false;
   }
 
-  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.
-    const msg = bashRuns === 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.
+  if (!role.readOnly && result.fileMutations === 0) {
+    const msg = result.bashRuns === 0
       ? `${role.title} completed WITHOUT any successful write/edit/bash — treat its changed-files claim as unverified.`
       : `${role.title} completed with only bash (no write/edit) — verify its changed-files claim independently.`;
     // Round-11: under --strict-mutations, a mutating role that took NO action at
     // all (no write/edit/bash) is a hard failure — an empty run must not pass as
     // a completed task. bash-only stays advisory to avoid penalizing shell edits.
-    const hardFail = ctx.strictMutations && bashRuns === 0;
+    const hardFail = strictMutations && result.bashRuns === 0;
     // Round-12: separate the tones so a passing advisory run doesn't masquerade
     // as a stream:error — only a real hard-fail is red; an advisory note is warn.
     log(formatRalphStreamEvent(hardFail ? "error" : "warn", msg, renderOpts));
@@ -507,12 +537,169 @@ async function executeTaskWithAgent(ctx: RalphSubagentPromptContext & { cwd: str
       return false;
     }
   }
-  // Surface the subagent's ACTUAL report to the user — not just a "finished"
-  // status. Previously `reason` was consumed only for validation/gating and the
-  // report content was discarded, so `team` runs produced no visible answer.
+
+  // Surface the subagent's full report (header + step trace + fenced reason +
+  // mutation audit) — not just a "finished" status.
   log(formatRalphStreamEvent("complete", `${role.title} finished task`, renderOpts));
   log(`\n${role.title} report:`);
-  log(reason); // log() already splits multi-line strings across the io.output sink
+  log(result.output); // log() already splits multi-line strings across the io.output sink
 
   return true;
 }
+
+/** One step of a dispatched parallel group, resolved to its plan position + role. */
+interface ParallelGroupStep {
+  index: number;
+  name: string;
+  roleId?: string;
+}
+
+/** Per-step worktree + branch resolved for a dispatched parallel group. */
+interface ParallelWorktree {
+  path: string;
+  branch: string;
+}
+
+function runGitSync(cwd: string, args: string[]): { ok: boolean; stdout: string; stderr: string } {
+  const res = Bun.spawnSync(["git", ...args], { cwd, stdout: "pipe", stderr: "pipe" });
+  return { ok: res.exitCode === 0, stdout: res.stdout.toString(), stderr: res.stderr.toString() };
+}
+
+/**
+ * Execute a CONTIGUOUS run of `parallel_group`-marked plan steps concurrently,
+ * each in its own git worktree via `resolveWorktree` + the SAME
+ * `SubagentRegistry`/`runSubagentOnce` core the serial path and the `task`/
+ * `subagent` tools use. On full success, each worker's committed branch is
+ * merged back into `cwd`'s current branch IN ARRAY ORDER; any failure or merge
+ * conflict stops processing immediately and leaves the remaining
+ * worktrees/branches in place for manual inspection — nothing is ever silently
+ * resolved or discarded.
+ */
+async function runParallelGroup(
+  group: ParallelGroupStep[],
+  ctx: {
+    cwd: string;
+    teamCfg: Config;
+    tasks: string[];
+    completed: readonly string[];
+    strictMutations: boolean;
+    log: (line: string) => void;
+    slug: string;
+  },
+): Promise<{ ok: true } | { ok: false; failedTaskName: string }> {
+  const { cwd, teamCfg, tasks, completed, strictMutations, log, slug } = ctx;
+  const renderOpts: RalphRenderOptions = { color: !!process.stdout.isTTY, indexed: true };
+
+  const registry = new SubagentRegistry();
+  const resultsByIndex = new Map<number, SubagentRunResult>();
+  const idByIndex = new Map<number, string>();
+  const roleByStepIndex = new Map<number, SubagentRole>();
+  const worktreeByIndex = new Map<number, ParallelWorktree>();
+
+  log(`\n${categoryBadge("progress")} Dispatching parallel group of ${group.length} steps concurrently: ${group.map(s => `"${s.name}"`).join(", ")}`);
+
+  for (const step of group) {
+    const worktreePath = path.join(cwd, ".jeo", "team-worktrees", `${slug}-${step.index}`);
+    const resolvedPath = resolveWorktree(cwd, worktreePath);
+    const branchRes = runGitSync(resolvedPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branch = branchRes.stdout.trim();
+    worktreeByIndex.set(step.index, { path: resolvedPath, branch });
+
+    const role = getSubagentRole(step.roleId, teamCfg) ?? defaultSubagentRole();
+    roleByStepIndex.set(step.index, role);
+    const model = resolveSubagentModel(role.id, teamCfg);
+    const maxSteps = resolveSubagentMaxSteps(role.id, teamCfg);
+    log(`  └─ [${step.name}] Subagent: ${role.title} · model ${model} · ≤${maxSteps} steps · worktree ${resolvedPath} (branch ${branch})`);
+
+    // Loaded PER WORKTREE (its own file tree) — never shared across concurrent workers.
+    const projectContext = await loadProjectContext(resolvedPath);
+    const promptCtx: RalphSubagentPromptContext = { task: step.name, tasks, activeIndex: step.index, completed };
+    const taskText = buildRalphSubagentPrompt(promptCtx);
+
+    const record = registry.launch(role.id, step.name, async (signal) => {
+      const result = await runSubagentOnce(role, taskText, "", resolvedPath, {
+        config: teamCfg,
+        signal,
+        projectContext,
+        onEvent: ev => {
+          if (ev.kind === "step") {
+            log(formatRalphStreamEvent("step", `[${step.name}] ${ev.detail ?? `${role.title} thinking ${ev.step ?? "?"}/${ev.maxSteps ?? maxSteps}`}`, renderOpts));
+          } else if (ev.kind === "tool") {
+            const suffix = ev.summary ? ` — ${ev.summary}` : "";
+            log(formatRalphStreamEvent(ev.success ? "complete" : "error", `[${step.name}] tool ${ev.detail}${suffix}`, renderOpts));
+          }
+        },
+      });
+      // Capture the FULL SubagentRunResult (doneReason/fileMutations/etc.) before
+      // collapsing it to the plain ToolResult shape SubagentRegistry stores.
+      resultsByIndex.set(step.index, result);
+      return { success: result.success, output: result.output, error: result.error };
+    });
+    idByIndex.set(step.index, record.id);
+  }
+
+  // No timeout — team runs can take as long as needed.
+  await registry.awaitIds([...idByIndex.values()]);
+
+  // Evaluate + commit each successful worktree, IN ARRAY ORDER (not completion
+  // order). Any failure stops the whole group immediately: no merges happen,
+  // and every worktree/branch is left exactly as it is for inspection.
+  for (const step of group) {
+    const result = resultsByIndex.get(step.index);
+    const role = roleByStepIndex.get(step.index)!;
+    const wt = worktreeByIndex.get(step.index)!;
+    if (!result) {
+      log(formatRalphStreamEvent("error", `[${step.name}] subagent produced no result`, renderOpts));
+      return { ok: false, failedTaskName: step.name };
+    }
+    const success = evaluateSubagentResult(result, role, strictMutations, log, renderOpts);
+    if (!success) {
+      log(`${categoryBadge("error")} Parallel group step "${step.name}" failed — its worktree (${wt.path}) and the OTHER group worktrees are left in place for inspection; nothing was merged.`);
+      return { ok: false, failedTaskName: step.name };
+    }
+    // An empty diff (read-only role, or a no-op) needs no commit — skip it for
+    // the merge step below without treating it as an error.
+    if (gitDirtyCount(wt.path)) {
+      const add = runGitSync(wt.path, ["add", "-A"]);
+      if (!add.ok) {
+        log(`${categoryBadge("error")} Failed to stage changes in worktree ${wt.path} for step "${step.name}": ${add.stderr.trim()}`);
+        return { ok: false, failedTaskName: step.name };
+      }
+      const commit = runGitSync(wt.path, ["commit", "-m", step.name]);
+      if (!commit.ok) {
+        log(`${categoryBadge("error")} Failed to commit changes in worktree ${wt.path} for step "${step.name}": ${commit.stderr.trim()}`);
+        return { ok: false, failedTaskName: step.name };
+      }
+    }
+  }
+
+  // All group steps succeeded — merge each worker branch back, IN ARRAY ORDER.
+  // A conflict aborts the merge immediately (never auto-resolved) and stops the
+  // rest of the group's merges.
+  for (const step of group) {
+    const wt = worktreeByIndex.get(step.index)!;
+    const merge = runGitSync(cwd, ["merge", "--no-ff", wt.branch, "-m", `merge: ${step.name}`]);
+    if (!merge.ok) {
+      runGitSync(cwd, ["merge", "--abort"]);
+      log(
+        `${categoryBadge("error")} Merge conflict merging step "${step.name}"'s branch "${wt.branch}" into the current branch — ` +
+        `the merge was aborted automatically (no changes were auto-resolved). Resolve manually: ` +
+        `cd ${wt.path} to inspect the change, then run 'git merge ${wt.branch}' yourself from ${cwd}.\n${(merge.stderr + merge.stdout).trim()}`,
+      );
+      return { ok: false, failedTaskName: step.name };
+    }
+    log(`${categoryBadge("done")} Merged step "${step.name}" (branch ${wt.branch}) into the current branch.`);
+  }
+
+  // Fully successful group — clean up worktrees best-effort (a removal failure,
+  // e.g. stray untracked files, is a warning, never a hard failure of the run).
+  for (const step of group) {
+    const wt = worktreeByIndex.get(step.index)!;
+    const removal = runGitSync(cwd, ["worktree", "remove", wt.path]);
+    if (!removal.ok) {
+      log(`[WARN] Could not remove worktree ${wt.path} for step "${step.name}": ${removal.stderr.trim()}`);
+    }
+  }
+
+  return { ok: true };
+}

package/src/util/sanitize-json.ts

@@ -0,0 +1,42 @@
+/**
+ * Lone-surrogate sanitization for provider request bodies (gjc 0.8.1 parity).
+ *
+ * Tool-call arguments, tool-result output, and message content are embedded raw into
+ * provider request bodies before `JSON.stringify`. A truncated multi-byte emoji (or
+ * model-echoed text) can leave an unpaired UTF-16 surrogate in a string; `JSON.stringify`
+ * happily emits it as a lone `\ud8xx`/`\udcxx` escape, which strict provider JSON parsers
+ * reject (e.g. Anthropic 400 "no low surrogate in string"). `sanitizeJsonStrings` walks an
+ * arbitrary JS value and replaces every string (both object keys and values) with its
+ * `.toWellFormed()` form, which turns lone surrogates into U+FFFD without touching valid
+ * surrogate pairs (real emoji, etc.).
+ */
+
+/** Recursively sanitize every string value and object key in `value` for well-formed UTF-16.
+ *  Cycle-safe via a `WeakMap` of already-sanitized objects/arrays. */
+export function sanitizeJsonStrings<T>(value: T): T {
+  return sanitizeJsonStringsInner(value, new WeakMap<object, unknown>()) as T;
+}
+
+function sanitizeJsonStringsInner(value: unknown, seen: WeakMap<object, unknown>): unknown {
+  if (typeof value === "string") return value.toWellFormed();
+  if (!value || typeof value !== "object") return value;
+
+  const cached = seen.get(value);
+  if (cached !== undefined) return cached;
+
+  if (Array.isArray(value)) {
+    const sanitized: unknown[] = [];
+    seen.set(value, sanitized);
+    for (const item of value) {
+      sanitized.push(sanitizeJsonStringsInner(item, seen));
+    }
+    return sanitized;
+  }
+
+  const sanitized: Record<string, unknown> = {};
+  seen.set(value, sanitized);
+  for (const [key, nestedValue] of Object.entries(value as Record<string, unknown>)) {
+    sanitized[key.toWellFormed()] = sanitizeJsonStringsInner(nestedValue, seen);
+  }
+  return sanitized;
+}