jeo-code 0.7.32 → 0.7.35

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/subagents.ts

@@ -252,7 +252,7 @@ export function bashCommandAllowed(command: string, prefixes: string[]): boolean
  */
 export function subagentToolset(role: SubagentRole): Record<string, ToolHandler> {
   if (role.readOnly) {
-    const MUTATING = new Set(["write", "edit", "bash", "mkdir", "delete", "ast_edit", "computer", "lsp_rename", "debug"]);
+    const MUTATING = new Set(["write", "edit", "bash", "mkdir", "delete", "ast_edit", "computer", "lsp_rename", "debug", "browser"]);
     const ro: Record<string, ToolHandler> = {};
     for (const [name, handler] of Object.entries(DEFAULT_TOOLS)) {
       if (MUTATING.has(name)) continue;

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

@@ -525,7 +525,7 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // pi-style: load project context (JEO.md / AGENTS.md / .jeo/context.md / CLAUDE.md) into the prompt.
   const contextFiles = await loadProjectContext(cwd);
 
-  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "todo", "subagent", "job", "irc", "goal", "ast_grep", "ast_edit", "computer", "lsp", "lsp_rename", "debug"]);
+  const KNOWN_TOOLS = new Set(["read", "write", "edit", "bash", "find", "search", "ls", "task", "todo", "subagent", "job", "irc", "goal", "ast_grep", "ast_edit", "computer", "lsp", "lsp_rename", "debug", "browser"]);
   let allowedTools = new Set(KNOWN_TOOLS);
 
   if (flags.noTools) {
@@ -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;