@wrongstack/core 0.267.0 → 0.269.0

package/dist/execution/index.d.ts

@@ -1,23 +1,24 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-DdNnw9BQ.js';
-export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorStrategy, l as ContextWindowBudgetSnapshot, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as StrategyCompactorOptions, j as buildGoalPreamble, k as createStrategyCompactor, m as makeAutonomyPromptContributor } from '../goal-preamble-SulMTowG.js';
-import { P as Provider } from '../context-dT5Ueund.js';
-import { e as BrainDecision, h as BrainDecisionRequest, B as BrainArbiter } from '../brain-Cdg77tVN.js';
-import '../retry-policy-BilV1ujH.js';
-import '../compactor-iMZ84CXq.js';
-import '../config-Du3pYYln.js';
-import '../index-Bms0m4oy.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-D9y5Pkcc.js';
+export { A as AutoCompactionMiddleware, a as AutonomousRunner, b as AutonomousRunnerOptions, c as AutonomyPromptContributorOptions, C as CompactorStrategy, l as ContextWindowBudgetSnapshot, D as DefaultSkillLoader, d as DoneCheckResult, e as DoneConditionChecker, I as IntelligentCompactor, f as IntelligentCompactorOptions, S as SelectiveCompactor, g as SelectiveCompactorOptions, h as SkillLoaderOptions, i as StrategyCompactorOptions, j as buildGoalPreamble, k as createStrategyCompactor, m as makeAutonomyPromptContributor } from '../goal-preamble-CA_4yiGQ.js';
+import { P as Provider, l as ReasoningConfig, R as Request } from '../context-Dp87Bcaq.js';
+import { e as BrainDecision, h as BrainDecisionRequest, B as BrainArbiter } from '../brain-BYcK__Ym.js';
+import { G as ModelRuntimeConfig } from '../config-C_ae2k86.js';
+import '../retry-policy-CtFhfwa8.js';
+import '../compactor-C2RKEBtC.js';
+import '../index-W4VJCzHa.js';
 import '../logger-B63L5bTg.js';
-import '../pipeline-BfD2k1rT.js';
+import '../pipeline-l_zzFRh3.js';
+import '../mailbox-types-Ct2hJq0P.js';
 import '../observability-D-HZN_mF.js';
-import '../permission-B75JAi3-.js';
-import '../agent-subagent-runner-CzPGP3jA.js';
-import '../goal-store-CABDwdFE.js';
-import '../multi-agent-coordinator-B8R43uPz.js';
+import '../permission-CvYQNUqZ.js';
+import '../agent-subagent-runner-SHJW7t8q.js';
+import '../goal-store-DhuJoUNG.js';
+import '../multi-agent-coordinator-CJSpTe5O.js';
 import 'node:events';
 import '../skill-DGIXCtdv.js';
 import '../wstack-paths-hOpNLmvf.js';
-import '../selector-Bc7eWtT3.js';
-import '../session-event-bridge-D-araDEz.js';
+import '../selector-CXl2_y9W.js';
+import '../session-event-bridge-Ccud20CC.js';
 
 /**
  * AutonomyBrain — a self-driving decision layer for autonomous workflows.
@@ -108,4 +109,59 @@ declare function createAutonomyBrain(opts: AutonomyBrainOptions): BrainArbiter;
  */
 declare function formatDecisionSummary(decision: BrainDecision, request: BrainDecisionRequest): string;
 
-export { type AutonomyBrainOptions, type BrainAutoRisk, type TieredBrainArbiterOptions, createAutonomyBrain, createTieredBrainArbiter, formatDecisionSummary };
+/**
+ * Model-runtime resolver + request-pipeline middleware.
+ *
+ * Maps the shared `Config.modelRuntime` settings into the per-request
+ * `Request.reasoning` and `Request.cache` fields, gated by the active model's
+ * `reasoningConfig` capabilities so unsupported values are omitted (and
+ * surfaced as warnings) instead of triggering provider 400s.
+ *
+ * Wired once at boot (REPL/TUI/WebUI all go through the same `request`
+ * pipeline) — see `installModelRuntimeMiddleware()`. UIs only need to mutate
+ * `Config.modelRuntime` (and persist) for the change to take effect on the next
+ * request.
+ */
+
+interface ResolvedModelRuntime {
+    reasoning: Request['reasoning'];
+    cache: Request['cache'];
+    /** Human-readable warnings for settings that were ignored for this model. */
+    warnings: string[];
+}
+/**
+ * Resolve user-facing runtime settings into request fields for a specific
+ * model capability profile. Pure function — safe to unit-test without a
+ * provider or event bus.
+ *
+ * @param settings   `Config.modelRuntime` (may be undefined → no-op)
+ * @param reasoning  The model's `reasoningConfig`, or undefined when unknown.
+ *                   When undefined the resolver is conservative: explicit
+ *                   on/off is suppressed (provider default wins) and effort is
+ *                   dropped, because we cannot tell whether the model will
+ *                   accept the fields.
+ */
+declare function resolveModelRuntime(settings: ModelRuntimeConfig | undefined, reasoning: ReasoningConfig | undefined): ResolvedModelRuntime;
+declare function resolveReasoningForRequest(settings: ModelRuntimeConfig, rc: ReasoningConfig | undefined, warnings: string[]): Request['reasoning'];
+declare function resolveCacheForRequest(settings: ModelRuntimeConfig, _warnings: string[]): Request['cache'];
+interface ModelRuntimeMiddlewareOptions {
+    /** Provider id of the active model, for logging/diagnostics only. */
+    providerId?: string | undefined;
+    /** Model id of the active model, for logging/diagnostics only. */
+    modelId?: string | undefined;
+    /** Current runtime settings. Called per-request so live changes apply. */
+    getSettings(): ModelRuntimeConfig | undefined;
+    /** Current model capability profile. Called per-request. */
+    getReasoningConfig(): ReasoningConfig | undefined;
+    /** Optional sink for suppressed-setting warnings (e.g. emit to event bus). */
+    onWarning?: ((message: string) => void) | undefined;
+}
+/**
+ * Build a `request`-pipeline middleware that applies runtime settings. The
+ * returned function mutates the outgoing request by overlaying resolved
+ * `reasoning` / `cache` fields. Existing fields on the request are preserved
+ * only when the resolver produces nothing for that field.
+ */
+declare function applyModelRuntime(req: Request, opts: ModelRuntimeMiddlewareOptions): Request;
+
+export { type AutonomyBrainOptions, type BrainAutoRisk, type ModelRuntimeMiddlewareOptions, type ResolvedModelRuntime, type TieredBrainArbiterOptions, applyModelRuntime, createAutonomyBrain, createTieredBrainArbiter, formatDecisionSummary, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest };

package/dist/execution/index.js

@@ -89,8 +89,19 @@ function calState(key) {
   return state;
 }
 var MIN_SAMPLES_FOR_CALIBRATION = 3;
+var MODEL_FAMILY_RATIO = {
+  // Anthropic: ~3.8-4.0 chars/token depending on model
+  claude: 3.8,
+  // OpenAI: ~4.0 chars/token
+  "gpt-4": 4,
+  "gpt-3.5": 4,
+  // Google: ~3.5 chars/token
+  gemini: 3.5,
+  // DeepSeek: ~3.5 chars/token
+  deepseek: 3.5
+};
 var ESTIMATE_CACHE = /* @__PURE__ */ new Map();
-var ESTIMATE_CACHE_MAX_SIZE = 1e4;
+var ESTIMATE_CACHE_MAX_SIZE = 5e4;
 function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
@@ -218,8 +229,24 @@ function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrat
       total: Math.round(result.total * safeRatio)
     };
   }
+  const fallbackRatio = getModelFamilyRatio(calibrationKey);
+  if (fallbackRatio !== null) {
+    return {
+      messages: Math.round(result.messages * fallbackRatio),
+      systemPrompt: Math.round(result.systemPrompt * fallbackRatio),
+      tools: Math.round(result.tools * fallbackRatio),
+      total: Math.round(result.total * fallbackRatio)
+    };
+  }
   return result;
 }
+function getModelFamilyRatio(calibrationKey) {
+  const lower = calibrationKey.toLowerCase();
+  for (const [family, ratio] of Object.entries(MODEL_FAMILY_RATIO)) {
+    if (lower.includes(family)) return ratio / 3.5;
+  }
+  return null;
+}
 
 // src/utils/expect-defined.ts
 function expectDefined(value, label) {
@@ -293,7 +320,7 @@ function hasToolResult(msg) {
 }
 function toolUseIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "assistant") return ids;
+  if (msg?.role !== "assistant") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_use") ids.add(block.id);
   }
@@ -301,7 +328,7 @@ function toolUseIds(msg) {
 }
 function toolResultIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "user") return ids;
+  if (msg?.role !== "user") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_result") ids.add(block.tool_use_id);
   }
@@ -1765,6 +1792,41 @@ function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 
+// src/utils/tool-subject.ts
+var GLOB_METACHARACTERS = /[*?[\]]/g;
+function escapeGlobSubject(value) {
+  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
+}
+function normalizePathSubject(value) {
+  return escapeGlobSubject(value.replace(/\\/g, "/"));
+}
+function isPathSubjectKey(subjectKey) {
+  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+}
+function subjectForToolInput(toolName, input, subjectKey) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  if (subjectKey) {
+    const value = obj[subjectKey];
+    if (typeof value === "string") {
+      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+    }
+  }
+  if (toolName === "bash" && typeof obj.command === "string") {
+    return escapeGlobSubject(obj.command);
+  }
+  if (typeof obj.path === "string") {
+    return normalizePathSubject(obj.path);
+  }
+  if (typeof obj.url === "string") {
+    return escapeGlobSubject(obj.url);
+  }
+  if (typeof obj.name === "string") {
+    return escapeGlobSubject(obj.name);
+  }
+  return void 0;
+}
+
 // src/utils/tool-output-serializer.ts
 var DEFAULT_LIST_LIMIT = 500;
 var LOG_ENTRY_LIMIT = 200;
@@ -1774,6 +1836,7 @@ var GREP_MATCHES_PER_FILE = 3;
 var DIFF_INLINE_LINE_LIMIT = 260;
 var DIFF_HUNK_LIMIT = 8;
 var DIFF_HUNK_CONTEXT = 14;
+var GREP_LINE_RE = /^(.+?):(\d+):(.*)$/;
 function createToolOutputSerializer(opts = {}) {
   const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
   function serialize(value, context = {}) {
@@ -2159,7 +2222,7 @@ ${renderStringList(passthrough, "", 50)}`);
   return sections.join("\n");
 }
 function parseGrepContentLine(line) {
-  const match = /^(.+?):(\d+):(.*)$/.exec(line);
+  const match = GREP_LINE_RE.exec(line);
   if (!match?.[1] || !match[2]) return void 0;
   return { file: match[1], line: match[2], text: match[3] ?? "" };
 }
@@ -2177,22 +2240,20 @@ function compactDiff(diff) {
   const hunks = lines.filter((line) => line.startsWith("@@")).length;
   const added = lines.filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
   const removed = lines.filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
-  const selected = /* @__PURE__ */ new Set();
+  const intervals = [];
   let hunkCount = 0;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i] ?? "";
     if (line.startsWith("diff --git") || line.startsWith("--- ") || line.startsWith("+++ ")) {
-      selected.add(i);
+      intervals.push([i, i]);
       continue;
     }
     if (!line.startsWith("@@")) continue;
     if (hunkCount >= DIFF_HUNK_LIMIT) continue;
     hunkCount++;
-    for (let j = i; j <= Math.min(lines.length - 1, i + DIFF_HUNK_CONTEXT); j++) {
-      selected.add(j);
-    }
+    intervals.push([i, Math.min(lines.length - 1, i + DIFF_HUNK_CONTEXT)]);
   }
-  if (selected.size === 0) {
+  if (intervals.length === 0) {
     return joinSections([
       renderHeader("diff_summary", {
         files: fileCount,
@@ -2205,17 +2266,29 @@ function compactDiff(diff) {
       `[serializer omitted ${Math.max(0, lines.length - DIFF_INLINE_LINE_LIMIT)} diff line(s)]`
     ]);
   }
+  const merged = [intervals[0]];
+  for (let i = 1; i < intervals.length; i++) {
+    const last = merged[merged.length - 1];
+    const current = intervals[i];
+    if (current[0] <= last[1] + 1) {
+      last[1] = Math.max(last[1], current[1]);
+    } else {
+      merged.push(current);
+    }
+  }
   const excerpt = [];
-  let previous = -1;
-  for (const index of [...selected].sort((a, b) => a - b)) {
-    if (index > previous + 1) {
-      const omitted = previous === -1 ? index : index - previous - 1;
+  let prevLine = -1;
+  for (const [start, end] of merged) {
+    if (start > prevLine + 1) {
+      const omitted = prevLine === -1 ? start : start - prevLine - 1;
       excerpt.push(`[serializer omitted ${omitted} diff line(s)]`);
     }
-    excerpt.push(lines[index] ?? "");
-    previous = index;
+    for (let j = start; j <= end; j++) {
+      excerpt.push(lines[j] ?? "");
+    }
+    prevLine = end;
   }
-  const trailing = lines.length - previous - 1;
+  const trailing = lines.length - prevLine - 1;
   if (trailing > 0) excerpt.push(`[serializer omitted ${trailing} trailing diff line(s)]`);
   return joinSections([
     renderHeader("diff_summary", {
@@ -2994,7 +3067,7 @@ ${errorDetails}`,
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
-          const suggestedPattern = this.subjectFor(tool.name, use.input, tool.subjectKey) ?? tool.name;
+          const suggestedPattern = subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
           const pending = {
             type: "tool_confirm_pending",
             toolUseId: use.id,
@@ -3040,6 +3113,7 @@ ${post.additionalContext}`;
       } catch (err) {
         const msg = toErrorMessage(err);
         const scrubbed = this.opts.secretScrubber.scrub(msg);
+        const { category, retryable, detail } = classifyToolError(err);
         this.opts.renderer?.writeToolResult(tool.name, scrubbed, true);
         const result = {
           type: "tool_result",
@@ -3050,6 +3124,9 @@ ${post.additionalContext}`;
         budget = this.budgetForString(result.content, budget);
         if (err instanceof Error) span?.recordError(err);
         span?.setAttribute("tool.is_error", true);
+        span?.setAttribute("tool.error_category", category);
+        span?.setAttribute("tool.error_retryable", retryable);
+        if (detail) span?.setAttribute("tool.error_detail", detail);
         return { result, tool, durationMs: Date.now() - start };
       } finally {
         span?.end();
@@ -3061,6 +3138,9 @@ ${post.additionalContext}`;
       } catch (err) {
         const msg = toErrorMessage(err);
         const scrubbed = this.opts.secretScrubber.scrub(msg);
+        const { category, retryable, detail } = classifyToolError(err);
+        const tool = this.registry.get(use.name);
+        this.opts.renderer?.writeToolResult(tool?.name ?? use.name, scrubbed, true);
         const result = {
           type: "tool_result",
           tool_use_id: use.id,
@@ -3068,7 +3148,7 @@ ${post.additionalContext}`;
           is_error: true
         };
         budget = this.budgetForString(result.content, budget);
-        return { result, tool: this.registry.get(use.name), durationMs: 0 };
+        return { result, tool, durationMs: 0 };
       }
     };
     if (strategy === "sequential") {
@@ -3273,38 +3353,6 @@ ${excerpt}`;
   budgetForString(content, budget) {
     return Math.max(0, budget - Buffer.byteLength(content, "utf8"));
   }
-  /**
-   * Compute the suggestedPattern string for a tool+input pair.
-   * Matches the logic in DefaultPermissionPolicy so the TUI shows the
-   * same subject that the trust file would use.
-   */
-  subjectFor(toolName, input, subjectKey) {
-    if (!input || typeof input !== "object") return void 0;
-    const obj = input;
-    const globChars = /[*?[\]]/g;
-    const escapeGlob = (s) => s.replace(globChars, (c) => `\\${c}`);
-    const normalizePath = (s) => escapeGlob(s.replace(/\\/g, "/"));
-    if (subjectKey) {
-      const v = obj[subjectKey];
-      if (typeof v === "string") {
-        const isPathKey = subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
-        return isPathKey ? normalizePath(v) : escapeGlob(v);
-      }
-    }
-    if (toolName === "bash" && typeof obj.command === "string") {
-      return escapeGlob(obj.command);
-    }
-    if (typeof obj.path === "string") {
-      return normalizePath(obj.path);
-    }
-    if (typeof obj.url === "string") {
-      return escapeGlob(obj.url);
-    }
-    if (typeof obj.name === "string") {
-      return escapeGlob(obj.name);
-    }
-    return void 0;
-  }
 };
 function clampTimeoutMs(timeoutMs, maxTimeoutMs) {
   const fallback = 3e5;
@@ -3332,6 +3380,58 @@ function extractMalformedRaw(input) {
   }
 }
 var TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES = 64 * 1024;
+function classifyToolError(err) {
+  if (err instanceof Error && err.name === "AbortError") {
+    return { category: "fatal" /* FATAL */, retryable: false, detail: "aborted" };
+  }
+  if (err instanceof Error && "code" in err) {
+    const code = err.code;
+    switch (code) {
+      case "ETIMEDOUT":
+      case "ECONNRESET":
+      case "ECONNREFUSED":
+      case "ENETUNREACH":
+      case "EHOSTUNREACH":
+        return { category: "transient" /* TRANSIENT */, retryable: true, detail: code };
+      case "ENOENT":
+      case "ENOTDIR":
+        return { category: "not_found" /* NOT_FOUND */, retryable: false, detail: code };
+      case "EACCES":
+      case "EPERM":
+        return { category: "permission" /* PERMISSION */, retryable: false, detail: code };
+      case "EBUSY":
+      case "EMFILE":
+      case "ENFILE":
+        return { category: "transient" /* TRANSIENT */, retryable: true, detail: code };
+    }
+  }
+  if (err instanceof Error && "response" in err) {
+    const response = err.response;
+    const status = response?.status;
+    if (status !== void 0) {
+      if (status === 429 || status === 503 || status === 502 || status === 504) {
+        return { category: "transient" /* TRANSIENT */, retryable: true, detail: `HTTP ${status}` };
+      }
+      if (status === 404 || status === 410) {
+        return { category: "not_found" /* NOT_FOUND */, retryable: false, detail: `HTTP ${status}` };
+      }
+      if (status === 401 || status === 403) {
+        return { category: "permission" /* PERMISSION */, retryable: false, detail: `HTTP ${status}` };
+      }
+      if (status === 400) {
+        return { category: "validation" /* VALIDATION */, retryable: false, detail: `HTTP ${status}` };
+      }
+    }
+  }
+  if (err instanceof Error && err.message.includes("validation")) {
+    return { category: "validation" /* VALIDATION */, retryable: false, detail: "validation" };
+  }
+  return {
+    category: "fatal" /* FATAL */,
+    retryable: false,
+    detail: err instanceof Error ? err.message.slice(0, 100) : String(err).slice(0, 100)
+  };
+}
 async function maybePersistLargeToolOutput(toolName, content, budget) {
   const bytes = Buffer.byteLength(content, "utf8");
   if (bytes <= Math.min(TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES, Math.max(0, budget))) {
@@ -4841,7 +4941,7 @@ var SubagentBudget = class _SubagentBudget {
    */
   _busRequestDecision(entry) {
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
     return new Promise((resolve3) => {
@@ -7313,7 +7413,27 @@ Working rules:
       id: "devops",
       name: "DevOps",
       role: "devops",
-      tools: [...TOOLS.build],
+      tools: [
+        ...TOOLS.build,
+        "mcp__ssh__ssh_list_servers",
+        "mcp__ssh__ssh_connection_status",
+        "mcp__ssh__ssh_execute",
+        "mcp__ssh__ssh_execute_sudo",
+        "mcp__ssh__ssh_upload",
+        "mcp__ssh__ssh_download",
+        "mcp__ssh__ssh_sync",
+        "mcp__ssh__ssh_deploy",
+        "mcp__ssh__ssh_health_check",
+        "mcp__ssh__ssh_service_status",
+        "mcp__ssh__ssh_process_manager",
+        "mcp__ssh__ssh_tunnel",
+        "mcp__ssh__ssh_backup_create",
+        "mcp__ssh__ssh_backup_list",
+        "mcp__ssh__ssh_backup_restore",
+        "mcp__ssh__ssh_db_list",
+        "mcp__ssh__ssh_db_query",
+        "mcp__ssh__ssh_profile"
+      ],
       prompt: `You are the DevOps agent. Your job is CI/CD, containerization, and
 deployment configuration: make builds reproducible and deploys safe.
 
@@ -7322,6 +7442,7 @@ Scope:
 - Write Dockerfiles/compose and optimize image size and layer caching
 - Configure deployment (env, secrets handling, health checks, rollback)
 - Diagnose flaky/broken pipelines
+- Use optional SSH MCP tools for remote hosts when the 'ssh' MCP server is enabled: list servers, run health checks, inspect services, transfer/deploy files, and open tunnels
 
 Input format you accept:
 { "task": "ci | container | deploy | fix-pipeline", "platform": "github-actions | gitlab | docker | k8s", "target": "<what>" }
@@ -7336,7 +7457,8 @@ Working rules:
 - Never hardcode secrets in config; reference the secret store
 - Pin versions for reproducible builds; avoid floating :latest
 - Every deploy path needs a rollback and a health check
-- Treat CI/CD changes as high-risk \u2014 explain blast radius before applying`
+- Treat CI/CD changes as high-risk \u2014 explain blast radius before applying
+- For remote SSH work, start with ssh_list_servers / ssh_connection_status, prefer read-only checks first, and do not run destructive commands without explicit user approval`
     },
     budget: MEDIUM_BUDGET,
     capability: {
@@ -7353,6 +7475,13 @@ Working rules:
         "kubernetes",
         "k8s",
         "deploy",
+        "ssh",
+        "remote ssh",
+        "remote server",
+        "sftp",
+        "tunnel",
+        "bastion",
+        "jump host",
         "github actions",
         "container"
       ]
@@ -8935,6 +9064,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         subagentId: result.subagentId,
         taskId: result.taskId,
         status: result.status,
+        result: result.result,
         iterations: result.iterations,
         toolCalls: result.toolCalls,
         durationMs: result.durationMs
@@ -9868,6 +9998,88 @@ function parseDescriptionFromText(desc) {
   return { trigger, scope };
 }
 
-export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, buildGoalPreamble, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, formatDecisionSummary, makeAutonomyPromptContributor };
+// src/execution/model-runtime.ts
+function resolveModelRuntime(settings, reasoning) {
+  const warnings = [];
+  if (!settings) {
+    return { reasoning: void 0, cache: void 0, warnings };
+  }
+  const reasoningField = resolveReasoningForRequest(settings, reasoning, warnings);
+  const cacheField = resolveCacheForRequest(settings);
+  return { reasoning: reasoningField, cache: cacheField, warnings };
+}
+function resolveReasoningForRequest(settings, rc, warnings) {
+  const cfg = settings.reasoning;
+  if (!cfg) return void 0;
+  const capKnown = rc !== void 0;
+  const supportsReasoning = rc ? rc.default !== "disabled" || rc.disableSupported || rc.effortSupported : false;
+  const out = {};
+  if (cfg.mode === "off") {
+    if (capKnown && rc?.disableSupported) {
+      out.enabled = false;
+    } else if (capKnown && rc && rc.default === "always_on") {
+      warnings.push(
+        'reasoning "off" requested, but this model has thinking always on; the disable field was omitted to avoid a provider error.'
+      );
+    } else if (capKnown && rc && !rc.disableSupported) {
+      warnings.push('reasoning "off" requested, but this model does not support disabling thinking; the setting was omitted.');
+    } else {
+      warnings.push('reasoning "off" requested, but model capabilities are unknown; the setting was omitted.');
+    }
+  } else if (cfg.mode === "on") {
+    if (!capKnown) {
+      warnings.push('reasoning "on" requested, but model capabilities are unknown; the setting was omitted.');
+    } else if (!supportsReasoning && rc?.default === "disabled") {
+      warnings.push('reasoning "on" requested, but this model has reasoning disabled by default and does not advertise support; the setting was omitted.');
+    } else {
+      out.enabled = true;
+    }
+  }
+  const effort = cfg.effort;
+  if (effort !== void 0) {
+    if (capKnown && rc?.effortSupported && rc.effortLevels.includes(effort)) {
+      out.effort = effort;
+    } else if (capKnown && rc?.effortSupported) {
+      warnings.push(
+        `reasoning effort "${effort}" not supported by this model (supported: ${rc.effortLevels.join(", ")}); the setting was omitted.`
+      );
+    } else if (capKnown) {
+      warnings.push(`reasoning effort "${effort}" requested, but this model does not support effort; the setting was omitted.`);
+    } else {
+      warnings.push(`reasoning effort "${effort}" requested, but model capabilities are unknown; the setting was omitted.`);
+    }
+  }
+  if (cfg.preserve !== void 0) {
+    if (capKnown && rc && rc.preserveThinking !== "unsupported") {
+      out.preserve = cfg.preserve;
+    } else if (capKnown) {
+      warnings.push("reasoning preserve requested, but this model does not support preserved thinking; the setting was omitted.");
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function resolveCacheForRequest(settings, _warnings) {
+  const ttl = settings.cache?.ttl;
+  if (ttl === void 0) return void 0;
+  const out = { ttl };
+  return out;
+}
+function applyModelRuntime(req, opts) {
+  const settings = opts.getSettings();
+  if (!settings) return req;
+  const rc = opts.getReasoningConfig();
+  const resolved = resolveModelRuntime(settings, rc);
+  for (const w of resolved.warnings) opts.onWarning?.(w);
+  const next = { ...req };
+  if (resolved.reasoning !== void 0) {
+    next.reasoning = resolved.reasoning;
+  }
+  if (resolved.cache !== void 0) {
+    next.cache = resolved.cache;
+  }
+  return next;
+}
+
+export { AutoCompactionMiddleware, AutonomousRunner, DefaultErrorHandler, DefaultRetryPolicy, DefaultSkillLoader, DoneConditionChecker, EternalAutonomyEngine, HybridCompactor, IntelligentCompactor, ParallelEternalEngine, SelectiveCompactor, ToolExecutor, applyModelRuntime, buildGoalPreamble, createAutonomyBrain, createStrategyCompactor, createTieredBrainArbiter, formatDecisionSummary, makeAutonomyPromptContributor, resolveCacheForRequest, resolveModelRuntime, resolveReasoningForRequest };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map