@wrongstack/core 0.283.0 → 0.284.0

package/dist/execution/index.js

@@ -205,7 +205,7 @@ function walk(value, schema, path12, errors, depth) {
     if (!checkType(value, schema.type)) {
       errors.push({
         path: path12 || "<root>",
-        message: `expected ${schema.type}, got ${describeType(value)}`
+        message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
     }
@@ -214,7 +214,11 @@ function walk(value, schema, path12, errors, depth) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path12, req), message: "required property missing" });
+        const expected = schema.properties?.[req]?.type;
+        errors.push({
+          path: joinPath(path12, req),
+          message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
+        });
       }
     }
     if (schema.properties) {
@@ -231,6 +235,69 @@ function walk(value, schema, path12, errors, depth) {
     }
   }
 }
+function coerceAgainstSchema(value, schema) {
+  return coerceWalk(value, schema, 0);
+}
+function coerceWalk(value, schema, depth) {
+  if (depth > MAX_SCHEMA_DEPTH) return { value, changed: false };
+  const type = typeof schema.type === "string" ? schema.type : void 0;
+  if (type && !checkType(value, type)) {
+    if (type === "string" && (typeof value === "number" || typeof value === "boolean")) {
+      return { value: String(value), changed: true };
+    }
+    if ((type === "number" || type === "integer") && typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed !== "" && /^-?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(trimmed)) {
+        const num = Number(trimmed);
+        if (!Number.isNaN(num) && (type === "number" || Number.isInteger(num))) {
+          return { value: num, changed: true };
+        }
+      }
+      return { value, changed: false };
+    }
+    if (type === "boolean" && typeof value === "string") {
+      const lowered = value.trim().toLowerCase();
+      if (lowered === "true") return { value: true, changed: true };
+      if (lowered === "false") return { value: false, changed: true };
+      return { value, changed: false };
+    }
+    if ((type === "object" || type === "array") && typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (checkType(parsed, type)) {
+          return { value: coerceWalk(parsed, schema, depth + 1).value, changed: true };
+        }
+      } catch {
+      }
+      return { value, changed: false };
+    }
+    return { value, changed: false };
+  }
+  if (type === "object" && isPlainObject(value) && schema.properties) {
+    const obj = value;
+    let changed = false;
+    const out = { ...obj };
+    for (const [key, subSchema] of Object.entries(schema.properties)) {
+      if (!(key in obj)) continue;
+      const r = coerceWalk(obj[key], subSchema, depth + 1);
+      if (r.changed) {
+        out[key] = r.value;
+        changed = true;
+      }
+    }
+    return changed ? { value: out, changed } : { value, changed: false };
+  }
+  if (type === "array" && Array.isArray(value) && schema.items) {
+    let changed = false;
+    const out = value.map((item) => {
+      const r = coerceWalk(item, schema.items, depth + 1);
+      if (r.changed) changed = true;
+      return r.value;
+    });
+    return changed ? { value: out, changed } : { value, changed: false };
+  }
+  return { value, changed: false };
+}
 function checkType(value, type) {
   switch (type) {
     case "string":
@@ -259,6 +326,15 @@ function describeType(v) {
   if (Array.isArray(v)) return "array";
   return typeof v;
 }
+function previewValue(v) {
+  try {
+    const s = JSON.stringify(v);
+    if (s === void 0) return String(v);
+    return s.length > 80 ? `${s.slice(0, 80)}\u2026` : s;
+  } catch {
+    return String(v);
+  }
+}
 function joinPath(parent, key) {
   if (!parent) return key;
   return `${parent}.${key}`;
@@ -413,6 +489,21 @@ function compileUserRegex(pattern, flags) {
   }
 }
 
+// src/utils/safe-json.ts
+function safeParse(input, maxBytes = 5e6) {
+  if (input.length > maxBytes) {
+    return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
+  }
+  try {
+    return { ok: true, value: JSON.parse(input) };
+  } catch (err) {
+    return {
+      ok: false,
+      error: toErrorMessage(err)
+    };
+  }
+}
+
 // src/utils/slug.ts
 function slugify(name, fallback = "prompt", maxLen = 64) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
@@ -908,18 +999,23 @@ ${renderStringList(files)}` : void 0
   }
   if (typeof obj["diff"] === "string") {
     const diff = obj["diff"];
+    const matchedBy = typeof obj["matched_by"] === "string" && obj["matched_by"] !== "exact" ? obj["matched_by"] : void 0;
+    const syntaxErrors = Array.isArray(obj["syntax_errors"]) ? obj["syntax_errors"].filter((e) => typeof e === "string") : [];
     return joinSections([
       renderHeader(toolName, {
         path: obj["path"],
         replacements: obj["replacements"],
         bytes_written: obj["bytes_written"],
         created: obj["created"],
+        matched_by: matchedBy,
         note: obj["note"],
         files: Array.isArray(obj["files"]) ? obj["files"].length : void 0,
         truncated: obj["truncated"],
         mode: obj["mode"]
       }),
-      compactDiff(diff)
+      compactDiff(diff),
+      syntaxErrors.length > 0 ? `syntax_errors:
+${renderStringList(syntaxErrors)}` : void 0
     ]);
   }
   if (toolName === "test" && typeof obj["output"] === "string") {
@@ -2302,16 +2398,14 @@ ${request.context}` : "",
     );
     const text = extractText(response).trim();
     if (request.options?.length) {
-      for (const opt of request.options) {
-        if (text.toLowerCase().includes(opt.id.toLowerCase())) {
-          return {
-            type: "answer",
-            optionId: opt.id,
-            text: opt.label,
-            rationale: text
-          };
-        }
+      const parsed = parseOptionDecision(text, request.options);
+      if (parsed) {
+        return parsed;
       }
+      return {
+        type: "deny",
+        reason: "Autonomy Brain returned no exact valid option id."
+      };
     }
     return {
       type: "answer",
@@ -2328,6 +2422,34 @@ ${request.context}` : "",
     return { type: "deny", reason: "Autonomy Brain LLM unavailable for decision." };
   }
 }
+function parseOptionDecision(rawText, options) {
+  const text = rawText.trim();
+  const byId = new Map(options.map((option2) => [option2.id, option2]));
+  const wholeFence = /^```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n?```$/i.exec(text);
+  const jsonCandidate = wholeFence ? (wholeFence[1] ?? "").trim() : text;
+  const parsed = safeParse(jsonCandidate, 16384);
+  if (parsed.ok && parsed.value && typeof parsed.value.optionId === "string") {
+    const option2 = byId.get(parsed.value.optionId);
+    if (!option2) return null;
+    return {
+      type: "answer",
+      optionId: option2.id,
+      text: option2.label,
+      rationale: typeof parsed.value.rationale === "string" && parsed.value.rationale.trim() ? parsed.value.rationale.trim() : void 0
+    };
+  }
+  const legacy = /^\s*\[([^\]\r\n]+)\](?:\s*(?:—|-|:)\s*)?([\s\S]*)$/.exec(text);
+  if (!legacy) return null;
+  const option = byId.get((legacy[1] ?? "").trim());
+  if (!option) return null;
+  const rationale = (legacy[2] ?? "").trim();
+  return {
+    type: "answer",
+    optionId: option.id,
+    text: option.label,
+    rationale: rationale || void 0
+  };
+}
 function extractText(result) {
   if (!result || typeof result !== "object") return "";
   const r = result;
@@ -3821,15 +3943,55 @@ function installDesignStudioMiddleware(deps) {
 }
 
 // src/types/provider.ts
+var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
+var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+function classifyProviderError(status, body, message) {
+  const type = body?.type;
+  if (status === 0) return "network";
+  if (status === 408) return "timeout";
+  if (status === 599) return "stream_hang";
+  if (type === "rate_limit_error" || status === 429) return "rate_limit";
+  if (type === "overloaded_error" || status === 529) return "overloaded";
+  if (status >= 500) return "server";
+  if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
+    return "auth";
+  }
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
+  if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
+  if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
+    return "context_overflow";
+  }
+  if (status >= 400) return "invalid_request";
+  return "unknown";
+}
+function isRetryableKind(kind) {
+  return RETRYABLE_BY_KIND[kind];
+}
+var RETRYABLE_BY_KIND = {
+  rate_limit: true,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
 var ProviderError = class extends WrongStackError {
   status;
   retryable;
   providerId;
+  /** Canonical failure classification — see {@link ProviderErrorKind}. */
+  kind;
   body;
   constructor(message, status, retryable, providerId, opts = {}) {
+    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
     super({
       message,
-      code: providerStatusToCode(status, opts.body?.type),
+      code: kindToCode(kind),
       subsystem: "provider",
       severity: status >= 500 ? "error" : "warning",
       recoverable: retryable,
@@ -3840,6 +4002,7 @@ var ProviderError = class extends WrongStackError {
     this.status = status;
     this.retryable = retryable;
     this.providerId = providerId;
+    this.kind = kind;
     this.body = opts.body;
   }
   /**
@@ -3867,33 +4030,40 @@ var ProviderError = class extends WrongStackError {
 };
 function describeStatus(status, type) {
   if (status === 0) return "network error";
+  if (status === 599) return `stream hang (${status})`;
   if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
   if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
   if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
   if (type === "permission_error" || status === 403) return `forbidden (${status})`;
   if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "content_filter") return `content filtered (${status})`;
   if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
   if (status === 408) return `timeout (${status})`;
   if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
   if (type) return `${type} (${status})`;
   return `HTTP ${status}`;
 }
-function providerStatusToCode(status, type) {
-  if (status === 0) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
-  if (type === "rate_limit_error" || status === 429) return ERROR_CODES.PROVIDER_RATE_LIMITED;
-  if (type === "authentication_error" || status === 401) return ERROR_CODES.PROVIDER_AUTH_FAILED;
-  if (type === "overloaded_error" || status === 529) return ERROR_CODES.PROVIDER_OVERLOADED;
-  if (type === "invalid_request_error" || status === 400) return ERROR_CODES.PROVIDER_INVALID_REQUEST;
-  if (status === 408) return ERROR_CODES.PROVIDER_NETWORK_ERROR;
-  if (status >= 500) return ERROR_CODES.PROVIDER_SERVER_ERROR;
-  return ERROR_CODES.PROVIDER_INVALID_REQUEST;
+var KIND_TO_CODE = {
+  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
+  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
+  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
+  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
+};
+function kindToCode(kind) {
+  return KIND_TO_CODE[kind];
 }
 
 // src/execution/regex-patterns.ts
 var NETWORK_ERR_RE = /ECONN|ETIMEDOUT|ETIME|ENOTFOUND|EAI_AGAIN|fetch failed/i;
 
 // src/execution/error-handler.ts
-var CONTEXT_OVERFLOW_RE = /context|too long|tokens|exceeds the context window|context window/i;
 function buildRecoveryStrategies(opts) {
   return [
     {
@@ -3901,7 +4071,7 @@ function buildRecoveryStrategies(opts) {
       compactor: opts?.compactor,
       async attempt(err, ctx) {
         if (!(err instanceof ProviderError)) return null;
-        if (err.status !== 413 && !isContextOverflowError(err)) return null;
+        if (err.kind !== "context_overflow") return null;
         if (this.compactor) {
           try {
             const report = await this.compactor.compact(ctx, { aggressive: true });
@@ -3917,7 +4087,7 @@ function buildRecoveryStrategies(opts) {
     {
       label: "rate_limit_backoff",
       async attempt(err) {
-        if (!(err instanceof ProviderError) || err.status !== 429) return null;
+        if (!(err instanceof ProviderError) || err.kind !== "rate_limit") return null;
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
         await new Promise((r) => setTimeout(r, delay));
@@ -3928,7 +4098,9 @@ function buildRecoveryStrategies(opts) {
       label: "downgrade_model",
       async attempt(err, ctx) {
         if (!(err instanceof ProviderError)) return null;
-        if (err.status !== 529 && err.status < 500) return null;
+        if (err.kind !== "overloaded" && err.kind !== "server" && err.kind !== "stream_hang") {
+          return null;
+        }
         const registry = opts?.modelsRegistry;
         if (!registry) return null;
         try {
@@ -3962,18 +4134,59 @@ function buildRecoveryStrategies(opts) {
           return null;
         }
       }
+    },
+    {
+      label: "content_filter_reroute",
+      async attempt(err, ctx) {
+        if (!(err instanceof ProviderError) || err.kind !== "content_filter") return null;
+        const registry = opts?.modelsRegistry;
+        if (!registry) return null;
+        try {
+          const providerId = ctx.provider?.id;
+          if (!providerId) return null;
+          const provider = await registry.getProvider(providerId);
+          if (!provider) return null;
+          const currentModel = await registry.getModel(providerId, ctx.model);
+          if (!currentModel) return null;
+          const visibleModels = opts?.getConfig?.().providers?.[providerId]?.models;
+          const candidates = provider.models.filter((m) => {
+            if (m.id === ctx.model) return false;
+            if (visibleModels !== void 0 && !visibleModels.includes(m.id)) return false;
+            if (currentModel.capabilities.tools && !m.tool_call) return false;
+            if (currentModel.capabilities.vision && !m.modalities?.input?.includes("image"))
+              return false;
+            return true;
+          });
+          if (candidates.length === 0) return null;
+          const currentCost = currentModel.cost?.input;
+          const distance = (m) => currentCost === void 0 || m.cost?.input === void 0 ? Number.POSITIVE_INFINITY : Math.abs(m.cost.input - currentCost);
+          const reroute = candidates.reduce((prev, curr) => {
+            const delta = distance(curr) - distance(prev);
+            if (delta < 0) return curr;
+            if (delta === 0 && curr.id < prev.id) return curr;
+            return prev;
+          });
+          return { action: "retry", reason: "content_filter_reroute", model: reroute.id };
+        } catch {
+          return null;
+        }
+      }
     }
   ];
 }
 var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
-function isContextOverflowError(err) {
-  return CONTEXT_OVERFLOW_RE.test([
-    err.message,
-    err.body?.message,
-    err.body?.type,
-    err.body?.raw
-  ].filter(Boolean).join("\n"));
-}
+var HANDLER_KIND_BY_PROVIDER_KIND = {
+  rate_limit: "rate_limit",
+  overloaded: "overloaded",
+  server: "server",
+  stream_hang: "server",
+  timeout: "network",
+  network: "network",
+  context_overflow: "context_overflow",
+  content_filter: "content_filter",
+  auth: "client",
+  invalid_request: "client"
+};
 var DefaultErrorHandler = class {
   strategies;
   constructor(strategies = DEFAULT_RECOVERY_STRATEGIES) {
@@ -3987,13 +4200,11 @@ var DefaultErrorHandler = class {
       return { kind: "abort", retryable: false };
     }
     if (err instanceof ProviderError) {
-      if (err.status === 429) return { kind: "rate_limit", retryable: true };
-      if (err.status === 529) return { kind: "overloaded", retryable: true };
-      if (err.status >= 500) return { kind: "server", retryable: true };
-      if (err.status === 413 || isContextOverflowError(err)) {
-        return { kind: "context_overflow", retryable: false };
-      }
-      if (err.status >= 400) return { kind: "client", retryable: false };
+      if (err.kind === "unknown") return { kind: "unknown", retryable: err.retryable };
+      return {
+        kind: HANDLER_KIND_BY_PROVIDER_KIND[err.kind],
+        retryable: isRetryableKind(err.kind)
+      };
     }
     if (err instanceof Error && NETWORK_ERR_RE.test(err.message)) {
       return { kind: "network", retryable: true };
@@ -4305,7 +4516,7 @@ var EternalAutonomyEngine = class {
     if (maxCtx && maxCtx > 0) {
       const used = ctx.tokenCounter?.currentRequestTokens?.();
       if (used) {
-        const total = used.input + used.cacheRead;
+        const total = used.input + used.cacheRead + used.cacheWrite;
         if (total / maxCtx >= threshold) {
           shouldRun = true;
           aggressive = true;
@@ -5405,6 +5616,104 @@ var SubagentBudget = class _SubagentBudget {
   }
 };
 
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /** Can execute a restricted set of commands (the `exec` tool). */
+  SHELL_RESTRICTED: "shell.restricted",
+  /** Can run a restricted project formatter/linter-style command. */
+  SHELL_EXEC: "shell.exec",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Can invoke arbitrary registered tools through a meta-tool. */
+  TOOL_MUTATE_ANY: "tool.mutate.any",
+  /** Can write persistent memory. */
+  MEMORY_WRITE: "memory.write",
+  /** Can delete persistent memory. */
+  MEMORY_DELETE: "memory.delete",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.SHELL_RESTRICTED,
+  ToolCapabilities.SHELL_EXEC,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.TOOL_MUTATE_ANY,
+  ToolCapabilities.MEMORY_WRITE,
+  ToolCapabilities.MEMORY_DELETE,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+function hasDangerousCapabilityForSubagents(toolOrCaps) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
+}
+function getDangerousCapabilities(toolOrCaps) {
+  if (!toolOrCaps) return [];
+  const input = toolOrCaps;
+  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
+  return caps.filter(
+    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
+  );
+}
+
+// src/coordination/subagent-result-tool.ts
+var SUBAGENT_STRUCTURED_REPORT_META_KEY = "subagentStructuredReport";
+var MAX_SUBAGENT_STRUCTURED_REPORT_CHARS = 8e3;
+var MAX_SUMMARY_CHARS = 1500;
+var MAX_FINDINGS = 16;
+var MAX_FILES = 64;
+var MAX_NEXT_STEPS = 12;
+var MAX_ITEM_CHARS = 500;
+function normalizeSubagentStructuredReport(value) {
+  if (!isRecord3(value)) return void 0;
+  const summary = nonEmptyString(value["summary"]);
+  const findings = stringArray(value["findings"]);
+  const filesExamined = stringArray(value["files_examined"]);
+  const nextSteps = stringArray(value["suggested_next_steps"]);
+  const confidence = value["confidence"];
+  if (!summary || summary.length > MAX_SUMMARY_CHARS || !findings || findings.length > MAX_FINDINGS || !filesExamined || filesExamined.length > MAX_FILES || !nextSteps || nextSteps.length > MAX_NEXT_STEPS || [...findings, ...filesExamined, ...nextSteps].some(
+    (item) => item.trim().length > MAX_ITEM_CHARS
+  ) || typeof confidence !== "number" || !Number.isFinite(confidence) || confidence < 0 || confidence > 1) {
+    return void 0;
+  }
+  const report = {
+    summary,
+    findings: findings.map((item) => item.trim()).filter(Boolean),
+    files_examined: filesExamined.map((item) => item.trim()).filter(Boolean),
+    confidence,
+    suggested_next_steps: nextSteps.map((item) => item.trim()).filter(Boolean)
+  };
+  return JSON.stringify(report).length <= MAX_SUBAGENT_STRUCTURED_REPORT_CHARS ? report : void 0;
+}
+function readSubagentStructuredReport(ctx) {
+  return normalizeSubagentStructuredReport(ctx?.meta?.[SUBAGENT_STRUCTURED_REPORT_META_KEY]);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function stringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+
 // src/coordination/agent-subagent-runner.ts
 function withDisabledToolFiltering(factory) {
   return async (config) => {
@@ -5426,6 +5735,8 @@ function makeAgentSubagentRunner(opts) {
     const taskStartedAt = Date.now();
     const factoryResult = await opts.factory(ctx.config);
     const { agent, events } = factoryResult;
+    const agentContext = agent.ctx;
+    if (agentContext?.meta) agentContext.meta["subagentTaskId"] = task.id;
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
@@ -5521,6 +5832,10 @@ function makeAgentSubagentRunner(opts) {
       events.on("provider.text_delta", (e) => {
         ctx.budget.markActivity();
         streamingTextAcc = (streamingTextAcc + e.text).slice(-2e3);
+        const text = streamingTextAcc.trim();
+        if (text) {
+          ctx.reportProgress?.({ text, source: "stream", capturedAt: Date.now() });
+        }
       })
     );
     const onParentAbort = () => aborter.abort();
@@ -5528,6 +5843,10 @@ function makeAgentSubagentRunner(opts) {
     let result;
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
+      const finalText2 = result.finalText?.trim();
+      if (finalText2) {
+        ctx.reportProgress?.({ text: finalText2, source: "run_result", capturedAt: Date.now() });
+      }
       events.emit("subagent.task_completed", {
         subagentId: ctx.subagentId,
         taskId: task.id,
@@ -5609,6 +5928,7 @@ function makeAgentSubagentRunner(opts) {
     }
     return {
       result: result.finalText,
+      report: readSubagentStructuredReport(agentContext),
       iterations: result.iterations,
       toolCalls: usage.toolCalls
     };
@@ -7341,20 +7661,31 @@ function classifySubagentError(err, hints = {}) {
   return { kind: "unknown", message: baseMessage, retryable: false, cause };
 }
 function providerErrorToSubagentError(err, message, cause) {
-  const status = err.status;
-  if (status === 429 || err.body?.type === "rate_limit_error") {
-    return { kind: "provider_rate_limit", message, retryable: true, backoffMs: 5e3, cause };
-  }
-  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
-    return { kind: "provider_auth", message, retryable: false, cause };
-  }
-  if (status === 408 || status === 0) {
-    return { kind: "provider_timeout", message, retryable: true, cause };
-  }
-  if (status >= 500 && status < 600) {
-    return { kind: "provider_5xx", message, retryable: true, backoffMs: 3e3, cause };
+  switch (err.kind) {
+    case "rate_limit":
+      return {
+        kind: "provider_rate_limit",
+        message,
+        retryable: true,
+        backoffMs: err.body?.retryAfterMs ?? 5e3,
+        cause
+      };
+    case "auth":
+      return { kind: "provider_auth", message, retryable: false, cause };
+    case "timeout":
+    case "network":
+      return { kind: "provider_timeout", message, retryable: true, cause };
+    case "overloaded":
+    case "server":
+    case "stream_hang":
+      return { kind: "provider_5xx", message, retryable: true, backoffMs: 3e3, cause };
+    case "context_overflow":
+      return { kind: "context_overflow", message, retryable: false, cause };
+    case "invalid_request":
+    case "content_filter":
+    case "unknown":
+      return { kind: "unknown", message, retryable: err.retryable, cause };
   }
-  return { kind: "unknown", message, retryable: err.retryable, cause };
 }
 
 // src/coordination/fleet.ts
@@ -8087,12 +8418,22 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.inFlight++;
     const startTime = Date.now();
+    let latestPartial;
     const runCtx = {
       subagentId,
       config: subagent.config,
       budget,
       signal: subagent.abortController.signal,
-      bridge: subagent.context.parentBridge || null
+      bridge: subagent.context.parentBridge || null,
+      reportProgress: (partial) => {
+        const text = partial.text.trim();
+        if (!text) return;
+        latestPartial = {
+          ...partial,
+          // A partial is context recovery, not a transcript replacement.
+          text: text.slice(-4e3)
+        };
+      }
     };
     let result;
     budget.start();
@@ -8109,6 +8450,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         taskId: task.id,
         status: "success",
         result: outcome.result,
+        ...outcome.report ? { report: outcome.report } : {},
         iterations: outcome.iterations,
         toolCalls: outcome.toolCalls,
         durationMs: Date.now() - startTime
@@ -8123,6 +8465,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         error: classifySubagentError(err, {
           parentAborted: subagent.abortController.signal.aborted
         }),
+        ...latestPartial ? { partial: latestPartial } : {},
         iterations: usage.iterations,
         toolCalls: usage.toolCalls,
         durationMs: Date.now() - startTime
@@ -8368,6 +8711,8 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         taskId: result.taskId,
         status: result.status,
         result: result.result,
+        report: result.report,
+        partial: result.partial,
         iterations: result.iterations,
         toolCalls: result.toolCalls,
         durationMs: result.durationMs
@@ -8856,6 +9201,20 @@ ${lastFew}` : "No prior iterations.",
   }
 };
 var MAX_RETRY_AFTER_MS = 6e4;
+var MAX_ATTEMPTS_BY_KIND = {
+  rate_limit: 5,
+  stream_hang: 5,
+  // transient, worth retrying aggressively
+  overloaded: 3,
+  server: 3,
+  timeout: 2,
+  network: 2,
+  auth: 0,
+  invalid_request: 0,
+  context_overflow: 0,
+  content_filter: 0,
+  unknown: 0
+};
 var DefaultRetryPolicy = class {
   shouldRetry(err, attempt) {
     if (err instanceof ProviderError) {
@@ -8869,11 +9228,7 @@ var DefaultRetryPolicy = class {
   }
   maxAttempts(err) {
     if (err instanceof ProviderError) {
-      if (err.status === 429) return 5;
-      if (err.status === 529) return 3;
-      if (err.status === 599) return 5;
-      if (err.status >= 500) return 3;
-      return 0;
+      return MAX_ATTEMPTS_BY_KIND[err.kind];
     }
     return 2;
   }
@@ -10012,14 +10367,56 @@ function escapeRegExp(s) {
 function createStrategyCompactor(opts = {}) {
   const requested = opts.strategy ?? (opts.llmSelector ? "selective" : "hybrid");
   const strategy = requested;
+  let inner;
   if (strategy === "intelligent" || strategy === "selective") {
-    return new ProviderBackedCompactor(strategy, opts);
+    inner = new ProviderBackedCompactor(strategy, opts);
+  } else {
+    inner = new HybridCompactor({
+      preserveK: opts.preserveK,
+      eliseThreshold: opts.eliseThreshold,
+      smart: opts.smart
+    });
   }
-  return new HybridCompactor({
-    preserveK: opts.preserveK,
-    eliseThreshold: opts.eliseThreshold,
-    smart: opts.smart
-  });
+  return new JournaledCompactor(inner);
+}
+var JournaledCompactor = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  async compact(ctx, compactOpts = {}) {
+    const state = ctx.state;
+    const revisionBefore = state.revision;
+    const report = await this.inner.compact(ctx, compactOpts);
+    const changed = state.revision !== revisionBefore || report.reductions.some((reduction) => reduction.saved > 0) || report.repaired !== void 0;
+    const writer = ctx.session;
+    if (!changed || !writer) return report;
+    const messages = ctx.messages.map(stripTransientMessageFields);
+    try {
+      await writer.append({
+        type: "context_snapshot",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: "compaction",
+        messages
+      });
+      await writer.flush();
+    } catch (err) {
+      console.error(
+        JSON.stringify({
+          level: "error",
+          event: "session.context_snapshot_write_failed",
+          sessionId: writer.id,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+    return report;
+  }
+};
+function stripTransientMessageFields(message) {
+  const { _estTokens: _ignored, ...persisted } = message;
+  return persisted;
 }
 var ProviderBackedCompactor = class {
   constructor(strategy, opts) {
@@ -10077,62 +10474,6 @@ function readPolicy(ctx) {
   return candidate;
 }
 
-// src/security/capabilities.ts
-var ToolCapabilities = {
-  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
-  SHELL_ARBITRARY: "shell.arbitrary",
-  /** Can execute a restricted set of commands (the `exec` tool). */
-  SHELL_RESTRICTED: "shell.restricted",
-  /** Can run a restricted project formatter/linter-style command. */
-  SHELL_EXEC: "shell.exec",
-  /** Can write / modify / delete files inside the project. */
-  FS_WRITE: "fs.write",
-  /** Can write files outside the current project root (very high risk). */
-  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
-  /** Can invoke arbitrary registered tools through a meta-tool. */
-  TOOL_MUTATE_ANY: "tool.mutate.any",
-  /** Can write persistent memory. */
-  MEMORY_WRITE: "memory.write",
-  /** Can delete persistent memory. */
-  MEMORY_DELETE: "memory.delete",
-  /** Proxies tools from external MCP servers (unknown capability). */
-  MCP_PROXY: "mcp.proxy",
-  /** Can spawn or manage subagents / multi-agent tasks. */
-  SUBAGENT_SPAWN: "subagent.spawn",
-  /** Can mutate global or session configuration / trust state. */
-  CONFIG_MUTATE: "config.mutate",
-  /** Can install packages or run package managers with side effects. */
-  PACKAGE_INSTALL: "package.install"
-};
-var DANGEROUS_FOR_SUBAGENTS = [
-  ToolCapabilities.SHELL_ARBITRARY,
-  ToolCapabilities.SHELL_RESTRICTED,
-  ToolCapabilities.SHELL_EXEC,
-  ToolCapabilities.FS_WRITE,
-  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
-  ToolCapabilities.TOOL_MUTATE_ANY,
-  ToolCapabilities.MEMORY_WRITE,
-  ToolCapabilities.MEMORY_DELETE,
-  ToolCapabilities.MCP_PROXY,
-  ToolCapabilities.SUBAGENT_SPAWN,
-  ToolCapabilities.CONFIG_MUTATE,
-  ToolCapabilities.PACKAGE_INSTALL
-];
-function hasDangerousCapabilityForSubagents(toolOrCaps) {
-  if (!toolOrCaps) return false;
-  const input = toolOrCaps;
-  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
-  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
-}
-function getDangerousCapabilities(toolOrCaps) {
-  if (!toolOrCaps) return [];
-  const input = toolOrCaps;
-  const caps = Array.isArray(toolOrCaps) ? toolOrCaps : input.capabilities ?? [];
-  return caps.filter(
-    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
-  );
-}
-
 // src/types/tool-markers.ts
 var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
 
@@ -10259,29 +10600,39 @@ var ToolExecutor = class _ToolExecutor {
         budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
+      if (hasMalformedArguments(use.input)) {
+        const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
+        budget = this.budgetForString(result.content, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
       const validation = validateAgainstSchema(use.input, tool.inputSchema);
       if (!validation.ok) {
-        const errorDetails = validation.errors.map((e) => `  - ${e.path || "input"}: ${e.message}`).join("\n");
-        const result = {
-          type: "tool_result",
-          tool_use_id: use.id,
-          content: `Invalid arguments for tool "${tool.name}".
+        const coercion = coerceAgainstSchema(use.input, tool.inputSchema);
+        const revalidation = coercion.changed ? validateAgainstSchema(coercion.value, tool.inputSchema) : validation;
+        if (coercion.changed && revalidation.ok) {
+          this.opts.logger?.info("tool arguments coerced to match inputSchema", {
+            tool: tool.name,
+            id: use.id
+          });
+          use = { ...use, input: coercion.value };
+        } else {
+          const errorDetails = revalidation.errors.map((e) => `  - ${e.path || "input"}: ${e.message}`).join("\n");
+          const result = {
+            type: "tool_result",
+            tool_use_id: use.id,
+            content: `Invalid arguments for tool "${tool.name}".
 
 Validation errors:
 ${errorDetails}
 
-Please call the tool again with arguments that match its inputSchema. You can use the "tool-help" tool with name="${tool.name}" to see the exact expected schema.`,
-          is_error: true
-        };
-        budget = this.budgetForString(result.content, budget);
-        return { result, tool, durationMs: Date.now() - start };
+Fix exactly the fields listed above and call the tool again. You can use the "tool-help" tool with name="${tool.name}" to see the exact expected schema.`,
+            is_error: true
+          };
+          budget = this.budgetForString(result.content, budget);
+          return { result, tool, durationMs: Date.now() - start };
+        }
       }
       const toolDangerousCaps = getDangerousCapabilities(tool);
-      if (hasMalformedArguments(use.input)) {
-        const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
-        budget = this.budgetForString(result.content, budget);
-        return { result, tool, durationMs: Date.now() - start };
-      }
       if (this.opts.hookRunner?.has("PreToolUse")) {
         const pre = await this.opts.hookRunner.preToolUse(tool.name, use.input, ctx);
         if (pre.block) {
@@ -10747,6 +11098,8 @@ function extractMalformedRaw(input) {
   }
 }
 var TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES = 64 * 1024;
+var TOOL_OUTPUT_ARTIFACT_PREVIEW_BYTES = 12 * 1024;
+var TOOL_OUTPUT_ARTIFACT_OMISSION = "\n\u2026[artifact middle omitted]\u2026\n";
 function classifyToolError(err) {
   if (err instanceof Error && err.name === "AbortError") {
     return { category: "fatal" /* FATAL */, retryable: false, detail: "aborted" };
@@ -10830,12 +11183,53 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const filePath = path3.join(dir, `${stamp}-${safeTool}-${randomUUID()}.log`);
     await fs.writeFile(filePath, content, "utf8");
-    return content + `
-[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
+    const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
+    const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
+    const previewBytes = Math.min(
+      TOOL_OUTPUT_ARTIFACT_PREVIEW_BYTES,
+      Math.max(0, budget - fixedBytes)
+    );
+    if (previewBytes < 256) return marker;
+    const headBudget = Math.ceil(previewBytes / 2);
+    const tailBudget = previewBytes - headBudget;
+    const head = sliceUtf8Prefix(content, headBudget);
+    const tail = sliceUtf8Suffix(content, tailBudget);
+    return `${marker}
+${head}${TOOL_OUTPUT_ARTIFACT_OMISSION}${tail}`;
   } catch {
     return content;
   }
 }
+function sliceUtf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(0, mid), "utf8") <= maxBytes) low = mid;
+    else high = mid - 1;
+  }
+  let end = low;
+  const last = text.charCodeAt(end - 1);
+  if (last >= 55296 && last <= 56319) end--;
+  return text.slice(0, end);
+}
+function sliceUtf8Suffix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(text, "utf8") <= maxBytes) return text;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const chars = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(text.slice(text.length - chars), "utf8") <= maxBytes) low = chars;
+    else high = chars - 1;
+  }
+  let start = text.length - low;
+  const first = text.charCodeAt(start);
+  if (first >= 56320 && first <= 57343) start++;
+  return text.slice(start);
+}
 
 export { AutoCompactionMiddleware, AutonomousRunner, DEFAULT_RECOVERY_STRATEGIES, DefaultDesignKitLoader, DefaultErrorHandler, DefaultPromptLoader, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, _resetDesignKitLoaderMemo, _resetDesignRulesCache, activateDesign, applyModelRuntime, buildGoalPreamble, buildRecoveryStrategies, clearActiveKit, clearPersistedActiveKit, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, designProjectDir, detectFrontendFile, detectFrontendIntent, formatDecisionSummary, getDesignKitLoader, getDesignState, installDesignStudioMiddleware, loadActiveKit, loadProjectDesignRules, makeAutonomyPromptContributor, makeDesignDetectToolCallMiddleware, makeDesignDetectUserInputMiddleware, makeDesignStudioRequestMiddleware, mergeModelRuntime, recordKitChoice, renderPrompt, resolveBundledDesignKitsDir, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest, setActiveKit };
 //# sourceMappingURL=index.js.map