@tangle-network/agent-runtime 0.23.1 → 0.25.0

package/dist/agent.d.ts

@@ -1,103 +1,9 @@
 import * as _tangle_network_agent_eval from '@tangle-network/agent-eval';
-import { FindingSubject, TraceAnalystKindSpec, AnalystFinding } from '@tangle-network/agent-eval';
+import { TraceAnalystKindSpec, AnalystFinding } from '@tangle-network/agent-eval';
 import { R as RuntimeStreamEvent } from './types-BFgFD_sl.js';
-import { I as ImprovementAdapter, K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-D_MXrmJP.js';
-
-/**
- * `AgentSurfaces` — declarative map of the mutable file/directory paths
- * the self-improvement loop can edit on behalf of an agent.
- *
- * The substrate uses this map to resolve every parsed `FindingSubject`
- * (from agent-eval) to a real on-disk path. No per-vertical glue;
- * no fabricated paths; no silent `existsSync(...)` skips that hide
- * misconfiguration from the operator.
- *
- * Surfaces are validated at `defineAgent` time — missing paths fail
- * loud with a list of every offender. A surface that's not needed
- * (e.g. an agent with no RAG corpora) is simply omitted; the loop
- * refuses to route those subjects rather than fabricating a target.
- */
-
-/**
- * Surface declarations. Every path is repo-relative (or absolute) at
- * `defineAgent` time. At resolution time, paths are joined against the
- * agent's `repoRoot`.
- *
- * `systemPrompt`, `tools`, `personas` are DIRECTORIES; the loop appends
- * `<section>.md`, `<tool>/README.md`, `<persona-id>.yaml` etc.
- * `rubric`, `outputSchema` are SINGLE FILES; the loop edits them in
- * place.
- *
- * `knowledge` is the agent-knowledge root (typically `.agent-knowledge`);
- * `applyKnowledgeWriteBlocks` writes pages relative to it.
- *
- * Optional surfaces (`scaffolding`, `memory`, `rag`, `outputSchema`)
- * can be omitted — the loop will reject findings targeting them with a
- * clear log message instead of fabricating a path.
- */
-interface AgentSurfaces {
-    /** Directory containing one markdown file per system-prompt section. */
-    systemPrompt: string;
-    /** Directory containing one subdir per tool (`<tool>/README.md`). */
-    tools: string;
-    /** Single file (TypeScript module) defining the rubric weights + dimensions. */
-    rubric: string;
-    /** Knowledge-base root; typically `.agent-knowledge`. */
-    knowledge: string;
-    /** Directory containing one YAML/JSON file per persona. */
-    personas: string;
-    /** Optional: directory containing scaffolding rules (precondition checks, retry policies). */
-    scaffolding?: string;
-    /** Optional: memory store path (JSONL / SQLite / DB). */
-    memory?: string;
-    /** Optional: directory containing RAG corpora (`<corpus>/<doc-id>.md`). */
-    rag?: string;
-    /** Optional: single file defining the output schema (Zod / JSON Schema). */
-    outputSchema?: string;
-}
-interface ResolvedSurface {
-    /** Absolute filesystem path the operator can `cat` / `vim`. */
-    absolutePath: string;
-    /** Repo-relative path for PR descriptions, diffs, audit logs. */
-    repoRelativePath: string;
-    /** Whether the path currently exists on disk. */
-    exists: boolean;
-    /** The substrate's intent: edit an existing file or create a new one. */
-    intent: 'edit-existing' | 'create-new';
-}
-/**
- * Resolve a parsed `FindingSubject` to the file path the substrate
- * should edit (or create) on disk.
- *
- * Returns `null` when:
- *   - the subject targets a surface the agent didn't declare
- *     (e.g. `rag:*` when `surfaces.rag` is undefined), OR
- *   - the subject is a `cluster` (failure-mode emits these as evidence,
- *     not actionable mutations — they don't route to a file).
- *
- * Returns a `ResolvedSurface` with `intent: 'create-new'` when the
- * subject names a path that doesn't yet exist (e.g. a new wiki page).
- * The caller chooses whether to honour the create — for tightly-managed
- * surfaces like `systemPrompt` it's usually a contract violation
- * (the analyst named a section that doesn't exist); for `knowledge`
- * it's the whole point.
- */
-declare function resolveSubjectPath(subject: FindingSubject, surfaces: AgentSurfaces, repoRoot: string): ResolvedSurface | null;
-/**
- * Validate that every declared surface exists on disk under `repoRoot`.
- *
- * Returns an array of `SurfaceValidationIssue` — empty when all required
- * surfaces resolve. `defineAgent` throws with the issues rendered, so
- * a misconfigured manifest fails at startup (not at the first finding
- * the loop produces 20 minutes later).
- */
-interface SurfaceValidationIssue {
-    surface: keyof AgentSurfaces;
-    path: string;
-    reason: 'missing' | 'not-directory' | 'not-file';
-}
-declare function validateSurfaces(surfaces: AgentSurfaces, repoRoot: string): ReadonlyArray<SurfaceValidationIssue>;
-declare function renderSurfaceIssues(issues: ReadonlyArray<SurfaceValidationIssue>, repoRoot: string): string;
+import { A as AgentSurfaces } from './improvement-adapter-CaZxFxTd.js';
+export { C as CreateSurfaceImprovementAdapterOpts, D as DraftPatchInput, a as DraftPatchOutput, R as ResolvedSurface, S as SurfaceImprovementEdit, b as SurfaceValidationIssue, c as createSurfaceImprovementAdapter, r as renderSurfaceIssues, d as resolveSubjectPath, v as validateSurfaces } from './improvement-adapter-CaZxFxTd.js';
+import { K as KnowledgeAdapter, a as RunAnalystLoopResult } from './types-D_MXrmJP.js';
 
 /**
  * The full agent manifest. Each agent ships ONE of these.
@@ -342,113 +248,6 @@ declare class AgentManifestError extends Error {
  */
 declare function defineAgent<TPersona = unknown, TRunOutput = unknown>(manifest: AgentManifest<TPersona, TRunOutput>): AgentManifest<TPersona, TRunOutput>;
 
-/**
- * Substrate-default `ImprovementAdapter` — surfaces-driven, LLM-drafted
- * patches, optional auto-apply or PR-open.
- *
- * This is the one ImprovementAdapter every vertical agent uses. The
- * substrate parses each finding's `subject` via
- * `parseFindingSubject` (agent-eval), resolves it to a real file path
- * via the agent's `AgentSurfaces`, reads the current content, and asks
- * an LLM to draft a unified-diff patch given the finding + current
- * content + per-kind editing-discipline rules.
- *
- * Auto-apply gates on the source-finding's confidence and the
- * autoApply.improvement policy. Two modes:
- *   `write` — apply the patch in-place via `git apply -p0`. Operator
- *     reviews via `git diff`.
- *   `open-pr` — write to a branch, commit, push, open a PR via `gh`.
- *     Operator reviews via the PR UI.
- *
- * Fail-loud rules:
- *   - Findings whose subject doesn't parse → counted in `errors`.
- *   - Findings whose subject targets an undeclared surface → counted in
- *     `errors` with the offending kind in the message.
- *   - Findings whose target path doesn't exist AND the kind isn't a
- *     create-new variant (`new-tool`, `knowledge.wiki`) → counted in
- *     `errors` with the resolved path in the message.
- *   - LLM drafts that fail JSON-schema validation → counted in
- *     `errors` with the schema issue.
- *
- * No silent skips. Every dropped finding has a recorded reason the
- * loop's report surfaces.
- */
-
-interface SurfaceImprovementEdit {
-    /** Stable id derived from the source finding so re-proposals are idempotent. */
-    id: string;
-    /** The finding that produced this edit — for revert + audit trail. */
-    sourceFindingId: string;
-    /** Parsed subject; included so the apply step doesn't re-parse. */
-    subject: FindingSubject;
-    /** Resolved on-disk target. */
-    target: ResolvedSurface;
-    /** SHA-256 of the current file content the patch was drafted against. */
-    baseSha256: string;
-    /** Unified-diff patch the LLM drafted (relative to `target.absolutePath`). */
-    patch: string;
-    /** One-line summary the operator sees in the report / PR title. */
-    summary: string;
-    /** Multi-line rationale for the PR body — finding context + LLM reasoning. */
-    rationale: string;
-    /** Carry-forward from the finding so the apply gate can check the threshold. */
-    confidence: number;
-    /** Carry-forward severity for prioritization. */
-    severity: AnalystFinding['severity'];
-}
-interface CreateSurfaceImprovementAdapterOpts {
-    surfaces: AgentSurfaces;
-    repoRoot: string;
-    /**
-     * LLM-draft callback. Given a finding + current file content + the
-     * resolved target, returns a unified-diff patch + summary + rationale.
-     *
-     * Required — the substrate doesn't ship a hardcoded prompt; the agent
-     * author picks the model (Haiku for cheap routine drafts, Sonnet for
-     * substantive prompt rewrites, etc.) via this callback.
-     */
-    draftPatch: (input: DraftPatchInput) => Promise<DraftPatchOutput>;
-    /**
-     * Apply mode:
-     *   `write` — `git apply` in-place; operator reviews via `git diff`
-     *   `open-pr` — branch + commit + push + `gh pr create`
-     *   `none` — never apply; collect proposals for the report only
-     *
-     * The `apply` method honours this even when the loop calls it; the
-     * effective behaviour is also gated on the per-finding confidence
-     * threshold via `runAnalystLoop`'s `autoApply` policy.
-     */
-    mode?: 'write' | 'open-pr' | 'none';
-    /** When `mode === 'open-pr'`, the base branch new PRs target. Default: `main`. */
-    baseBranch?: string;
-    /** Required for `mode === 'open-pr'` — the GH owner/repo (`tangle-network/tax-agent`). */
-    ghRepo?: string;
-    /**
-     * When the resolved target doesn't exist, allow the substrate to
-     * CREATE the file (for `knowledge.wiki`, `new-tool` subjects). Default
-     * true for those kinds, false for `system-prompt` / `rubric` / etc.
-     * (named sections that don't exist are a contract violation, not a
-     * scaffolding opportunity).
-     */
-    allowCreateForKinds?: ReadonlyArray<FindingSubject['kind']>;
-}
-interface DraftPatchInput {
-    finding: AnalystFinding;
-    subject: FindingSubject;
-    target: ResolvedSurface;
-    /** Current file content (empty string when `intent === 'create-new'`). */
-    currentContent: string;
-}
-interface DraftPatchOutput {
-    /** Unified diff against the current file content. Empty string skips this finding. */
-    patch: string;
-    /** One-line summary for the operator. */
-    summary: string;
-    /** Multi-line rationale for the PR body. */
-    rationale: string;
-}
-declare function createSurfaceImprovementAdapter(opts: CreateSurfaceImprovementAdapterOpts): ImprovementAdapter<SurfaceImprovementEdit>;
-
 /**
  * Substrate-default `KnowledgeAdapter` — wraps agent-knowledge's
  * `proposeFromFindings` + `applyKnowledgeWriteBlocks` with substrate
@@ -580,4 +379,4 @@ declare function measureOutcome<TProposal, TEdit>(result: RunAnalystLoopResult<T
     outcome: OutcomeMeasurement;
 }>;
 
-export { type AgentManifest, AgentManifestError, type AgentRubric, type AgentRunContext, type AgentRunInvocation, type AgentRuntime, type AgentSurfaces, type AnalystConfig, type AutoApplyPolicy, type CreateSurfaceImprovementAdapterOpts, type CreateSurfaceKnowledgeAdapterOpts, type DraftPatchInput, type DraftPatchOutput, type JudgeConfig, type KnowledgeAdapterDeps, type OutcomeMeasurement, type OutcomeMeasurementOpts, type ResolvedSurface, type RubricDimension, type SurfaceImprovementEdit, type SurfaceValidationIssue, collectAgentRun, createSurfaceImprovementAdapter, createSurfaceKnowledgeAdapter, defineAgent, measureOutcome, renderSurfaceIssues, resolveSubjectPath, unimplementedAgentRun, validateSurfaces };
+export { type AgentManifest, AgentManifestError, type AgentRubric, type AgentRunContext, type AgentRunInvocation, type AgentRuntime, AgentSurfaces, type AnalystConfig, type AutoApplyPolicy, type CreateSurfaceKnowledgeAdapterOpts, type JudgeConfig, type KnowledgeAdapterDeps, type OutcomeMeasurement, type OutcomeMeasurementOpts, type RubricDimension, collectAgentRun, createSurfaceKnowledgeAdapter, defineAgent, measureOutcome, unimplementedAgentRun };

package/dist/chunk-GLR25NG7.js

@@ -0,0 +1,92 @@
+// src/mcp/local-harness.ts
+import { spawn } from "child_process";
+var HARNESS_INVOCATIONS = {
+  claude: {
+    command: "claude",
+    buildArgs: (taskPrompt) => ["--headless", "-p", taskPrompt]
+  },
+  codex: {
+    command: "codex",
+    buildArgs: (taskPrompt) => ["run", taskPrompt]
+  },
+  opencode: {
+    command: "opencode",
+    buildArgs: (taskPrompt) => ["run", taskPrompt]
+  }
+};
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+function runLocalHarness(options) {
+  const { harness, cwd, taskPrompt } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const env = options.env ?? process.env;
+  const spawnImpl = options.spawn ?? spawn;
+  const invocation = HARNESS_INVOCATIONS[harness];
+  if (!invocation) {
+    return Promise.reject(new Error(`runLocalHarness: unknown harness ${String(harness)}`));
+  }
+  const startedAt = Date.now();
+  const args = invocation.buildArgs(taskPrompt);
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawnImpl(invocation.command, args, { cwd, env, stdio: "pipe" });
+    } catch (err) {
+      reject(err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let settled = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      if (!child.killed) child.kill("SIGTERM");
+    }, timeoutMs) : null;
+    if (timer && typeof timer.unref === "function") {
+      ;
+      timer.unref();
+    }
+    const onAbort = () => {
+      if (!child.killed) child.kill("SIGTERM");
+    };
+    if (options.signal) {
+      if (options.signal.aborted) onAbort();
+      else options.signal.addEventListener("abort", onAbort, { once: true });
+    }
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    const finalize = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve(result);
+    };
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      reject(err);
+    });
+    child.on("close", (code, signal) => {
+      finalize({
+        exitCode: code,
+        stdout,
+        stderr,
+        killedBySignal: signal,
+        durationMs: Date.now() - startedAt,
+        timedOut
+      });
+    });
+  });
+}
+
+export {
+  runLocalHarness
+};
+//# sourceMappingURL=chunk-GLR25NG7.js.map

package/dist/chunk-GLR25NG7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp/local-harness.ts"],"sourcesContent":["/**\n * @experimental\n *\n * Subprocess wrappers for the local coding-harness CLIs installed in the\n * sandbox image (claude-code, codex, opencode). Used by the in-process\n * delegation executor (`createInProcessExecutor`) so a `delegate_code` call\n * spawns a real harness on a real git worktree instead of provisioning a\n * sibling sandbox.\n *\n * All harness invocations:\n *   - run with `cwd` set to the worktree\n *   - inherit env from the parent (the MCP server inside the sandbox has\n *     the harness's auth already)\n *   - capture stdout/stderr\n *   - support cancellation via AbortSignal\n *   - enforce a wall-clock timeout\n */\n\nimport { type ChildProcess, spawn } from 'node:child_process'\n\n/** Local coding harness available inside the sandbox. */\nexport type LocalHarness = 'claude' | 'codex' | 'opencode'\n\n/** Default per-harness command + arg shape. */\nconst HARNESS_INVOCATIONS: Record<\n  LocalHarness,\n  { command: string; buildArgs: (taskPrompt: string) => string[] }\n> = {\n  claude: {\n    command: 'claude',\n    buildArgs: (taskPrompt) => ['--headless', '-p', taskPrompt],\n  },\n  codex: {\n    command: 'codex',\n    buildArgs: (taskPrompt) => ['run', taskPrompt],\n  },\n  opencode: {\n    command: 'opencode',\n    buildArgs: (taskPrompt) => ['run', taskPrompt],\n  },\n}\n\n/** @experimental */\nexport interface RunLocalHarnessOptions {\n  harness: LocalHarness\n  /** Working directory for the subprocess (typically a worktree path). */\n  cwd: string\n  /** Prompt forwarded as the harness CLI's task argument. */\n  taskPrompt: string\n  /** Wall-clock kill deadline (ms). Default 5 min. Subprocess SIGTERMed on expiry. */\n  timeoutMs?: number\n  /** Caller cancellation. SIGTERM is sent on abort. */\n  signal?: AbortSignal\n  /** Override env (defaults to inheriting from the parent). */\n  env?: NodeJS.ProcessEnv\n  /**\n   * Test seam — inject a custom spawner so unit tests can mock the\n   * subprocess without touching the OS. Defaults to node's `child_process.spawn`.\n   */\n  spawn?: (\n    command: string,\n    args: ReadonlyArray<string>,\n    opts: {\n      cwd: string\n      env: NodeJS.ProcessEnv\n      stdio: 'pipe'\n    },\n  ) => ChildProcess\n}\n\n/** @experimental */\nexport interface LocalHarnessResult {\n  /** OS exit code. `null` when killed before exit. */\n  exitCode: number | null\n  /** Concatenated stdout. */\n  stdout: string\n  /** Concatenated stderr. */\n  stderr: string\n  /** Set when the process exited via signal (timeout / abort). */\n  killedBySignal: NodeJS.Signals | null\n  /** Wall-clock duration ms (spawn → exit). */\n  durationMs: number\n  /** Set when timeoutMs elapsed before exit. */\n  timedOut: boolean\n}\n\nconst DEFAULT_TIMEOUT_MS = 5 * 60 * 1000\n\n/**\n * Spawn a local coding harness CLI as a subprocess + collect its output.\n *\n * NOT responsible for parsing the harness's output or extracting a diff —\n * the in-process executor's `streamPrompt` orchestrates `git diff` against\n * the worktree after this resolves. This function is intentionally narrow:\n * spawn, wait, capture, return.\n *\n * Fails loud — throws when:\n *   - `cwd` doesn't exist (subprocess emits ENOENT; surfaced as Error)\n *   - the harness binary is not on PATH (ENOENT)\n *\n * Does NOT throw when:\n *   - the subprocess exits non-zero (`result.exitCode` carries the code)\n *   - the subprocess is aborted / timed out (`result.killedBySignal` /\n *     `result.timedOut` carries the reason)\n *\n * @experimental\n */\nexport function runLocalHarness(options: RunLocalHarnessOptions): Promise<LocalHarnessResult> {\n  const { harness, cwd, taskPrompt } = options\n  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS\n  const env = options.env ?? process.env\n  const spawnImpl = options.spawn ?? spawn\n\n  const invocation = HARNESS_INVOCATIONS[harness]\n  if (!invocation) {\n    return Promise.reject(new Error(`runLocalHarness: unknown harness ${String(harness)}`))\n  }\n\n  const startedAt = Date.now()\n  const args = invocation.buildArgs(taskPrompt)\n\n  return new Promise<LocalHarnessResult>((resolve, reject) => {\n    let child: ChildProcess\n    try {\n      child = spawnImpl(invocation.command, args, { cwd, env, stdio: 'pipe' })\n    } catch (err) {\n      reject(err instanceof Error ? err : new Error(String(err)))\n      return\n    }\n\n    let stdout = ''\n    let stderr = ''\n    let timedOut = false\n    let settled = false\n\n    const timer =\n      timeoutMs > 0\n        ? setTimeout(() => {\n            timedOut = true\n            if (!child.killed) child.kill('SIGTERM')\n          }, timeoutMs)\n        : null\n    if (timer && typeof (timer as { unref?: () => void }).unref === 'function') {\n      ;(timer as { unref: () => void }).unref()\n    }\n\n    const onAbort = () => {\n      if (!child.killed) child.kill('SIGTERM')\n    }\n    if (options.signal) {\n      if (options.signal.aborted) onAbort()\n      else options.signal.addEventListener('abort', onAbort, { once: true })\n    }\n\n    child.stdout?.on('data', (chunk) => {\n      stdout += String(chunk)\n    })\n    child.stderr?.on('data', (chunk) => {\n      stderr += String(chunk)\n    })\n\n    const finalize = (result: LocalHarnessResult) => {\n      if (settled) return\n      settled = true\n      if (timer) clearTimeout(timer)\n      options.signal?.removeEventListener('abort', onAbort)\n      resolve(result)\n    }\n\n    child.on('error', (err) => {\n      if (settled) return\n      settled = true\n      if (timer) clearTimeout(timer)\n      options.signal?.removeEventListener('abort', onAbort)\n      reject(err)\n    })\n\n    child.on('close', (code, signal) => {\n      finalize({\n        exitCode: code,\n        stdout,\n        stderr,\n        killedBySignal: signal,\n        durationMs: Date.now() - startedAt,\n        timedOut,\n      })\n    })\n  })\n}\n"],"mappings":";AAkBA,SAA4B,aAAa;AAMzC,IAAM,sBAGF;AAAA,EACF,QAAQ;AAAA,IACN,SAAS;AAAA,IACT,WAAW,CAAC,eAAe,CAAC,cAAc,MAAM,UAAU;AAAA,EAC5D;AAAA,EACA,OAAO;AAAA,IACL,SAAS;AAAA,IACT,WAAW,CAAC,eAAe,CAAC,OAAO,UAAU;AAAA,EAC/C;AAAA,EACA,UAAU;AAAA,IACR,SAAS;AAAA,IACT,WAAW,CAAC,eAAe,CAAC,OAAO,UAAU;AAAA,EAC/C;AACF;AA8CA,IAAM,qBAAqB,IAAI,KAAK;AAqB7B,SAAS,gBAAgB,SAA8D;AAC5F,QAAM,EAAE,SAAS,KAAK,WAAW,IAAI;AACrC,QAAM,YAAY,QAAQ,aAAa;AACvC,QAAM,MAAM,QAAQ,OAAO,QAAQ;AACnC,QAAM,YAAY,QAAQ,SAAS;AAEnC,QAAM,aAAa,oBAAoB,OAAO;AAC9C,MAAI,CAAC,YAAY;AACf,WAAO,QAAQ,OAAO,IAAI,MAAM,oCAAoC,OAAO,OAAO,CAAC,EAAE,CAAC;AAAA,EACxF;AAEA,QAAM,YAAY,KAAK,IAAI;AAC3B,QAAM,OAAO,WAAW,UAAU,UAAU;AAE5C,SAAO,IAAI,QAA4B,CAAC,SAAS,WAAW;AAC1D,QAAI;AACJ,QAAI;AACF,cAAQ,UAAU,WAAW,SAAS,MAAM,EAAE,KAAK,KAAK,OAAO,OAAO,CAAC;AAAA,IACzE,SAAS,KAAK;AACZ,aAAO,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC,CAAC;AAC1D;AAAA,IACF;AAEA,QAAI,SAAS;AACb,QAAI,SAAS;AACb,QAAI,WAAW;AACf,QAAI,UAAU;AAEd,UAAM,QACJ,YAAY,IACR,WAAW,MAAM;AACf,iBAAW;AACX,UAAI,CAAC,MAAM,OAAQ,OAAM,KAAK,SAAS;AAAA,IACzC,GAAG,SAAS,IACZ;AACN,QAAI,SAAS,OAAQ,MAAiC,UAAU,YAAY;AAC1E;AAAC,MAAC,MAAgC,MAAM;AAAA,IAC1C;AAEA,UAAM,UAAU,MAAM;AACpB,UAAI,CAAC,MAAM,OAAQ,OAAM,KAAK,SAAS;AAAA,IACzC;AACA,QAAI,QAAQ,QAAQ;AAClB,UAAI,QAAQ,OAAO,QAAS,SAAQ;AAAA,UAC/B,SAAQ,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;AAAA,IACvE;AAEA,UAAM,QAAQ,GAAG,QAAQ,CAAC,UAAU;AAClC,gBAAU,OAAO,KAAK;AAAA,IACxB,CAAC;AACD,UAAM,QAAQ,GAAG,QAAQ,CAAC,UAAU;AAClC,gBAAU,OAAO,KAAK;AAAA,IACxB,CAAC;AAED,UAAM,WAAW,CAAC,WAA+B;AAC/C,UAAI,QAAS;AACb,gBAAU;AACV,UAAI,MAAO,cAAa,KAAK;AAC7B,cAAQ,QAAQ,oBAAoB,SAAS,OAAO;AACpD,cAAQ,MAAM;AAAA,IAChB;AAEA,UAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,UAAI,QAAS;AACb,gBAAU;AACV,UAAI,MAAO,cAAa,KAAK;AAC7B,cAAQ,QAAQ,oBAAoB,SAAS,OAAO;AACpD,aAAO,GAAG;AAAA,IACZ,CAAC;AAED,UAAM,GAAG,SAAS,CAAC,MAAM,WAAW;AAClC,eAAS;AAAA,QACP,UAAU;AAAA,QACV;AAAA,QACA;AAAA,QACA,gBAAgB;AAAA,QAChB,YAAY,KAAK,IAAI,IAAI;AAAA,QACzB;AAAA,MACF,CAAC;AAAA,IACH,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}

package/dist/{chunk-IQHYOJU3.js → chunk-ZJACJZF7.js}

@@ -22,6 +22,9 @@ import {
   createDelegationHistoryHandler,
   createDelegationStatusHandler
 } from "./chunk-UNQM6XQO.js";
+import {
+  runLocalHarness
+} from "./chunk-GLR25NG7.js";
 import {
   runLoop
 } from "./chunk-TZ53F7M7.js";
@@ -96,9 +99,276 @@ function readId(box) {
   return typeof raw === "string" && raw.length > 0 ? raw : void 0;
 }
 
+// src/mcp/worktree.ts
+import { spawn } from "child_process";
+async function runGitAsync(args, cwd, runner) {
+  if (runner) return runner(args, { cwd });
+  return new Promise((resolve, reject) => {
+    const proc = spawn("git", args, { cwd, stdio: "pipe" });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (c) => {
+      stdout += String(c);
+    });
+    proc.stderr?.on("data", (c) => {
+      stderr += String(c);
+    });
+    proc.on("error", reject);
+    proc.on("close", (code) => resolve({ stdout, stderr, exitCode: code ?? -1 }));
+  });
+}
+function ensureGitOk(step, result) {
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `worktree: git ${step} failed (exit ${result.exitCode}): ${result.stderr.slice(0, 400)}`
+    );
+  }
+}
+async function createWorktree(options) {
+  const variants = options.variantsDir ?? ".coder-variants";
+  const baseRef = options.baseRef ?? "HEAD";
+  const branch = `delegate/${options.runId}`;
+  const path = `${options.repoRoot.replace(/\/+$/, "")}/${variants}/${options.runId}`;
+  const headSha = await runGitAsync(["rev-parse", baseRef], options.repoRoot, options.runGit);
+  ensureGitOk(`rev-parse ${baseRef}`, headSha);
+  const add = await runGitAsync(
+    ["worktree", "add", "-b", branch, path, baseRef],
+    options.repoRoot,
+    options.runGit
+  );
+  ensureGitOk(`worktree add ${path}`, add);
+  return { path, baseSha: headSha.stdout.trim(), branch };
+}
+async function captureWorktreeDiff(options) {
+  const baseRef = options.baseRef ?? options.worktree.baseSha;
+  const patch = await runGitAsync(["diff", baseRef], options.worktree.path, options.runGit);
+  const shortstat = await runGitAsync(
+    ["diff", "--shortstat", baseRef],
+    options.worktree.path,
+    options.runGit
+  );
+  const stats = parseShortstat(shortstat.stdout);
+  return { patch: patch.stdout, stats };
+}
+function parseShortstat(text) {
+  const out = { filesChanged: 0, insertions: 0, deletions: 0 };
+  const filesMatch = text.match(/(\d+)\s+files?\s+changed/);
+  if (filesMatch?.[1]) out.filesChanged = Number(filesMatch[1]);
+  const insertMatch = text.match(/(\d+)\s+insertions?/);
+  if (insertMatch?.[1]) out.insertions = Number(insertMatch[1]);
+  const deleteMatch = text.match(/(\d+)\s+deletions?/);
+  if (deleteMatch?.[1]) out.deletions = Number(deleteMatch[1]);
+  return out;
+}
+async function removeWorktree(options) {
+  const force = options.force ?? true;
+  const args = ["worktree", "remove"];
+  if (force) args.push("--force");
+  args.push(options.worktree.path);
+  const result = await runGitAsync(args, options.repoRoot, options.runGit);
+  if (result.exitCode !== 0 && !/not a working tree/.test(result.stderr)) {
+    await runGitAsync(
+      ["branch", "-D", options.worktree.branch],
+      options.repoRoot,
+      options.runGit
+    ).catch(() => void 0);
+  }
+  await runGitAsync(
+    ["branch", "-D", options.worktree.branch],
+    options.repoRoot,
+    options.runGit
+  ).catch(() => void 0);
+}
+
+// src/mcp/in-process-executor.ts
+import { randomUUID } from "crypto";
+var DEFAULT_HARNESS_TIMEOUT_MS = 5 * 60 * 1e3;
+var DEFAULT_POSTCHECK_TIMEOUT_MS = 2 * 60 * 1e3;
+function createInProcessExecutor(options) {
+  const harnesses = options.harnesses && options.harnesses.length > 0 ? [...options.harnesses] : ["claude"];
+  const runHarness = options.runHarness ?? runLocalHarness;
+  const runPostCheck = options.runPostCheck ?? defaultRunPostCheck;
+  let callIndex = 0;
+  const client = {
+    async create(_opts) {
+      const runId = randomUUID();
+      const harness = harnesses[callIndex % harnesses.length];
+      callIndex += 1;
+      const virtual = {
+        // Synthesize the minimum SandboxInstance surface the kernel touches.
+        // We CAST through unknown because SandboxInstance is a `declare class`
+        // with private fields; we're producing a structural subtype that
+        // satisfies the kernel's narrow usage (`box.id`, `box.streamPrompt`).
+        id: `in-process-${runId}`,
+        __inProcess: { runId, harness },
+        // eslint-disable-next-line require-yield
+        async *streamPrompt(message, promptOpts) {
+          const taskPrompt = typeof message === "string" ? message : message.map(
+            (p) => typeof p === "object" && p && "text" in p ? String(p.text) : ""
+          ).join("\n");
+          let worktree;
+          try {
+            worktree = await createWorktree({
+              repoRoot: options.repoRoot,
+              runId,
+              runGit: options.runGit
+            });
+            this.__inProcess.worktree = worktree;
+            yield {
+              type: "in_process.harness.started",
+              data: {
+                runId,
+                harness,
+                worktreePath: worktree.path,
+                command: harness
+              }
+            };
+            const harnessResult = await runHarness({
+              harness,
+              cwd: worktree.path,
+              taskPrompt,
+              timeoutMs: options.harnessTimeoutMs ?? DEFAULT_HARNESS_TIMEOUT_MS,
+              signal: promptOpts?.signal
+            });
+            yield {
+              type: "in_process.harness.ended",
+              data: {
+                runId,
+                exitCode: harnessResult.exitCode,
+                durationMs: harnessResult.durationMs,
+                killedBySignal: harnessResult.killedBySignal,
+                timedOut: harnessResult.timedOut,
+                stdoutBytes: harnessResult.stdout.length,
+                stderrBytes: harnessResult.stderr.length
+              }
+            };
+            const diff = await captureWorktreeDiff({ worktree, runGit: options.runGit });
+            const testCheck = options.testCmd ? await runPostCheck(options.testCmd, worktree.path, promptOpts?.signal).catch(
+              (err) => ({
+                exitCode: -1,
+                stdout: "",
+                stderr: err instanceof Error ? err.message : String(err)
+              })
+            ) : { exitCode: 0, stdout: "", stderr: "" };
+            const typecheckCheck = options.typecheckCmd ? await runPostCheck(options.typecheckCmd, worktree.path, promptOpts?.signal).catch(
+              (err) => ({
+                exitCode: -1,
+                stdout: "",
+                stderr: err instanceof Error ? err.message : String(err)
+              })
+            ) : { exitCode: 0, stdout: "", stderr: "" };
+            const coderOutput = {
+              branch: worktree.branch,
+              patch: diff.patch,
+              testResult: {
+                passed: !options.testCmd || testCheck.exitCode === 0,
+                output: tail(testCheck.stderr || testCheck.stdout, 4e3)
+              },
+              typecheckResult: {
+                passed: !options.typecheckCmd || typecheckCheck.exitCode === 0,
+                output: tail(typecheckCheck.stderr || typecheckCheck.stdout, 4e3)
+              },
+              diffStats: diff.stats,
+              reviewerNotes: harnessResult.exitCode === 0 ? void 0 : `harness ${harness} exited ${harnessResult.exitCode}${harnessResult.timedOut ? " (timed out)" : ""}`
+            };
+            yield {
+              type: "result",
+              data: {
+                result: coderOutput,
+                source: "in-process-executor",
+                harness,
+                runId
+              }
+            };
+          } finally {
+            if (worktree) {
+              await removeWorktree({
+                worktree,
+                repoRoot: options.repoRoot,
+                runGit: options.runGit
+              }).catch(() => void 0);
+            }
+          }
+        }
+      };
+      return virtual;
+    },
+    describePlacement(box) {
+      const sandboxId = box.id;
+      const meta = box.__inProcess;
+      return {
+        kind: "sibling",
+        sandboxId,
+        worktreePath: meta?.worktree?.path,
+        harness: meta?.harness
+      };
+    }
+  };
+  return {
+    client,
+    describe() {
+      return `in-process (repoRoot=${options.repoRoot}, harnesses=[${harnesses.join(",")}]${options.testCmd ? `, testCmd="${options.testCmd}"` : ""}${options.typecheckCmd ? `, typecheckCmd="${options.typecheckCmd}"` : ""})`;
+    }
+  };
+}
+async function defaultRunPostCheck(cmd, cwd, signal) {
+  const { spawn: spawn2 } = await import("child_process");
+  return new Promise((resolve, reject) => {
+    const child = spawn2("sh", ["-c", cmd], { cwd, stdio: "pipe" });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (c) => {
+      stdout += String(c);
+    });
+    child.stderr?.on("data", (c) => {
+      stderr += String(c);
+    });
+    if (signal) {
+      const onAbort = () => {
+        if (!child.killed) child.kill("SIGTERM");
+      };
+      if (signal.aborted) onAbort();
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const killTimer = setTimeout(() => {
+      if (!child.killed) child.kill("SIGTERM");
+    }, DEFAULT_POSTCHECK_TIMEOUT_MS);
+    if (typeof killTimer.unref === "function") {
+      ;
+      killTimer.unref();
+    }
+    child.on("error", (err) => {
+      clearTimeout(killTimer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      resolve({ exitCode: code ?? -1, stdout, stderr });
+    });
+  });
+}
+function tail(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(text.length - max);
+}
+
 // src/mcp/bin-helpers.ts
 async function detectExecutor(args) {
   const env = args.env ?? process.env;
+  if (env.AGENT_RUNTIME_IN_SANDBOX === "1") {
+    const repoRoot = env.AGENT_RUNTIME_REPO_ROOT?.trim();
+    if (!repoRoot) {
+      throw new Error(
+        "agent-runtime-mcp: AGENT_RUNTIME_IN_SANDBOX=1 requires AGENT_RUNTIME_REPO_ROOT to point at the workspace root"
+      );
+    }
+    return createInProcessExecutor({
+      repoRoot,
+      harnesses: parseHarnesses(env.AGENT_RUNTIME_LOCAL_HARNESSES),
+      testCmd: env.AGENT_RUNTIME_TEST_CMD?.trim() || void 0,
+      typecheckCmd: env.AGENT_RUNTIME_TYPECHECK_CMD?.trim() || void 0
+    });
+  }
   const fleetId = parseFleetId(env.TANGLE_FLEET_ID);
   if (!fleetId) {
     return createSiblingSandboxExecutor({ client: args.sandboxClient });
@@ -111,6 +381,20 @@ async function detectExecutor(args) {
     excludeMachineIds
   });
 }
+var KNOWN_HARNESSES = ["claude", "codex", "opencode"];
+function parseHarnesses(raw) {
+  if (!raw) return void 0;
+  const parts = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  if (parts.length === 0) return void 0;
+  for (const part of parts) {
+    if (!KNOWN_HARNESSES.includes(part)) {
+      throw new Error(
+        `agent-runtime-mcp: AGENT_RUNTIME_LOCAL_HARNESSES contains unknown harness "${part}". Expected: ${KNOWN_HARNESSES.join(", ")}.`
+      );
+    }
+  }
+  return parts;
+}
 async function defaultResolveFleet(sandboxClient, fleetId) {
   const fleets = sandboxClient.fleets;
   if (!fleets || typeof fleets.get !== "function") {
@@ -419,9 +703,13 @@ function createInProcessTransport() {
 export {
   createSiblingSandboxExecutor,
   createFleetWorkspaceExecutor,
+  createWorktree,
+  captureWorktreeDiff,
+  removeWorktree,
+  createInProcessExecutor,
   detectExecutor,
   createDefaultCoderDelegate,
   createMcpServer,
   createInProcessTransport
 };
-//# sourceMappingURL=chunk-IQHYOJU3.js.map
+//# sourceMappingURL=chunk-ZJACJZF7.js.map