jeo-code 0.12.12 → 0.12.15

package/src/ai/model-discovery.ts

@@ -43,6 +43,8 @@ export interface ProviderModelsResult {
   error?: string;
   /** True when the live endpoint was unusable and ids came from the static catalog. */
   fallback?: boolean;
+  /** Display names from the same live response, keyed by callable model id. */
+  displayNames?: Record<string, string>;
 }
 
 export interface DiscoveryOptions {
@@ -565,6 +567,15 @@ export async function listProviderModels(
       }
     }
     let ids = parseModelsBody(provider, body, { openaiCompatible: provider === "openai" && !!baseUrl });
+    const displayNames: Record<string, string> = {};
+    if (provider === "antigravity" && body && typeof body === "object" && "models" in body && body.models && typeof body.models === "object") {
+      for (const [key, row] of Object.entries(body.models)) {
+        if (!row || typeof row !== "object" || !("displayName" in row) || typeof row.displayName !== "string" || !row.displayName.trim()) continue;
+        const rawId: string = Array.isArray(body.models) ? ("slug" in row && typeof row.slug === "string" ? row.slug : "id" in row && typeof row.id === "string" ? row.id : "name" in row && typeof row.name === "string" ? row.name : "") : key;
+        const id = `antigravity/${normalizeAntigravityModelId(rawId)}`;
+        if (ids.includes(id)) displayNames[id] = row.displayName;
+      }
+    }
     // Gemini paginates: follow nextPageToken (bounded) so the available list is
     // COMPLETE — page 1 alone silently dropped the newest models (round-15).
     if (provider === "gemini") {
@@ -609,6 +620,7 @@ export async function listProviderModels(
       models,
       ok: true,
       source,
+      ...(Object.keys(displayNames).length ? { displayNames } : {}),
       ...scope,
     };
   } catch (err) {

package/src/ai/providers/anthropic.ts

@@ -2,7 +2,7 @@ import { createHash, randomBytes, randomUUID } from "node:crypto";
 import type { Credential } from "../../auth";
 import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
-import { ProviderHttpError, parseRetryAfter, parseRetryFromBody, providerHttpError } from "./errors";
+import { ProviderHttpError, ProviderStreamError, parseRetryAfter, parseRetryFromBody, providerHttpError } from "./errors";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 import { sanitizeJsonStrings } from "../../util/sanitize-json";
 import { jeoEnv } from "../../util/env";
@@ -501,6 +501,13 @@ function emptyCompletionError(stopReason: string | undefined, category?: string)
   return new Error(`Anthropic returned no content${reason ? ` (${reason})` : ""}${hint}.`);
 }
 
+function assertNormalStop(stopReason: string | undefined, category?: string): void {
+  if (stopReason && stopReason !== "end_turn" && stopReason !== "tool_use" && stopReason !== "stop_sequence") {
+    const hint = stopReason === "max_tokens" ? " — output budget exhausted; raise maxTokens or lower the thinking level" : "";
+    throw new Error(`Anthropic response incomplete (stop_reason=${stopReason}${category ? `, category=${category}` : ""})${hint}.`);
+  }
+}
+
 export const anthropicAdapter: ProviderAdapter = {
   name: "anthropic",
   supportsNativeTools: true,
@@ -508,6 +515,10 @@ export const anthropicAdapter: ProviderAdapter = {
     const response = await postAnthropic(messages, options, credential, false);
     const result = (await response.json()) as { model?: string; content: { type: string; text?: string; name?: string; input?: unknown; thinking?: string; signature?: string; data?: string }[]; stop_reason?: string; stop_details?: { category?: string }; usage?: AnthropicUsage };
     if (result.usage) options.onUsage?.({ inputTokens: totalInputTokens(result.usage), outputTokens: result.usage.output_tokens });
+    if (!result.content.some(c => (c.type === "text" && c.text) || (c.type === "tool_use" && c.name)) && result.stop_reason && !["end_turn", "tool_use", "stop_sequence"].includes(result.stop_reason)) {
+      throw emptyCompletionError(result.stop_reason, result.stop_details?.category);
+    }
+    assertNormalStop(result.stop_reason, result.stop_details?.category);
     // Tag with the model that ACTUALLY produced the content — on a server-side
     // fallback (see anthropicFallbackModels), `result.model` names the fallback
     // model, not `options.model` (the originally requested one). Stamping the
@@ -541,6 +552,7 @@ export const anthropicAdapter: ProviderAdapter = {
     let yieldedAny = false;
     let stopReason: string | undefined;
     let stopCategory: string | undefined;
+    let terminal = false;
     // The model that actually served the response — starts at the requested model,
     // updated from `message_start.message.model` and, on a mid-stream server-side
     // fallback (see anthropicFallbackModels), from the `fallback` block's `to.model`.
@@ -563,12 +575,18 @@ export const anthropicAdapter: ProviderAdapter = {
         delta?: { type?: string; text?: string; partial_json?: string; thinking?: string; signature?: string; stop_reason?: string; stop_details?: { category?: string } };
         message?: { model?: string; usage?: AnthropicUsage; stop_reason?: string; stop_details?: { category?: string } };
         usage?: { output_tokens?: number };
+        error?: { type?: string; message?: string };
       };
       try {
         evt = JSON.parse(data);
       } catch {
         continue;
       }
+      if (evt.type === "error") {
+        const code = evt.error?.type;
+        const statuses: Record<string, number> = { invalid_request_error: 400, authentication_error: 401, permission_error: 403, not_found_error: 404, request_too_large: 413, rate_limit_error: 429, api_error: 500, overloaded_error: 529 };
+        throw new ProviderStreamError("Anthropic", evt.error?.message ?? "unknown error", code, code ? statuses[code] : undefined);
+      }
       if (evt.type === "content_block_start" && evt.content_block?.type === "tool_use" && typeof evt.index === "number") {
         toolBlocks.set(evt.index, { name: evt.content_block.name ?? "", args: "" });
       } else if (evt.type === "content_block_start" && evt.content_block?.type === "fallback") {
@@ -619,12 +637,19 @@ export const anthropicAdapter: ProviderAdapter = {
           // message_start is harmless).
           cachedInput = totalInputTokens(evt.message.usage);
         }
+      } else if (evt.type === "message_stop") {
+        terminal = true;
       } else if (evt.type === "message_delta") {
-        if (evt.delta?.stop_reason) stopReason = evt.delta.stop_reason;
+        if (evt.delta?.stop_reason) { stopReason = evt.delta.stop_reason; terminal = true; }
         if (evt.delta?.stop_details?.category) stopCategory = evt.delta.stop_details.category;
         if (evt.usage) options.onUsage?.({ inputTokens: cachedInput, outputTokens: evt.usage.output_tokens });
       }
     }
+    if (!yieldedAny && !toolBlocks.size && stopReason && !["end_turn", "tool_use", "stop_sequence"].includes(stopReason)) {
+      throw emptyCompletionError(stopReason, stopCategory);
+    }
+    if (!terminal && (yieldedAny || toolBlocks.size)) throw new Error("Anthropic response incomplete (missing terminal event).");
+    assertNormalStop(stopReason, stopCategory);
     // Emit captured thinking blocks as replay artifacts (signed thought + signature).
     for (const tb of thinkBlocks.values()) {
       if (tb.text || tb.signature) {

package/src/ai/providers/antigravity.ts

@@ -323,6 +323,7 @@ export const antigravityAdapter: ProviderAdapter = {
     let out = "";
     let usage: CcaUsage | undefined;
     let lastEmptyReason: string | undefined;
+    let terminal = false;
     const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];
     for await (const data of readSse(response.body)) {
       let chunk: CcaChunk;
@@ -332,11 +333,14 @@ export const antigravityAdapter: ProviderAdapter = {
       if (thought) options.onReasoning?.(thought);
       const delta = textOf(chunk);
       if (delta) out += delta;
-      else lastEmptyReason = finishReasonOf(chunk) ?? lastEmptyReason;
+      lastEmptyReason = finishReasonOf(chunk) ?? lastEmptyReason;
+      if (chunk.response?.candidates?.[0]?.finishReason) terminal = true;
       fnCalls.push(...functionCallsOf(chunk));
       if (chunk.response?.usageMetadata) usage = chunk.response.usageMetadata;
     }
     if (usage) options.onUsage?.({ inputTokens: usage.promptTokenCount, outputTokens: (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0) });
+    if (lastEmptyReason && (out || fnCalls.length)) throw new Error(`Antigravity Cloud Code Assist response incomplete (${lastEmptyReason}).`);
+    if (!terminal && (out || fnCalls.length)) throw new Error("Antigravity Cloud Code Assist response incomplete (missing finishReason).");
     // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
     const envelope = serializeToolCalls(fnCalls);
     if (envelope) return envelope;
@@ -352,6 +356,7 @@ export const antigravityAdapter: ProviderAdapter = {
     let yielded = false;
     let usage: CcaUsage | undefined;
     let lastEmptyReason: string | undefined;
+    let terminal = false;
     const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];
     for await (const data of readSse(response.body, options.onStreamActivity)) {
       let chunk: CcaChunk;
@@ -361,11 +366,14 @@ export const antigravityAdapter: ProviderAdapter = {
       if (thought) options.onReasoning?.(thought);
       const delta = textOf(chunk);
       if (delta) { yielded = true; yield delta; }
-      else lastEmptyReason = finishReasonOf(chunk) ?? lastEmptyReason;
+      lastEmptyReason = finishReasonOf(chunk) ?? lastEmptyReason;
+      if (chunk.response?.candidates?.[0]?.finishReason) terminal = true;
       fnCalls.push(...functionCallsOf(chunk));
       if (chunk.response?.usageMetadata) usage = chunk.response.usageMetadata;
     }
     if (usage) options.onUsage?.({ inputTokens: usage.promptTokenCount, outputTokens: (usage.candidatesTokenCount ?? 0) + (usage.thoughtsTokenCount ?? 0) });
+    if (lastEmptyReason && (yielded || fnCalls.length)) throw new Error(`Antigravity Cloud Code Assist response incomplete (${lastEmptyReason}).`);
+    if (!terminal && (yielded || fnCalls.length)) throw new Error("Antigravity Cloud Code Assist response incomplete (missing finishReason).");
     // Native tool calls have no text deltas — yield the re-serialized envelope once at end.
     const envelope = serializeToolCalls(fnCalls);
     if (envelope) { yielded = true; yield envelope; }

package/src/ai/providers/gemini.ts

@@ -320,9 +320,6 @@ function blockedReason(chunk: GeminiChunk): string | undefined {
   if (block) return `blockReason=${block}`;
   const finish = chunk.candidates?.[0]?.finishReason;
   if (finish === "MAX_TOKENS") {
-    // Only reached when NO text was produced at all (both call/stream paths guard
-    // on emptiness): the output budget was consumed before any visible text —
-    // typically thinking tokens on a 2.5+/latest model.
     return "finishReason=MAX_TOKENS — output budget exhausted before any text; raise maxTokens or lower the thinking level";
   }
   if (finish && finish !== "STOP") return `finishReason=${finish}`;
@@ -360,6 +357,7 @@ async function* ccaTurn(messages: Message[], options: CallOptions, credential: C
   let lastUsage: GeminiChunk["usageMetadata"];
   let yieldedAny = false;
   let lastEmptyReason: string | undefined;
+  let terminal = false;
   const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];
   const seenSigs = new Set<string>();
   for await (const data of readSse(response.body, options.onStreamActivity)) {
@@ -379,12 +377,14 @@ async function* ccaTurn(messages: Message[], options: CallOptions, credential: C
     if (delta) {
       yieldedAny = true;
       yield delta;
-    } else {
-      lastEmptyReason = blockedReason(inner) ?? lastEmptyReason;
     }
+    lastEmptyReason = blockedReason(inner) ?? lastEmptyReason;
+    if (inner.candidates?.[0]?.finishReason) terminal = true;
     if (inner.usageMetadata) lastUsage = inner.usageMetadata;
     fnCalls.push(...geminiFunctionCallsOf(inner));
   }
+  if (lastEmptyReason && (yieldedAny || fnCalls.length)) throw new Error(`Gemini (Cloud Code Assist) response incomplete (${lastEmptyReason.replace(" before any text", "")}).`);
+  if (!terminal && (yieldedAny || fnCalls.length)) throw new Error("Gemini (Cloud Code Assist) response incomplete (missing finishReason).");
   const envelope = serializeToolCalls(fnCalls);
   if (envelope) { yieldedAny = true; yield envelope; }
   if (!yieldedAny) {
@@ -415,13 +415,14 @@ export const geminiAdapter: ProviderAdapter = {
     if (result.usageMetadata) {
       options.onUsage?.({ inputTokens: result.usageMetadata.promptTokenCount, outputTokens: result.usageMetadata.candidatesTokenCount });
     }
+    const reason = blockedReason(result);
+    if (reason) {
+      const hasContent = !!textOf(result) || geminiFunctionCallsOf(result).length > 0;
+      throw new Error(hasContent ? `Gemini response incomplete (${reason.replace(" before any text", "")}).` : `Gemini returned no content (${reason}).`);
+    }
     const envelope = serializeToolCalls(geminiFunctionCallsOf(result));
     if (envelope) return envelope;
     const text = textOf(result);
-    if (!text) {
-      const reason = blockedReason(result);
-      if (reason) throw new Error(`Gemini returned no content (${reason}).`);
-    }
     return text;
   },
   async *stream(messages, options, credential) {
@@ -435,8 +436,9 @@ export const geminiAdapter: ProviderAdapter = {
     if (!response.body) return;
     if (geminiThinkingActive(options)) options.onReasoningStart?.();
     let lastUsage: GeminiChunk["usageMetadata"];
-    let yieldedAny = false;
     let lastEmptyReason: string | undefined;
+    let terminal = false;
+    let receivedText = false;
     const fnCalls: { tool: string; arguments: Record<string, unknown> }[] = [];
     const seenSigs = new Set<string>();
     for await (const data of readSse(response.body, options.onStreamActivity)) {
@@ -452,21 +454,23 @@ export const geminiAdapter: ProviderAdapter = {
       captureGeminiSignatures(chunk, options, seenSigs);
       const delta = textOf(chunk);
       if (delta) {
-        yieldedAny = true;
+        receivedText = true;
         yield delta;
-      } else {
-        lastEmptyReason = blockedReason(chunk) ?? lastEmptyReason;
       }
+      lastEmptyReason = blockedReason(chunk) ?? lastEmptyReason;
+      if (chunk.candidates?.[0]?.finishReason) terminal = true;
       // Gemini emits cumulative usageMetadata on most chunks; capture the last and
       // report ONCE after the stream so an accumulating sink can't over-count.
       if (chunk.usageMetadata) lastUsage = chunk.usageMetadata;
       fnCalls.push(...geminiFunctionCallsOf(chunk));
     }
-    const envelope = serializeToolCalls(fnCalls);
-    if (envelope) { yieldedAny = true; yield envelope; }
-    if (!yieldedAny && lastEmptyReason) {
+    if (lastEmptyReason) {
+      if (receivedText || fnCalls.length) throw new Error(`Gemini response incomplete (${lastEmptyReason.replace(" before any text", "")}).`);
       throw new Error(`Gemini returned no content (${lastEmptyReason}).`);
     }
+    if (!terminal && (receivedText || fnCalls.length)) throw new Error("Gemini response incomplete (missing finishReason).");
+    const envelope = serializeToolCalls(fnCalls);
+    if (envelope) yield envelope;
     if (lastUsage) {
       options.onUsage?.({ inputTokens: lastUsage.promptTokenCount, outputTokens: lastUsage.candidatesTokenCount });
     }

package/src/ai/providers/ollama.ts

@@ -64,6 +64,13 @@ function emptyCompletionError(doneReason: string | undefined): Error {
   return new Error(`Ollama returned no content${doneReason ? ` (done_reason=${doneReason})` : ""}${hint}.`);
 }
 
+function assertNormalDone(doneReason: string | undefined): void {
+  if (doneReason && doneReason !== "stop") {
+    const hint = doneReason === "length" ? " — output budget exhausted; raise maxTokens" : "";
+    throw new Error(`Ollama response incomplete (done_reason=${doneReason})${hint}.`);
+  }
+}
+
 export const ollamaAdapter: ProviderAdapter = {
   name: "ollama",
   async call(messages, options) {
@@ -72,6 +79,7 @@ export const ollamaAdapter: ProviderAdapter = {
     if (!response.ok) throw await providerHttpError("Ollama", response, `at ${url}`);
     const result = (await response.json()) as { message?: { content?: string }; done_reason?: string; prompt_eval_count?: number; eval_count?: number; total_duration?: number };
     options.onUsage?.({ inputTokens: result.prompt_eval_count, outputTokens: result.eval_count, durationMs: result.total_duration ? Math.round(result.total_duration / 1e6) : undefined });
+    assertNormalDone(result.done_reason);
     const text = result.message?.content ?? "";
     if (!text) throw emptyCompletionError(result.done_reason);
     return text;
@@ -83,6 +91,8 @@ export const ollamaAdapter: ProviderAdapter = {
     if (!response.body) return;
     let yieldedAny = false;
     let doneReason: string | undefined;
+    let terminal = false;
+    let receivedContent = false;
     // Route inline <think>…</think> (local reasoning models) to the reasoning channel.
     const think = createThinkSplitter(options.onReasoning);
     for await (const line of readLines(response.body, options.onStreamActivity)) {
@@ -94,6 +104,7 @@ export const ollamaAdapter: ProviderAdapter = {
       }
       const raw = chunk.message?.content;
       if (raw) {
+        receivedContent = true;
         const visible = think.push(raw);
         if (visible) {
           yieldedAny = true;
@@ -105,11 +116,14 @@ export const ollamaAdapter: ProviderAdapter = {
       const reason = chunk.message?.thinking;
       if (reason) options.onReasoning?.(reason);
       if (chunk.done) {
+        terminal = true;
         if (chunk.done_reason) doneReason = chunk.done_reason;
         options.onUsage?.({ inputTokens: chunk.prompt_eval_count, outputTokens: chunk.eval_count, durationMs: chunk.total_duration ? Math.round(chunk.total_duration / 1e6) : undefined });
         break;
       }
     }
+    if (!terminal && receivedContent) throw new Error("Ollama response incomplete (missing done event).");
+    assertNormalDone(doneReason);
     const trailing = think.flush();
     if (trailing) { yieldedAny = true; yield trailing; }
     if (!yieldedAny) throw emptyCompletionError(doneReason);

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

@@ -186,9 +186,9 @@ export interface ResponsesEvent {
    *  carried separately from the human-readable message so callers can classify
    *  retryability without parsing prose (round: in-band SSE error retry fix). */
   errorCode?: string;
-  /** `response.incomplete` cause (e.g. max_output_tokens) — surfaced when the
-   *  whole response produced no text (round-5 #1). */
+  /** `response.incomplete` cause (e.g. max_output_tokens). */
   incompleteReason?: string;
+  completed?: boolean;
   /** NATIVE function_call output items (accumulated by the caller across SSE events). */
   toolCallName?: string;
   toolCallArgsDelta?: string;
@@ -235,10 +235,11 @@ export function parseResponsesEvent(data: string): ResponsesEvent {
     return { reasoningDelta: o.delta };
   }
   // `response.incomplete` (max_output_tokens / content filter) also carries usage — don't drop it.
-  if ((o.type === "response.completed" || o.type === "response.incomplete") && o.response?.usage) {
+  if (o.type === "response.completed" || o.type === "response.incomplete") {
     return {
-      usage: { inputTokens: o.response.usage.input_tokens, outputTokens: o.response.usage.output_tokens },
-      ...(o.type === "response.incomplete" ? { incompleteReason: o.response.incomplete_details?.reason ?? "incomplete" } : {}),
+      ...(o.response?.usage ? { usage: { inputTokens: o.response.usage.input_tokens, outputTokens: o.response.usage.output_tokens } } : {}),
+      ...(o.type === "response.completed" ? { completed: true } : {}),
+      ...(o.type === "response.incomplete" ? { incompleteReason: o.response?.incomplete_details?.reason ?? "incomplete" } : {}),
     };
   }
   if (o.type === "response.failed" || o.type === "error") {
@@ -284,6 +285,14 @@ function fetchResponses(messages: Message[], options: CallOptions, credential: C
   );
 }
 
+export class ResponsesIncompleteError extends Error {
+  constructor(reason: string) {
+    const hint = reason === "max_output_tokens" ? " — output budget exhausted; raise maxTokens or lower reasoning effort" : "";
+    super(`OpenAI Codex response incomplete (finish_reason=${reason})${hint}.`);
+    this.name = "ResponsesIncompleteError";
+  }
+}
+
 /** Non-streaming call over the Codex backend (collects the streamed output). */
 export async function codexResponsesCall(messages: Message[], options: CallOptions, credential: Credential): Promise<string> {
   const response = await fetchResponses(messages, options, credential);
@@ -291,6 +300,7 @@ export async function codexResponsesCall(messages: Message[], options: CallOptio
   if (!response.body) return "";
   let out = "";
   let incompleteReason: string | undefined;
+  let completed = false;
   const toolAcc = new Map<number, { name: string; args: string }>();
   for await (const data of readSse(response.body)) {
     const ev = parseResponsesEvent(data);
@@ -300,8 +310,11 @@ export async function codexResponsesCall(messages: Message[], options: CallOptio
     accumulateResponsesToolCall(toolAcc, ev);
     if (ev.usage) options.onUsage?.(ev.usage);
     if (ev.incompleteReason) incompleteReason = ev.incompleteReason;
+    if (ev.completed) completed = true;
     if (ev.error) throw new ProviderStreamError("OpenAI Codex", ev.error, ev.errorCode);
   }
+  if (incompleteReason) throw new ResponsesIncompleteError(incompleteReason);
+  if (!completed && (out || toolAcc.size)) throw new ResponsesIncompleteError("missing_terminal_event");
   // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
   const envelope = serializeAccumulatedToolCalls(toolAcc);
   if (envelope) return envelope;
@@ -320,6 +333,7 @@ export async function* codexResponsesStream(
   if (!response.body) return;
   let yieldedAny = false;
   let incompleteReason: string | undefined;
+  let completed = false;
   const toolAcc = new Map<number, { name: string; args: string }>();
   for await (const data of readSse(response.body, options.onStreamActivity)) {
     const ev = parseResponsesEvent(data);
@@ -332,8 +346,11 @@ export async function* codexResponsesStream(
     accumulateResponsesToolCall(toolAcc, ev);
     if (ev.usage) options.onUsage?.(ev.usage);
     if (ev.incompleteReason) incompleteReason = ev.incompleteReason;
+    if (ev.completed) completed = true;
     if (ev.error) throw new ProviderStreamError("OpenAI Codex", ev.error, ev.errorCode);
   }
+  if (incompleteReason) throw new ResponsesIncompleteError(incompleteReason);
+  if (!completed && (yieldedAny || toolAcc.size)) throw new ResponsesIncompleteError("missing_terminal_event");
   // Native tool calls have no output_text deltas — yield the re-serialized envelope once.
   const envelope = serializeAccumulatedToolCalls(toolAcc);
   if (envelope) { yieldedAny = true; yield envelope; }

package/src/ai/providers/openai.ts

@@ -1,8 +1,8 @@
 import type { Credential } from "../../auth";
 import type { CallOptions, Message, ProviderAdapter } from "../types";
 import { readSse } from "../sse";
-import { providerHttpError } from "./errors";
-import { codexResponsesCall, codexResponsesStream } from "./openai-responses";
+import { providerHttpError, ProviderStreamError } from "./errors";
+import { codexResponsesCall, codexResponsesStream, ResponsesIncompleteError } from "./openai-responses";
 import { serializeToolCalls, serializeAccumulatedToolCalls } from "../../agent/tool-schemas";
 import { sanitizeJsonStrings } from "../../util/sanitize-json";
 import { createThinkSplitter, stripLeakedReasoningTags } from "../think-tags";
@@ -110,32 +110,11 @@ function emptyCompletionError(finishReason: string | undefined): Error {
   return new Error(`OpenAI returned no content${finishReason ? ` (finish_reason=${finishReason})` : ""}${hint}.`);
 }
 
-/** Scan `text` for the first BALANCED, syntactically valid JSON object that carries a
- *  `tool`/`tools` key — i.e. a complete jeo tool envelope. Brace-depth aware and string/
- *  escape safe so a `{` inside a JSON string never miscounts. Returns the raw object
- *  substring, or "" if none is complete. Used to salvage a truncated (finish_reason=length)
- *  reasoning stream when the model finished the actionable JSON before it ran out of budget. */
-function firstCompleteToolEnvelope(text: string): string {
-  for (let start = text.indexOf("{"); start !== -1; start = text.indexOf("{", start + 1)) {
-    let depth = 0, inStr = false, esc = false;
-    for (let i = start; i < text.length; i++) {
-      const ch = text[i];
-      if (esc) { esc = false; continue; }
-      if (ch === "\\") { esc = true; continue; }
-      if (ch === '"') { inStr = !inStr; continue; }
-      if (inStr) continue;
-      if (ch === "{") depth++;
-      else if (ch === "}" && --depth === 0) {
-        const candidate = text.slice(start, i + 1);
-        try {
-          const obj = JSON.parse(candidate) as Record<string, unknown>;
-          if (obj && (typeof obj.tool === "string" || Array.isArray(obj.tools))) return candidate;
-        } catch { /* not valid JSON — keep scanning from the next `{` */ }
-        break;
-      }
-    }
+function assertNormalFinish(finishReason: string | undefined): void {
+  if (finishReason && finishReason !== "stop" && finishReason !== "tool_calls" && finishReason !== "function_call") {
+    const hint = finishReason === "length" ? " — output budget exhausted; raise maxTokens or lower reasoning effort" : "";
+    throw new Error(`OpenAI response incomplete (finish_reason=${finishReason})${hint}.`);
   }
-  return "";
 }
 
 /** Recover a usable answer from the reasoning channel when `content` came back empty.
@@ -144,16 +123,10 @@ function firstCompleteToolEnvelope(text: string): string {
  *  `reasoning_content`/`reasoning` (or an inline `<think>…</think>` block) and leave
  *  `content` empty, which would otherwise kill the turn with "OpenAI returned no content".
  *
- *  Strips leaked think/scaffolding markup and returns the recovered text when the turn ended
- *  normally (no `finish_reason`, or `stop`). On a `length` finish the reasoning is truncated,
- *  but a thinking model often COMPLETES the JSON tool envelope before it runs out of budget —
- *  so we still salvage that complete envelope when present, and otherwise surface the
- *  actionable budget error. `content_filter` is never recovered (the reply was blocked).
+ *  Strips leaked think/scaffolding markup after a normal completion.
  *  Returns "" when nothing is recoverable. */
-function recoverFromReasoning(reasoning: string, finishReason: string | undefined): string {
+function recoverFromReasoning(reasoning: string): string {
   if (!reasoning) return "";
-  if (finishReason === "content_filter") return "";
-  if (finishReason === "length") return firstCompleteToolEnvelope(reasoning);
   return stripLeakedReasoningTags(reasoning);
 }
 
@@ -234,7 +207,10 @@ export const openaiAdapter: ProviderAdapter = {
     if (credential.kind === "api_key" && !options.baseUrl && isOpenAIReasoningModel(options.model)) {
       try {
         return await codexResponsesCall(messages, options, credential);
-      } catch { /* /responses unsupported for this model/account — fall through to chat */ }
+      } catch (e) {
+        if (e instanceof ResponsesIncompleteError || e instanceof ProviderStreamError) throw e;
+        // /responses unsupported for this model/account — fall through to chat.
+      }
     }
     const { url, headers, body } = openaiRequest(messages, options, credential, false);
     let response = await fetch(url, { method: "POST", headers, body, signal: options.signal });
@@ -251,6 +227,8 @@ export const openaiAdapter: ProviderAdapter = {
 
     const result = (await response.json()) as { choices: { message: { content?: string; reasoning_content?: string; reasoning?: string; tool_calls?: { function?: { name?: string; arguments?: string } }[] }; finish_reason?: string }[]; usage?: { prompt_tokens?: number; completion_tokens?: number } };
     if (result.usage) options.onUsage?.({ inputTokens: result.usage.prompt_tokens, outputTokens: result.usage.completion_tokens });
+    const finishReason = result.choices[0]?.finish_reason;
+    assertNormalFinish(finishReason);
     // Prefer a native tool call (re-serialized to canonical JSON) over any stray text.
     const envelope = serializeToolCalls(parseOpenaiToolCalls(result.choices[0]?.message?.tool_calls));
     if (envelope) return envelope;
@@ -260,9 +238,8 @@ export const openaiAdapter: ProviderAdapter = {
     // OpenAI-compatible servers) running reasoning models routinely emit the WHOLE reply —
     // including the `{"tool":…}` JSON — into `reasoning_content`/`reasoning` while leaving
     // `content` empty, which otherwise dies as a dead "returned no content" turn.
-    const finishReason = result.choices[0]?.finish_reason;
     const msg = result.choices[0]?.message;
-    const recovered = recoverFromReasoning(msg?.reasoning_content ?? msg?.reasoning ?? "", finishReason);
+    const recovered = recoverFromReasoning(msg?.reasoning_content ?? msg?.reasoning ?? "");
     if (recovered) return recovered;
     throw emptyCompletionError(finishReason);
   },
@@ -279,7 +256,7 @@ export const openaiAdapter: ProviderAdapter = {
         for await (const chunk of codexResponsesStream(messages, options, credential)) { started = true; yield chunk; }
         return;
       } catch (e) {
-        if (started) throw e; // mid-stream failure — cannot safely restart on another endpoint
+        if (started || e instanceof ResponsesIncompleteError || e instanceof ProviderStreamError) throw e;
         // else fall through to chat completions below
       }
     }
@@ -305,6 +282,7 @@ export const openaiAdapter: ProviderAdapter = {
     if (!response.body) return;
     let yieldedAny = false;
     let finishReason: string | undefined;
+    let receivedContent = false;
     // Mirror every reasoning delta into a local buffer so a content-less reply can be
     // recovered from the reasoning channel at end-of-stream (see recoverFromReasoning).
     let reasoningBuf = "";
@@ -323,6 +301,7 @@ export const openaiAdapter: ProviderAdapter = {
       }
       const raw = chunk.choices?.[0]?.delta?.content;
       if (raw) {
+        receivedContent = true;
         const visible = think.push(raw);
         if (visible) {
           yieldedAny = true;
@@ -347,6 +326,10 @@ export const openaiAdapter: ProviderAdapter = {
       if (chunk.choices?.[0]?.finish_reason) finishReason = chunk.choices[0].finish_reason;
       if (chunk.usage) options.onUsage?.({ inputTokens: chunk.usage.prompt_tokens, outputTokens: chunk.usage.completion_tokens });
     }
+    if (!finishReason && (receivedContent || reasoningBuf || toolAcc.size)) {
+      throw new Error("OpenAI response incomplete (missing finish_reason).");
+    }
+    assertNormalFinish(finishReason);
     const trailing = think.flush();
     if (trailing) { yieldedAny = true; yield trailing; }
     // Native tool calls stream as tool_calls argument fragments — re-serialize once at end.
@@ -356,7 +339,7 @@ export const openaiAdapter: ProviderAdapter = {
       // Recover from the reasoning channel before failing the turn. Local reasoning models
       // (LM Studio, llama.cpp, …) often stream the whole reply — JSON tool call included —
       // as reasoning/<think> with an empty `content`.
-      const recovered = recoverFromReasoning(reasoningBuf, finishReason);
+      const recovered = recoverFromReasoning(reasoningBuf);
       if (recovered) { yield recovered; return; }
       throw emptyCompletionError(finishReason);
     }

package/src/cli/runner.ts

@@ -410,6 +410,9 @@ function leadingGlobalFlag(argv: string[], targets: readonly string[]): boolean
 }
 export async function dispatch(argv: string[], ctx: DispatchContext): Promise<number> {
   const first = argv[0];
+  if (process.env.JEO_MESSENGER_SESSION_KEY && first !== "launch") {
+    throw new Error("SANDBOX_REQUIRED: messenger workers may only enter the sandboxed launch command");
+  }
 
   if (first === "--version" || first === "-v") {
     console.log(`${ctx.appName} v${ctx.version}`);

package/src/commands/approve.ts

@@ -5,15 +5,47 @@ import {
   readGlobalConfig,
   readWorkflowState,
   writeWorkflowState,
+  readWorkflowFile,
 } from "../agent/state";
 import { PlanSchema, normalizePlanShape, parseYaml } from "../agent/plan";
 import { getSubagentRole, subagentRoleIds } from "../agent/subagents";
+import { currentSandboxExecution } from "../agent/hooks";
 
 export interface ApprovePlanResult {
   ok: boolean;
   message: string;
 }
 
+export interface ApprovalPathInspection {
+  exists: boolean;
+  canonical: string;
+}
+
+/** Inspect only workspace paths in the guest; role configuration stays in the brain. */
+export async function inspectApprovalPath(filePath: string, cwd: string): Promise<ApprovalPathInspection> {
+  const resolved = path.resolve(cwd, filePath);
+  const sandbox = currentSandboxExecution();
+  if (sandbox) {
+    const result = await sandbox.supervisor.call("__workflow", { operation: "approvalPath", path: resolved }, { cwd, signal: sandbox.signal });
+    if (!result.success) throw new Error(result.error || "SANDBOX_WORKFLOW: approval path inspection failed");
+    const value: unknown = JSON.parse(result.output);
+    if (typeof value !== "object" || value === null || !("exists" in value) || typeof value.exists !== "boolean" || !("canonical" in value) || typeof value.canonical !== "string") {
+      throw new Error("SANDBOX_WORKFLOW: invalid approval path inspection");
+    }
+    return { exists: value.exists, canonical: value.canonical };
+  }
+  try {
+    await fs.access(resolved);
+  } catch {
+    return { exists: false, canonical: resolved };
+  }
+  try {
+    return { exists: true, canonical: await fs.realpath(resolved) };
+  } catch {
+    return { exists: true, canonical: resolved };
+  }
+}
+
 /** Core approval gate, shared by the `jeo approve` CLI command and the agent-facing
  *  `approve` tool (src/agent/approve-tool.ts). ALL of the plan-quality checks below
  *  (schema shape, known roles, persisted [OKAY] consensus verdict, hash-vs-consensus
@@ -29,9 +61,8 @@ export async function approvePlan(planPathInput: string, cwd: string): Promise<A
   const resolvedInputPath = path.resolve(cwd, planPathInput);
 
   // Rejection if the plan file doesn't exist on disk
-  try {
-    await fs.access(resolvedInputPath);
-  } catch {
+  const inputPath = await inspectApprovalPath(resolvedInputPath, cwd);
+  if (!inputPath.exists) {
     return { ok: false, message: `[ERROR] Plan file not found: ${resolvedInputPath}` };
   }
 
@@ -47,16 +78,9 @@ export async function approvePlan(planPathInput: string, cwd: string): Promise<A
 
   // Compare canonical (symlink-resolved) paths so a relative arg, an absolute arg,
   // or a /var↔/private/var (macOS) form all match the stored plan path.
-  const canonical = async (p: string): Promise<string> => {
-    try {
-      return await fs.realpath(p);
-    } catch {
-      return p;
-    }
-  };
   const resolvedStatePath = path.resolve(cwd, ralplanState.plan_path);
-  const [canonInput, canonState] = await Promise.all([canonical(resolvedInputPath), canonical(resolvedStatePath)]);
-  if (canonInput !== canonState) {
+  const statePath = await inspectApprovalPath(resolvedStatePath, cwd);
+  if (inputPath.canonical !== statePath.canonical) {
     return {
       ok: false,
       message:
@@ -73,7 +97,7 @@ export async function approvePlan(planPathInput: string, cwd: string): Promise<A
   // aborting later at execution time.
   let planContent = "";
   try {
-    planContent = await fs.readFile(resolvedInputPath, "utf-8");
+    planContent = await readWorkflowFile(resolvedInputPath, cwd);
     const parsed = PlanSchema.safeParse(normalizePlanShape(parseYaml(planContent)));
     if (!parsed.success) {
       return {

package/src/commands/launch/flags.ts

@@ -253,12 +253,13 @@ export const TOOL_DESCRIPTIONS: Record<string, string> = {
   search: "search {pattern, globPattern?, ignoreCase?, context?, maxMatches?} — grep (context: N lines around each match)",
   ls: "ls     {dirPath}                   — list a directory's entries (dirs first)",
   computer: "computer {action, x?, y?, text?, key?, deltaX?, deltaY?, duration?, actions?} — desktop automation (screenshot, click, double_click, move, drag, scroll, type, keypress, wait, batch)",
+  sandbox_request: "sandbox_request {host, mode:'ro'|'rw'} requests additional session filesystem access; {action:'status'} reports requests, active grants and guest mount paths. Only direct terminal or authenticated remote /sandbox controls can approve, deny, or revoke access.",
 };
 
 export function buildToolProtocol(allowedTools: Set<string>): string {
   const lines: string[] = ["You have these tools (call exactly ONE per step):"];
   let num = 1;
-  for (const name of ["read", "write", "edit", "bash", "find", "search", "ls", "computer"]) {
+  for (const name of ["read", "write", "edit", "bash", "find", "search", "ls", "computer", "sandbox_request"]) {
     if (allowedTools.has(name)) {
       lines.push(`${num}. ${TOOL_DESCRIPTIONS[name]}`);
       num++;