atom-agent 1.1.0 → 1.3.0

package/dist/zen.js

@@ -5,14 +5,20 @@
 // different Zen request shapes and are out of scope.
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
-import { MAX_TOOL_STEPS, TOOL_DEFINITIONS, } from "./tools.js";
+import { MAX_TOOL_STEPS, allToolDefinitions, getExtensionPromptHints, } from "./tools.js";
 import { chatEndpointFor, getProvider, isLocalProviderId, modelsUrlForProvider, providerLabel, } from "./providers.js";
 import { discoverLocalProvider } from "./local-discovery.js";
-import { ANTHROPIC_VERSION, anthropicHeaders, buildAnthropicBody, buildGeminiBody, geminiChatUrl, geminiGenerateUrl, geminiHeaders, parseAnthropicJson, parseAnthropicModelsList, parseGeminiJson, parseGeminiModelsList, parseOpenAIModelsList, readAnthropicSSEMessage, readGeminiSSEMessage, isStallError, readWithStall, } from "./adapters.js";
+import { ANTHROPIC_MAX_TOKENS, ANTHROPIC_VERSION, anthropicHeaders, anthropicThinkingFor, buildAnthropicBody, buildGeminiBody, geminiChatUrl, geminiGenerateUrl, geminiHeaders, geminiThinkingLevelFor, isEffortRejection, parseAnthropicJson, parseAnthropicModelsList, parseGeminiJson, parseGeminiModelsList, parseOpenAIModelsList, readAnthropicSSEMessage, readGeminiSSEMessage, isStallError, readWithStall, sseStallTimeoutMs, } from "./adapters.js";
 export { isStallError, readWithStall, sseStallTimeoutMs } from "./adapters.js";
 import { KILO_FALLBACK_MODELS, fetchKiloModelsWithStatus, normalizeKiloChatError, } from "./kilo.js";
 import { splitSystemHead } from "./prompt-cache.js";
 import { SYSTEM_PROMPT } from "./system.js";
+// Provider hooks (ticket 08): extension context/pre-request/post-response
+// hooks fire per POST in the three transports below (openai-chat,
+// anthropic-messages, gemini-generate), so every provider kind is covered
+// through the chatCompletionForProvider dispatcher. All apply/notify helpers
+// never throw (fail-open), so hooks can never break the turn.
+import { afterResponseObservers, applyBeforeRequest, applyContextTransform, beforeRequestInterceptors, contextTransformers, notifyAfterResponse, snapshotResponseHeaders, } from "./tools/provider-hooks.js";
 export { MAX_TOOL_STEPS };
 // Re-exported so existing `SYSTEM_PROMPT` imports keep working; the
 // owner-editable source of truth lives in src/system.ts.
@@ -22,61 +28,66 @@ export const MODELS_URL_DEFAULT = "https://opencode.ai/zen/v1/models";
 // Task 5 default: strongest tool-reliable chat/completions default available,
 // verified against the live /models list + https://opencode.ai/docs/zen on
 // 2026-09-08 (endpoint chat/completions, Tool Calls support, not deprecated,
-// in REASONING_EFFORT_SUPPORTED_MODELS, verified 1M context window). Free
-// models (big-pickle etc.) stay in FALLBACK_MODELS, selectable via /model.
+// verified 1M context window). Free models (big-pickle etc.) stay in
+// FALLBACK_MODELS, selectable via /model.
 export const DEFAULT_MODEL = "deepseek-v4-pro";
 export const AGENTS_CHAR_CAP = 12 * 1024;
-// ---- Conversation-history budget (deterministic, no extra model calls) ----
-// Long sessions can't bloat context, cost, and latency: the shared loop core
-// trims history to BOTH caps before every POST (uniform across providers).
-// The caps themselves live in the ContextManager module (re-exported here so
-// existing importers keep working); precedence per knob stays env override
-// (when valid) → project atom.json → global atom.json → compiled default:
-// - ATOM_MAX_HISTORY_MESSAGES, clamped to 10–1000 (default 100)
-// - ATOM_MAX_HISTORY_CHARS, clamped to 10_000–2_000_000 (default 200_000)
+// ---- Conversation history: uncapped ----
+// Long sessions ride on compaction, not truncation: the shared loop core
+// sends the full history on every POST (uniform across providers) and
+// auto-compact at ~83% of the verified window is the only pressure valve.
+// There are no message/char caps and no trim step.
 export { toolStepBudget } from "./agent/loop.js";
-// Reasoning effort (session state in the App, default "default").
-// Wire values are exactly default/low/medium/high/max. "default" never
-// sends a param. NOTE: the user asked for `xhigh`, but the only VERIFIED
-// valid values (OpenCode Zen docs/changelog: Thinking Effort
-// Default/Max/High/Medium/Low, sent as `reasoning_effort`) use `Max`, so
-// the top setting is `Max`, sent on the wire as `max`.
+// Reasoning effort (session state in the App, default "auto").
+// Wire values are low/medium/high/max. "auto" never sends a param: it lets
+// the model decide. The top setting is `Max`, sent on the wire as `max`.
+// Support is assumed for every model on every provider kind — the server is
+// authoritative: a model that truly lacks the knob fails the POST with a
+// 400 naming the effort param, and the transports below retry once without
+// it (see isEffortRejection in adapters.ts). Nothing is preemptively gated
+// by model name, so "(unsupported)" only ever reflects an actual rejection.
 export const EFFORT_OPTIONS = [
-    "default",
+    "auto",
     "low",
     "medium",
     "high",
     "max",
 ];
-// Verified-support set for `reasoning_effort`: the chat/completions-family
-// models Zen documents Thinking Effort for. Any other model omits the
-// param (setting kept, warning shown, status shows "(unsupported)").
-export const REASONING_EFFORT_SUPPORTED_MODELS = new Set([
-    "kimi-k2.5",
-    "kimi-k2.6",
-    "glm-5.1",
-    "glm-5.2",
-    "deepseek-v4-pro",
-    "deepseek-v4-flash",
-]);
-export function isEffortSupported(model) {
-    return REASONING_EFFORT_SUPPORTED_MODELS.has(model);
+// Canonicalize a stored/picked effort value. "default" is the pre-auto name
+// for the same level (old saves, old atom.json) and maps to "auto"; unknown
+// values fall back to "auto" instead of stranding the session.
+export function normalizeEffort(value) {
+    if (value === "default" || value === "auto")
+        return "auto";
+    if (value === "low" || value === "medium" || value === "high" || value === "max") {
+        return value;
+    }
+    return "auto";
+}
+// Effort support is provider-wide, never per-model: every known provider
+// kind has a wire mapping (reasoning_effort on openai-chat, thinking on
+// anthropic-messages, thinkingLevel on gemini-generate). Returns false only
+// for an empty model or an unknown provider id — the actual per-model truth
+// comes from the server at POST time (see above).
+export function isEffortSupported(model, provider) {
+    if (!model)
+        return false;
+    if (provider === undefined)
+        return true;
+    return getProvider(provider) !== undefined;
 }
 // Wire value for the POST body, or undefined when the param must be
-// omitted (Default, unsupported model, or unknown effort string).
-export function reasoningEffortParam(effort, model) {
-    if (!effort || effort === "default")
+// omitted (Auto, or an unknown effort string). The `model` argument is
+// accepted for backward compatibility and intentionally ignored: support is
+// assumed for every model, with server rejection as the only veto.
+export function reasoningEffortParam(effort, _model) {
+    const normalized = normalizeEffort(effort);
+    if (normalized === "auto")
         return undefined;
-    if (!isEffortSupported(model))
-        return undefined;
-    if (effort === "low" || effort === "medium" || effort === "high" || effort === "max") {
-        return effort;
-    }
-    return undefined;
+    return normalized;
 }
-export { CHARS_PER_TOKEN, MAX_HISTORY_CHARS, MAX_HISTORY_MESSAGES, createContextManager, estimateTokensForChars, historyCharBudget, historyChars, historyMessageBudget, messageChars, truncateHistoryWithCaps, } from "./context-manager.js";
+export { CHARS_PER_TOKEN, createContextManager, estimateTokensForChars, historyChars, messageChars, } from "./context-manager.js";
 export { openTodoNeedles } from "./agent/gates.js";
-export { truncateHistory } from "./agent/loop.js";
 function finiteCount(value) {
     return typeof value === "number" && Number.isFinite(value) && value >= 0
         ? Math.floor(value)
@@ -337,11 +348,20 @@ export async function fetchModels(endpoint, apiKey) {
 // - Slots with an id but no name at [DONE] are dropped with an onWarning
 //   message and never returned (keeps assistant/tool pairing valid).
 // - A stream that ends without [DONE] throws a truncation error.
+// - A response flagged `finish_reason: "length"` (output limit cut the
+//   response off, so tool arguments are incomplete) does NOT throw: it
+//   returns normally with `truncated: true` so the loop can fail each carried
+//   tool call inline and continue the turn. Transport failures (aborted
+//   connections, stalls, empty replies) keep throwing.
 // - A stream silent longer than the stall budget (env ATOM_STALL_TIMEOUT_MS,
 //   default 60s; the clock resets on every received chunk) throws a
 //   Truncated-stream stall error — permanent, never retried, same contract
 //   as a dead connection (verified live: free-tier routers can stall a
 //   200-OK stream mid-generation for minutes).
+// - Queue comments (`: ...`) and keep-alives carry bytes but no model output:
+//   only `data:` payload lines refresh the data-silence clock, so minutes of
+//   `: KILO PROCESSING` while queued fail fast instead of hanging the turn
+//   (same budget, same permanent contract).
 // - A stream with zero "data:" lines is treated as a non-SSE JSON payload
 //   (tolerance for bodies that are really single-shot JSON) and parsed as
 //   choices[0].message like the non-streaming fallback.
@@ -361,9 +381,29 @@ export async function readSSEMessage(res, opts) {
     // reasoning label seen in any delta.
     let streamUsage;
     let streamReasoning;
+    // Output-limit flag (see contract above): set when any streamed choice
+    // reports `finish_reason: "length"`. Returned on the result — never thrown.
+    let lengthTruncated = false;
     // Accumulated thinking text (see onThinking): kept apart from fullText so
     // reasoning never leaks into the answer, history, or tool arguments.
     let fullThinking = "";
+    // Data-silence tracking (see throwIfDataStalled): timestamp of the last
+    // `data:` payload line. Queue comments (`: KILO PROCESSING`) and keep-alive
+    // comments carry bytes but no model output — they advance the raw stream
+    // but must NOT extend the stall budget (live-proven: minutes of comments
+    // while a free-tier request sits queued).
+    let lastDataAt = Date.now();
+    // Fail fast when the stream flows (or idles) with no model output: same
+    // permanent Truncated contract as a dead connection (passes through every
+    // catch below untouched), same env knob as the per-read byte race. Checked
+    // after each drained chunk — legitimately slow generations keep emitting
+    // `data:` lines, so only true silence trips it.
+    function throwIfDataStalled() {
+        const budget = sseStallTimeoutMs();
+        if (Date.now() - lastDataAt > budget) {
+            throw new Error(`Truncated stream from model (stall: no output for ${budget}ms — queued or stalled upstream; resend to retry).`);
+        }
+    }
     function announceStreaming() {
         if (!streamingAnnounced) {
             streamingAnnounced = true;
@@ -386,6 +426,7 @@ export async function readSSEMessage(res, opts) {
         if (!line.startsWith("data:"))
             return; // event:/id:/retry: ignored
         sawData = true;
+        lastDataAt = Date.now();
         let payload = line.slice("data:".length);
         if (payload.startsWith(" "))
             payload = payload.slice(1);
@@ -410,6 +451,10 @@ export async function readSSEMessage(res, opts) {
         }
         const choice = evt
             ?.choices?.[0];
+        // Output-limit marker rides on the choice, beside the delta — any chunk
+        // reporting it means the tool arguments below are incomplete.
+        if (choice?.finish_reason === "length")
+            lengthTruncated = true;
         const delta = (choice?.delta ?? choice?.message);
         if (typeof delta !== "object" || delta === null)
             return;
@@ -533,6 +578,7 @@ export async function readSSEMessage(res, opts) {
                     rawText += text;
                     buffer += text;
                     drainBuffer();
+                    throwIfDataStalled();
                     if (sawDone) {
                         try {
                             await reader.cancel?.();
@@ -569,6 +615,7 @@ export async function readSSEMessage(res, opts) {
                     rawText += text;
                     buffer += text;
                     drainBuffer();
+                    throwIfDataStalled();
                     if (sawDone)
                         break;
                 }
@@ -612,6 +659,10 @@ export async function readSSEMessage(res, opts) {
         throw new Error(`Truncated stream from model (connection aborted: ${e instanceof Error ? e.message : String(e)}).`);
     }
     // Tolerance: a body with no SSE data lines is really single-shot JSON.
+    // (The data-silence bound applies only once real SSE traffic exists, so
+    // whole-body JSON payloads are never false-tripped by it.)
+    if (sawData)
+        throwIfDataStalled();
     if (!sawData) {
         const candidate = rawText.trim();
         if (candidate.length > 0) {
@@ -628,6 +679,8 @@ export async function readSSEMessage(res, opts) {
                         content,
                         tool_calls: calls.length > 0 ? calls : undefined,
                     };
+                    if (data?.choices?.[0]?.finish_reason === "length")
+                        result.truncated = true;
                     const usage = parseUsage(data?.usage);
                     if (usage !== undefined)
                         result.usage = usage;
@@ -675,6 +728,8 @@ export async function readSSEMessage(res, opts) {
         content: fullText.length > 0 ? fullText : null,
         tool_calls: calls.length > 0 ? calls : undefined,
     };
+    if (lengthTruncated)
+        result.truncated = true;
     if (streamUsage !== undefined)
         result.usage = streamUsage;
     if (streamReasoning !== undefined)
@@ -683,16 +738,21 @@ export async function readSSEMessage(res, opts) {
 }
 // Streaming chat POST with tools attached (tool_choice omitted, so the
 // default auto applies). Sends {..., stream:true} plus `reasoning_effort`
-// ONLY when opts.reasoningEffort is non-Default AND the model is in
-// REASONING_EFFORT_SUPPORTED_MODELS (see reasoningEffortParam); otherwise
-// the param is omitted. Parses the SSE event stream (see readSSEMessage).
+// whenever opts.reasoningEffort is non-Auto (see reasoningEffortParam) —
+// for every model, on every provider routed through this transport.
+// A 400 naming the knob means the model truly lacks it: warn once via
+// onWarning and retry without it. Parses the SSE event stream (see
+// readSSEMessage).
 // When the response has no SSE body (plain {ok, json()} mocks and other
 // non-streaming payloads) it falls back to the original single-JSON parse,
 // unchanged. Returns the raw assistant message: either final content or
 // tool_calls the caller must execute, plus `usage`/`reasoning` only when
 // the response actually carried them (usage: top-level `usage` on JSON or
 // SSE final chunks; reasoning: message/delta reasoning metadata).
-// Throws on HTTP error, empty reply, or a truncated stream.
+// Throws on HTTP error, empty reply, or a truncated stream (aborted
+// connection / stall / missing [DONE]). A response flagged
+// `finish_reason: "length"` instead returns normally with `truncated: true`
+// (the loop fails its tool calls inline and continues).
 // - Network throws and HTTP 429/500/502/503/504 are retried up to
 //   MAX_RETRIES (10) with 1s→2s→4s… backoff, honoring Retry-After capped
 //   at 30s.
@@ -703,10 +763,25 @@ export async function readSSEMessage(res, opts) {
 // the dispatcher passes providerLabel(provider) for non-zen openai-chat
 // providers so users see e.g. `OpenAI HTTP 401` instead of `Zen HTTP 401`.
 // Legacy `function_call` shape is intentionally ignored.
-export async function chatCompletion(endpoint, apiKey, model, history, opts, errorLabel = "Zen") {
+export async function chatCompletion(endpoint, apiKey, model, history, 
+// providerId (ticket 08): hook attribution for the shared openai-chat
+// transport — the dispatcher passes its provider id, direct zen callers
+// omit it and default to "opencode-zen". Optional, wire-compatible.
+opts, errorLabel = "Zen") {
     const sleep = opts?.sleep ?? defaultSleep;
     const signal = opts?.signal ?? null;
+    const hookProvider = opts?.providerId ?? "opencode-zen";
+    // Context hooks (ticket 08) run once per call — not per retry — over a
+    // per-POST copy; the loop transcript array is never mutated. Fail-open:
+    // a throwing handler degrades to the untransformed messages. Zero-cost
+    // when no hooks are registered: the apply path is skipped entirely (no
+    // extra awaits per POST), so hook-free turns keep byte-identical timing.
+    const contextHooks = contextTransformers();
+    const outgoingHistory = contextHooks.length > 0 ? await applyContextTransform(contextHooks, history) : history;
     let lastError = null;
+    // Server-authoritative unsupported: when a 400 names the effort knob, the
+    // flag below drops it and the loop retries without it (once per call).
+    let effortDropped = false;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         try {
             throwIfCancelled(signal);
@@ -716,7 +791,9 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
             catch {
                 // ignore observer errors
             }
-            const effortParam = reasoningEffortParam(opts?.reasoningEffort, model);
+            const effortParam = effortDropped
+                ? undefined
+                : reasoningEffortParam(opts?.reasoningEffort, model);
             const summaryOpts = opts;
             // Stable-prefix split (prompt-cache architecture): history[0]'s env
             // tail becomes its own system message so the stable head + tools stay
@@ -724,16 +801,18 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
             // system messages concatenate on every OpenAI-protocol server, so this
             // is content-neutral. No env tail (tests, old saves) → history passes
             // through untouched, byte-identical to before.
-            const messages = splitSystemHead(history);
+            const messages = splitSystemHead(outgoingHistory);
             const payload = {
                 model,
                 messages,
                 stream: true,
             };
             // Compaction path only: tools disabled means NO `tools` key at all
-            // (asserted in tests); the normal loop always sends the schema.
+            // (asserted in tests); the normal loop always sends the schema —
+            // builtins plus extension-registered custom tools, so the model can
+            // discover and call them exactly like builtins.
             if (!summaryOpts?.disableTools) {
-                payload["tools"] = TOOL_DEFINITIONS;
+                payload["tools"] = allToolDefinitions();
             }
             // Compaction path only: cap output (openai-chat kind uses max_tokens).
             if (typeof summaryOpts?.maxOutputTokens === "number" &&
@@ -743,21 +822,73 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
             }
             if (effortParam !== undefined)
                 payload["reasoning_effort"] = effortParam;
+            // Pre-request hooks (ticket 08) run per POST attempt: payload
+            // replacement must be a record (else ignored — downstream JSON/fetch
+            // handling is never bypassed); header merge honors deletions.
+            // Zero-cost when unregistered (see context hooks above).
+            const preHooks = beforeRequestInterceptors();
+            const outgoing = preHooks.length > 0
+                ? await applyBeforeRequest(preHooks, {
+                    provider: hookProvider,
+                    model,
+                    url: endpoint,
+                    payload,
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                    },
+                })
+                : {
+                    payload,
+                    headers: {
+                        "Content-Type": "application/json",
+                        ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+                    },
+                };
             const res = await fetch(endpoint, {
                 method: "POST",
                 // Anonymous-capable providers (Kilo free models) omit Authorization
                 // when no key is configured — never an empty `Bearer `. Keyed
                 // providers always pass a key (gated by providerNeedsKey), so their
                 // behavior is unchanged.
-                headers: {
-                    "Content-Type": "application/json",
-                    ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
-                },
-                body: JSON.stringify(payload),
+                headers: outgoing.headers,
+                body: JSON.stringify(outgoing.payload),
                 ...(signal ? { signal } : {}),
             });
+            // Post-response observers (ticket 08): every resolved POST (ok and
+            // HTTP-error alike), fail-open — never break the turn. Zero-cost when
+            // unregistered (the header snapshot is only built for live observers).
+            const postHooks = afterResponseObservers();
+            if (postHooks.length > 0) {
+                await notifyAfterResponse(postHooks, {
+                    provider: hookProvider,
+                    model,
+                    url: endpoint,
+                    status: res.status,
+                    ok: res.ok,
+                    headers: snapshotResponseHeaders(res),
+                });
+            }
             if (!res.ok) {
                 const errText = await safeErrorText(res);
+                // The server is the authority on effort support: a 400 naming the
+                // knob means this model/deployment has no such control — warn,
+                // drop the knob, and retry without it (setting kept). Any other
+                // 400 keeps failing loudly below.
+                if (res.status === 400 &&
+                    effortParam !== undefined &&
+                    !effortDropped &&
+                    isEffortRejection(errText)) {
+                    effortDropped = true;
+                    try {
+                        opts?.onWarning?.(`reasoning effort "${effortParam}" is not supported by ${model} — continuing without it`);
+                    }
+                    catch {
+                        // ignore observer errors
+                    }
+                    throwIfCancelled(signal);
+                    continue;
+                }
                 const err = new Error(`${errorLabel} HTTP ${res.status}: ${errText.slice(0, 300)}`);
                 if (!RETRYABLE_STATUS.has(res.status))
                     throw err;
@@ -811,6 +942,8 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
                     content,
                     tool_calls: calls.length > 0 ? calls : undefined,
                 };
+                if (data?.choices?.[0]?.finish_reason === "length")
+                    result.truncated = true;
                 const usage = parseUsage(data?.usage);
                 if (usage !== undefined)
                     result.usage = usage;
@@ -861,16 +994,19 @@ export async function chatCompletion(endpoint, apiKey, model, history, opts, err
 }
 // Agentic loop for one user turn: thin wrapper over the shared runLoopWithChat
 // core below (single loop implementation). Send → while the response carries
-// tool_calls (max MAX_TOOL_STEPS tool rounds), append the assistant message,
-// execute each tool locally, append {role:'tool'} results, resend.
+// tool_calls (uncapped by default; explicit opts.maxSteps still caps), append
+// the assistant message, execute each tool locally, append {role:'tool'}
+// results, resend.
 // Streaming: each POST streams SSE tokens (onToken gets the growing text,
 // onPhase reports thinking|streaming|tool|retry|done, onToolDelta fires when
 // a tool name first appears mid-stream). A model that returns no tool_calls
 // ends the loop (graceful fallback for models without tool support). Tool
 // errors are results the model sees — NOTHING is rolled back here; only a
-// POST failure (HTTP/network/empty/truncated) throws (and the caller rolls
+// POST failure (HTTP/network/empty/stalled-stream) throws (and the caller rolls
 // back the user turn, as before; the caller preserves any streamed partial
-// on display).
+// on display). A length-truncated response (`finish_reason: "length"`) does
+// not throw: the loop fails each carried tool call inline with a repair
+// error and continues to the next model round.
 export async function runAgenticLoop(endpoint, apiKey, model, history, opts) {
     return runLoopWithChat((h, o) => chatCompletion(endpoint, apiKey, model, h, {
         onToken: o?.onToken,
@@ -904,11 +1040,16 @@ export function loadAgentsPrompt(cwd = process.cwd()) {
     }
 }
 export function buildSystemPrompt(cwd = process.cwd()) {
-    // Two layers: src/system.ts base one-liner + repo AGENTS.md overlay.
-    // Owner knobs: edit the one-liner in src/system.ts for the base identity;
-    // add repo instructions to AGENTS.md for the overlay.
+    // Three layers: src/system.ts base one-liner + repo AGENTS.md overlay +
+    // extension prompt hints (ticket 06). The hints ride the existing assembly
+    // — no parallel prompt pipeline: when none are registered the result is
+    // byte-identical to the two-layer form.
     const extra = loadAgentsPrompt(cwd);
-    return extra ? `${SYSTEM_PROMPT}\n\n${extra}` : SYSTEM_PROMPT;
+    const base = extra ? `${SYSTEM_PROMPT}\n\n${extra}` : SYSTEM_PROMPT;
+    const hints = getExtensionPromptHints();
+    if (hints.length === 0)
+        return base;
+    return `${base}\n\n## Extension hints\n${hints.map((h) => `- ${h}`).join("\n")}`;
 }
 function providerHttpError(provider, status, text) {
     return new Error(`${providerLabel(provider)} HTTP ${status}: ${text.slice(0, 300)}`);
@@ -916,7 +1057,17 @@ function providerHttpError(provider, status, text) {
 export async function chatCompletionAnthropic(apiKey, model, history, opts) {
     const sleep = opts?.sleep ?? defaultSleep;
     const signal = opts?.signal ?? null;
+    // Ticket 08: same per-POST hook contract as the openai-chat path above
+    // (context once per call, pre/post per attempt, all fail-open, zero-cost
+    // when unregistered).
+    const anthropicContextHooks = contextTransformers();
+    const outgoingHistory = anthropicContextHooks.length > 0
+        ? await applyContextTransform(anthropicContextHooks, history)
+        : history;
     let lastError = null;
+    // Same server-authoritative unsupported contract as the openai-chat path:
+    // a 400 naming the thinking knob drops it for the rest of the call.
+    let anthropicEffortDropped = false;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         try {
             throwIfCancelled(signal);
@@ -927,7 +1078,7 @@ export async function chatCompletionAnthropic(apiKey, model, history, opts) {
                 // ignore
             }
             const summaryOpts = opts;
-            const base = buildAnthropicBody(history, model, {
+            const base = buildAnthropicBody(outgoingHistory, model, {
                 includeTools: !summaryOpts?.disableTools,
             });
             const body = { ...base, stream: true };
@@ -938,14 +1089,62 @@ export async function chatCompletionAnthropic(apiKey, model, history, opts) {
                 summaryOpts.maxOutputTokens > 0) {
                 body["max_tokens"] = Math.floor(summaryOpts.maxOutputTokens);
             }
+            // /effort maps to the native thinking budget (Auto omits it; a cap too
+            // small for the 1024 minimum omits it too — see anthropicThinkingFor).
+            const anthropicEffort = anthropicEffortDropped
+                ? undefined
+                : reasoningEffortParam(opts?.reasoningEffort, model);
+            const anthropicBudget = anthropicEffort !== undefined
+                ? anthropicThinkingFor(anthropicEffort, typeof body["max_tokens"] === "number"
+                    ? body["max_tokens"]
+                    : ANTHROPIC_MAX_TOKENS)
+                : undefined;
+            if (anthropicBudget !== undefined) {
+                body["thinking"] = { type: "enabled", budget_tokens: anthropicBudget };
+            }
+            const anthropicPreHooks = beforeRequestInterceptors();
+            const outgoing = anthropicPreHooks.length > 0
+                ? await applyBeforeRequest(anthropicPreHooks, {
+                    provider: "anthropic",
+                    model,
+                    url: "https://api.anthropic.com/v1/messages",
+                    payload: body,
+                    headers: anthropicHeaders(apiKey),
+                })
+                : { payload: body, headers: anthropicHeaders(apiKey) };
             const res = await fetch("https://api.anthropic.com/v1/messages", {
                 method: "POST",
-                headers: anthropicHeaders(apiKey),
-                body: JSON.stringify(body),
+                headers: outgoing.headers,
+                body: JSON.stringify(outgoing.payload),
                 ...(signal ? { signal } : {}),
             });
+            const anthropicPostHooks = afterResponseObservers();
+            if (anthropicPostHooks.length > 0) {
+                await notifyAfterResponse(anthropicPostHooks, {
+                    provider: "anthropic",
+                    model,
+                    url: "https://api.anthropic.com/v1/messages",
+                    status: res.status,
+                    ok: res.ok,
+                    headers: snapshotResponseHeaders(res),
+                });
+            }
             if (!res.ok) {
                 const errText = await safeErrorText(res);
+                if (res.status === 400 &&
+                    anthropicBudget !== undefined &&
+                    !anthropicEffortDropped &&
+                    isEffortRejection(errText)) {
+                    anthropicEffortDropped = true;
+                    try {
+                        opts?.onWarning?.(`reasoning effort "${anthropicEffort}" is not supported by ${model} — continuing without it`);
+                    }
+                    catch {
+                        // ignore observer errors
+                    }
+                    throwIfCancelled(signal);
+                    continue;
+                }
                 const err = providerHttpError("anthropic", res.status, errText);
                 if (!RETRYABLE_STATUS.has(res.status))
                     throw err;
@@ -1005,7 +1204,17 @@ export async function chatCompletionAnthropic(apiKey, model, history, opts) {
 export async function chatCompletionGemini(apiKey, model, history, opts) {
     const sleep = opts?.sleep ?? defaultSleep;
     const signal = opts?.signal ?? null;
+    // Ticket 08: same per-POST hook contract as the openai-chat path above
+    // (context once per call, pre/post per attempt, all fail-open, zero-cost
+    // when unregistered).
+    const geminiContextHooks = contextTransformers();
+    const outgoingHistory = geminiContextHooks.length > 0
+        ? await applyContextTransform(geminiContextHooks, history)
+        : history;
     let lastError = null;
+    // Same server-authoritative unsupported contract as the other paths: a
+    // 400 naming the thinking knob drops it for the rest of the call.
+    let geminiEffortDropped = false;
     for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
         try {
             throwIfCancelled(signal);
@@ -1016,7 +1225,7 @@ export async function chatCompletionGemini(apiKey, model, history, opts) {
                 // ignore
             }
             const summaryOpts = opts;
-            const body = buildGeminiBody(history, model, {
+            const body = buildGeminiBody(outgoingHistory, model, {
                 includeTools: !summaryOpts?.disableTools,
                 ...(typeof summaryOpts?.maxOutputTokens === "number" &&
                     Number.isFinite(summaryOpts.maxOutputTokens) &&
@@ -1024,14 +1233,65 @@ export async function chatCompletionGemini(apiKey, model, history, opts) {
                     ? { maxOutputTokens: Math.floor(summaryOpts.maxOutputTokens) }
                     : {}),
             });
+            // /effort maps to the native thinkingLevel (Auto omits it; Max rides
+            // high, the deepest level the API offers). Merged into
+            // generationConfig so a compaction maxOutputTokens cap survives.
+            const geminiEffort = geminiEffortDropped
+                ? undefined
+                : reasoningEffortParam(opts?.reasoningEffort, model);
+            const geminiLevel = geminiEffort !== undefined ? geminiThinkingLevelFor(geminiEffort) : undefined;
+            if (geminiLevel !== undefined) {
+                const gc = typeof body.generationConfig === "object" && body.generationConfig !== null
+                    ? { ...body.generationConfig }
+                    : {};
+                body.generationConfig = {
+                    ...gc,
+                    thinkingConfig: { thinkingLevel: geminiLevel },
+                };
+            }
+            const geminiPreHooks = beforeRequestInterceptors();
+            const outgoing = geminiPreHooks.length > 0
+                ? await applyBeforeRequest(geminiPreHooks, {
+                    provider: "google-gemini",
+                    model,
+                    url: geminiChatUrl(model),
+                    payload: body,
+                    headers: geminiHeaders(apiKey),
+                })
+                : { payload: body, headers: geminiHeaders(apiKey) };
             const res = await fetch(geminiChatUrl(model), {
                 method: "POST",
-                headers: geminiHeaders(apiKey),
-                body: JSON.stringify(body),
+                headers: outgoing.headers,
+                body: JSON.stringify(outgoing.payload),
                 ...(signal ? { signal } : {}),
             });
+            const geminiPostHooks = afterResponseObservers();
+            if (geminiPostHooks.length > 0) {
+                await notifyAfterResponse(geminiPostHooks, {
+                    provider: "google-gemini",
+                    model,
+                    url: geminiChatUrl(model),
+                    status: res.status,
+                    ok: res.ok,
+                    headers: snapshotResponseHeaders(res),
+                });
+            }
             if (!res.ok) {
                 const errText = await safeErrorText(res);
+                if (res.status === 400 &&
+                    geminiLevel !== undefined &&
+                    !geminiEffortDropped &&
+                    isEffortRejection(errText)) {
+                    geminiEffortDropped = true;
+                    try {
+                        opts?.onWarning?.(`reasoning effort "${geminiEffort}" is not supported by ${model} — continuing without it`);
+                    }
+                    catch {
+                        // ignore observer errors
+                    }
+                    throwIfCancelled(signal);
+                    continue;
+                }
                 const err = providerHttpError("google-gemini", res.status, errText);
                 if (!RETRYABLE_STATUS.has(res.status))
                     throw err;
@@ -1063,10 +1323,20 @@ export async function chatCompletionGemini(apiKey, model, history, opts) {
                     throwIfCancelled(signal);
                     const res2 = await fetch(geminiGenerateUrl(model), {
                         method: "POST",
-                        headers: geminiHeaders(apiKey),
-                        body: JSON.stringify(body),
+                        headers: outgoing.headers,
+                        body: JSON.stringify(outgoing.payload),
                         ...(signal ? { signal } : {}),
                     });
+                    if (geminiPostHooks.length > 0) {
+                        await notifyAfterResponse(geminiPostHooks, {
+                            provider: "google-gemini",
+                            model,
+                            url: geminiGenerateUrl(model),
+                            status: res2.status,
+                            ok: res2.ok,
+                            headers: snapshotResponseHeaders(res2),
+                        });
+                    }
                     if (!res2.ok) {
                         const errText2 = await safeErrorText(res2);
                         throw providerHttpError("google-gemini", res2.status, errText2);
@@ -1117,9 +1387,11 @@ export async function chatCompletionGemini(apiKey, model, history, opts) {
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
 // Provider dispatcher: openai-chat reuses chatCompletion with the provider's
-// error label; anthropic/gemini go through their adapters. reasoning_effort is only
-// ever attached for opencode-zen (via reasoningEffortParam); all other
-// providers never receive the param.
+// error label; anthropic/gemini go through their adapters. Effort rides
+// every kind: reasoning_effort on openai-chat (all providers, all models),
+// thinking budgets on anthropic-messages, thinkingLevel on gemini-generate.
+// Auto omits the knob; a model that truly lacks it 400s and the transports
+// above retry once without it.
 export async function chatCompletionForProvider(provider, apiKey, model, history, opts) {
     const def = getProvider(provider);
     if (!def)
@@ -1136,7 +1408,14 @@ export async function chatCompletionForProvider(provider, apiKey, model, history
     const endpoint = provider === "opencode-zen"
         ? (opts?.endpointOverride ?? chatEndpointFor(provider, opts?.baseURL))
         : chatEndpointFor(provider, opts?.baseURL);
-    const effortOpts = provider === "opencode-zen" ? { reasoningEffort: opts?.reasoningEffort } : {};
+    // Effort passes through for every openai-chat provider (zen, OpenAI,
+    // DeepSeek, Mistral, Kilo, openai-compatible, local runtimes): the shared
+    // transport sends reasoning_effort when non-Auto and falls back without it
+    // on a server rejection. Anthropic/Gemini kinds receive opts directly
+    // above and map effort to their native thinking knobs.
+    const effortOpts = opts?.reasoningEffort !== undefined
+        ? { reasoningEffort: opts.reasoningEffort }
+        : {};
     const chatOpts = {
         onToken: opts?.onToken,
         onPhase: opts?.onPhase,
@@ -1145,6 +1424,9 @@ export async function chatCompletionForProvider(provider, apiKey, model, history
         onThinking: opts?.onThinking,
         sleep: opts?.sleep,
         signal: opts?.signal,
+        // Ticket 08: provider-hook attribution for the shared openai-chat
+        // transport (otherwise every kind would report "opencode-zen").
+        providerId: provider,
         ...effortOpts,
         // Compaction path only (undefined for the normal loop → tools sent).
         ...(opts?.disableTools !== undefined ? { disableTools: opts.disableTools } : {}),
@@ -1153,9 +1435,9 @@ export async function chatCompletionForProvider(provider, apiKey, model, history
             : {}),
     };
     // Kilo rides the shared OpenAI-chat path (streaming, tool reconstruction,
-    // retry) with its registry endpoint + label; HTTP failures are reframed
-    // into concise actionable Kilo errors (see src/kilo.ts). reasoning_effort
-    // is never attached (zen-only gating above).
+    // retry, effort with server-rejection fallback) with its registry
+    // endpoint + label; HTTP failures are reframed into concise actionable
+    // Kilo errors (see src/kilo.ts).
     if (provider === "kilo") {
         try {
             return await chatCompletion(endpoint, apiKey, model, history, chatOpts, providerLabel(provider));
@@ -1166,16 +1448,17 @@ export async function chatCompletionForProvider(provider, apiKey, model, history
     }
     return chatCompletion(endpoint, apiKey, model, history, chatOpts, providerLabel(provider));
 }
-export { evaluateTurnEnd, isCodePath, MAX_VERIFY_ROUNDS, todoCompletionGate, TURN_END_GATES, verificationGate, } from "./agent/gates.js";
+export { evaluateTurnEnd, isCodePath, MAX_TODO_ROUNDS, MAX_VERIFY_ROUNDS, todoCompletionGate, TURN_END_GATES, verificationGate, } from "./agent/gates.js";
 // Parallel independent tool calls: batch PLANNING lives in src/scheduler.ts
 // (effect metadata + conflict rules, no per-tool branches); this module only
 // plans via planToolBatches below and executes (serial singletons in program
-// order, read batches concurrently, results committed in call order).
+// order, disjoint batches concurrently, results committed in call order).
 //
-// Parallel-safe = batchable reads only (see TOOL_EFFECTS in scheduler.ts).
-// Excluded on purpose:
-// - write/edit/bash mutate or spawn with an unbounded footprint (bash can
-//   touch anything, so no footprint check could clear it) — always singletons;
+// Parallel-safe = batchable reads plus disjoint-file writes (see TOOL_EFFECTS
+// and canonicalFileKey in scheduler.ts). Approvals for batched writes resolve
+// serially in call order before any member executes. Excluded on purpose:
+// - bash mutates/spawns with an unbounded footprint (it can touch anything,
+//   so no footprint check could clear it) — always a singleton;
 // - ask_question blocks on a UI modal (parallel prompts make no sense);
 // - todowrite/todo_update share module-global todo state (read-modify-write
 //   races); todo_get is pure but sub-millisecond, so batching it buys
@@ -1190,7 +1473,7 @@ export function planToolBatches(calls) {
 }
 import { runLoopWithChat } from "./agent/loop.js";
 export { runLoopWithChat } from "./agent/loop.js";
-export { DEFAULT_MAX_TOTAL_TOOL_CALLS, DEFAULT_TOOL_TIMEOUT_MS, executeWithTimeout, resolveMaxTotalToolCalls, resolveToolTimeoutMs, } from "./agent/loop.js";
+export { DEFAULT_MAX_TOTAL_TOOL_CALLS, DEFAULT_TOOL_TIMEOUT_MS, executeWithTimeout, emptyResponseFollowUp, isEmptyReplyError, MAX_EMPTY_ROUNDS, resolveMaxTotalToolCalls, resolveToolTimeoutMs, } from "./agent/loop.js";
 export async function runAgenticLoopForProvider(provider, apiKey, model, history, opts) {
     return runLoopWithChat((h, o) => chatCompletionForProvider(provider, apiKey, model, h, {
         onToken: o?.onToken,