smol-symphony 0.2.0 → 0.3.1

package/dist/actions/predicate-env.js

@@ -1,27 +0,0 @@
-// Production-side adapter for `PredicateEnv` (issue 96). Backs
-// `branchExists` with `git rev-parse --verify --quiet` (via the unified
-// `runProcess`) and `pathExists` with `fs.stat`. Lives outside the
-// functional-core lint group so `src/actions/predicates.ts` can stay free of
-// `node:fs/promises` and `runProcess` direct imports; the runner threads
-// `defaultPredicateEnv` into the executor.
-import { stat } from 'node:fs/promises';
-import { runProcess } from '../util/process.js';
-export const defaultPredicateEnv = {
-    async branchExists(ref, workspacePath) {
-        // `--verify --quiet` keeps both streams empty on the happy path; the
-        // tiny default byte clamp is plenty and `appendErrorToStderr: false`
-        // skips stderr decoration for the missing-ref case (the common one).
-        const r = await runProcess('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${ref}`], { cwd: workspacePath, appendErrorToStderr: false });
-        return r.exit_code === 0;
-    },
-    async pathExists(absPath) {
-        try {
-            const st = await stat(absPath);
-            return st.isFile() || st.isDirectory();
-        }
-        catch {
-            return false;
-        }
-    },
-};
-//# sourceMappingURL=predicate-env.js.map

package/dist/actions/predicate-env.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicate-env.js","sourceRoot":"","sources":["../../src/actions/predicate-env.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,wEAAwE;AACxE,mEAAmE;AACnE,6EAA6E;AAC7E,yEAAyE;AACzE,2CAA2C;AAE3C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD,MAAM,CAAC,MAAM,mBAAmB,GAAiB;IAC/C,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,aAAa;QACnC,qEAAqE;QACrE,qEAAqE;QACrE,qEAAqE;QACrE,MAAM,CAAC,GAAG,MAAM,UAAU,CACxB,KAAK,EACL,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,GAAG,EAAE,CAAC,EACzD,EAAE,GAAG,EAAE,aAAa,EAAE,mBAAmB,EAAE,KAAK,EAAE,CACnD,CAAC;QACF,OAAO,CAAC,CAAC,SAAS,KAAK,CAAC,CAAC;IAC3B,CAAC;IACD,KAAK,CAAC,UAAU,CAAC,OAAO;QACtB,IAAI,CAAC;YACH,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,CAAC;YAC/B,OAAO,EAAE,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACzC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;CACF,CAAC"}

package/dist/actions/predicates.js

@@ -1,49 +0,0 @@
-// `if:` predicate evaluation (issue 36).
-//
-// Three predicate shapes — env-var-truthy, branch-exists, file-present.
-// These are the three predicates the hook shell actually exercised across
-// today's WORKFLOW.md; the issue body explicitly caps the predicate set
-// there: "If users want more, they've outgrown declarative."
-import path from 'node:path';
-import { renderTemplate } from './templating.js';
-/**
- * Evaluate a predicate against the context. `null`/undefined → always true
- * (no `if:` → run unconditionally).
- *
- * The string form `"$var"` is a truthiness check on the named context field
- * — `if: $repo` matches the issue body's example exactly. A bare literal
- * (`if: yes`) is treated as truthy; the literal-false case `if: ""` /
- * `if: null` falls through to "always".
- *
- * IO is routed through the injected `PredicateEnv` so the evaluator core
- * stays pure (no `node:fs` / `runProcess` imports). String-truthy predicates
- * never touch the env.
- */
-export async function evaluatePredicate(predicate, ctx, workspacePath, env) {
-    if (predicate === null || predicate === undefined)
-        return true;
-    if (typeof predicate === 'string') {
-        // Templates may already have been rendered by the executor's renderTree
-        // pass before evaluatePredicate is called; re-rendering an already-rendered
-        // empty string is a no-op. An empty (or empty-after-render) predicate is
-        // explicitly false — the intent of `if: $repo` with $repo unset is "skip
-        // when the var is empty," not "always run".
-        const expanded = renderTemplate(predicate, ctx).trim();
-        return expanded.length > 0;
-    }
-    if ('branch_exists' in predicate) {
-        const ref = renderTemplate(predicate.branch_exists, ctx).trim();
-        if (ref.length === 0)
-            return false;
-        return env.branchExists(ref, workspacePath);
-    }
-    if ('file_present' in predicate) {
-        const file = renderTemplate(predicate.file_present, ctx).trim();
-        if (file.length === 0)
-            return false;
-        const abs = path.isAbsolute(file) ? file : path.join(workspacePath, file);
-        return env.pathExists(abs);
-    }
-    return false;
-}
-//# sourceMappingURL=predicates.js.map

package/dist/actions/predicates.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicates.js","sourceRoot":"","sources":["../../src/actions/predicates.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,wEAAwE;AACxE,6DAA6D;AAE7D,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,SAAsC,EACtC,GAAkB,EAClB,aAAqB,EACrB,GAAiB;IAEjB,IAAI,SAAS,KAAK,IAAI,IAAI,SAAS,KAAK,SAAS;QAAE,OAAO,IAAI,CAAC;IAC/D,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClC,wEAAwE;QACxE,4EAA4E;QAC5E,yEAAyE;QACzE,yEAAyE;QACzE,4CAA4C;QAC5C,MAAM,QAAQ,GAAG,cAAc,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QACvD,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;IAC7B,CAAC;IACD,IAAI,eAAe,IAAI,SAAS,EAAE,CAAC;QACjC,MAAM,GAAG,GAAG,cAAc,CAAC,SAAS,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QAChE,IAAI,GAAG,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACnC,OAAO,GAAG,CAAC,YAAY,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;IAC9C,CAAC;IACD,IAAI,cAAc,IAAI,SAAS,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,cAAc,CAAC,SAAS,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;QAChE,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QACpC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QAC1E,OAAO,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/actions/templating.js

@@ -1,66 +0,0 @@
-// $-substitution against a fixed ActionContext namespace (issue 36).
-//
-// The issue body explicitly says "Mustache or `$`-substitution with a fixed
-// namespace is enough; Bazel's Starlark is overkill." We pick `$identifier`
-// over `${{ identifier }}` because the Done after_run already uses
-// `$SYMPHONY_*` env-var shapes; sharing the prefix style keeps cognitive
-// load low for operators converting hooks to actions.
-//
-// Behavior:
-//   • `$name` expands to the named ActionContext field.
-//   • An unknown `$name` throws — silent expansion to "" was the most common
-//     hook-shell bug (typo'd `$SYMPHONY_PR_TITTLE` is the canonical example).
-//   • Literal `$` followed by a non-word char is left alone.
-//   • `\$name` escapes the substitution (literal `$name` in output).
-export class TemplateError extends Error {
-    name;
-    constructor(name, message) {
-        super(message);
-        this.name = name;
-        this.name = 'TemplateError';
-    }
-}
-const VAR_RE = /(\\?)\$([A-Za-z_][A-Za-z0-9_]*)/g;
-/**
- * Substitute `$name` references in `template` against the ActionContext.
- * Throws TemplateError when a referenced variable is not in the fixed
- * namespace — silent "" expansion masks operator typos.
- */
-export function renderTemplate(template, ctx) {
-    if (typeof template !== 'string') {
-        return template;
-    }
-    return template.replace(VAR_RE, (full, escape, name) => {
-        if (escape === '\\')
-            return `$${name}`;
-        if (!(name in ctx)) {
-            throw new TemplateError(name, `unknown template variable "$${name}" (available: ${Object.keys(ctx).join(', ')})`);
-        }
-        const v = ctx[name];
-        if (v === null || v === undefined)
-            return '';
-        return String(v);
-    });
-}
-/**
- * Render every string field of an object. Used to render an action's
- * declarative fields in one pass before execution. Recurses into arrays and
- * plain objects; primitives other than strings (numbers, booleans) pass
- * through unchanged.
- */
-export function renderTree(value, ctx) {
-    if (typeof value === 'string')
-        return renderTemplate(value, ctx);
-    if (Array.isArray(value)) {
-        return value.map((v) => renderTree(v, ctx));
-    }
-    if (value && typeof value === 'object') {
-        const out = {};
-        for (const [k, v] of Object.entries(value)) {
-            out[k] = renderTree(v, ctx);
-        }
-        return out;
-    }
-    return value;
-}
-//# sourceMappingURL=templating.js.map

package/dist/actions/templating.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"templating.js","sourceRoot":"","sources":["../../src/actions/templating.ts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,mEAAmE;AACnE,yEAAyE;AACzE,sDAAsD;AACtD,EAAE;AACF,YAAY;AACZ,wDAAwD;AACxD,6EAA6E;AAC7E,8EAA8E;AAC9E,6DAA6D;AAC7D,qEAAqE;AAIrE,MAAM,OAAO,aAAc,SAAQ,KAAK;IACnB;IAAnB,YAAmB,IAAY,EAAE,OAAe;QAC9C,KAAK,CAAC,OAAO,CAAC,CAAC;QADE,SAAI,GAAJ,IAAI,CAAQ;QAE7B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AAED,MAAM,MAAM,GAAG,kCAAkC,CAAC;AAElD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,QAAgB,EAAE,GAAkB;IACjE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,OAAO,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAc,EAAE,IAAY,EAAE,EAAE;QACrE,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,IAAI,IAAI,EAAE,CAAC;QACvC,IAAI,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;YACnB,MAAM,IAAI,aAAa,CACrB,IAAI,EACJ,+BAA+B,IAAI,iBAAiB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACnF,CAAC;QACJ,CAAC;QACD,MAAM,CAAC,GAAI,GAA0C,CAAC,IAAI,CAAC,CAAC;QAC5D,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS;YAAE,OAAO,EAAE,CAAC;QAC7C,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAI,KAAQ,EAAE,GAAkB;IACxD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,cAAc,CAAC,KAAK,EAAE,GAAG,CAAiB,CAAC;IACjF,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,GAAG,CAAC,CAAiB,CAAC;IAC9D,CAAC;IACD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QACvC,MAAM,GAAG,GAA4B,EAAE,CAAC;QACxC,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC,EAAE,CAAC;YACtE,GAAG,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,GAAmB,CAAC;IAC7B,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/actions/types.js

@@ -1,15 +0,0 @@
-// Workflow action records (issue 36 — reconciler v2 / typed action DAG).
-//
-// Per-state `actions:` blocks declare a closed set of typed records that the
-// orchestrator runs in place of an `after_run` shell hook. Each kind has a
-// fixed schema; the only escape hatch for arbitrary commands is `run_in_vm`,
-// which is content-hash cached so identical (workspace, cmd, env) tuples
-// don't re-execute.
-//
-// Action records are pure data; the executor (src/actions/executor.ts) is the
-// one place that knows how to apply each kind. This mirrors the reconciler's
-// `KillSessionAction`/`RemoveWorkspaceAction`/… pattern (records, not closures)
-// so the snapshot machinery and the dashboard can render per-action state
-// uniformly across both surfaces.
-export {};
-//# sourceMappingURL=types.js.map

package/dist/actions/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/actions/types.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,6EAA6E;AAC7E,yEAAyE;AACzE,oBAAoB;AACpB,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,gFAAgF;AAChF,0EAA0E;AAC1E,kCAAkC"}

package/dist/agent/acp.js

@@ -1,473 +0,0 @@
-// ACP (Agent Client Protocol) client wrapper.
-//
-// Symphony talks the Zed Agent Client Protocol (https://agentclientprotocol.com) so that a
-// single integration covers Claude (`claude-agent-acp`), Codex (`codex-acp`), and OpenCode
-// (`opencode acp`). The protocol is JSON-RPC over stdio.
-//
-// This wrapper:
-//   * spawns the adapter command inside a Gondolin VM (the child process stdio is the
-//     transport; nothing local is mutated outside the VM)
-//   * bridges Node child process stdio to the SDK's WHATWG streams via Readable.toWeb / etc.
-//   * implements the small Client surface ACP requires — session update streaming,
-//     permission requests, and (optionally) fs/terminal — under a documented high-trust
-//     posture (auto-approve, no client-side fs writes; the agent uses its own tools in-VM)
-//   * exposes high-level methods `initSession()` and `runPrompt()` that the agent runner
-//     uses to drive one turn of work.
-import { Readable, Transform, Writable } from 'node:stream';
-import { StringDecoder } from 'node:string_decoder';
-import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
-import { log } from '../logging.js';
-import { summarizeToolCall, summarizeToolCallUpdate } from './tool-call-summary.js';
-// Connection/transport faults surfaced by the in-VM agent's model API client
-// (ECONNRESET, socket hang up, "Unable to connect to API", …) arrive as a thrown
-// JSON-RPC error on session/prompt — they are NOT an agent decision. Issue 135:
-// bucketing these as `refusal` made a transient upstream stream reset look like
-// the agent giving up, so a long turn's transport blip got scored an "agent turn
-// refusal", the whole run was discarded, and the issue re-dispatched in a loop.
-// Label them distinctly (`transport_error`) so the run log / summary stay honest
-// and downstream policy can treat them as transient rather than as a refusal.
-const TRANSPORT_ERROR_RE = /econnreset|etimedout|econnrefused|epipe|enetunreach|ehostunreach|eai_again|socket hang up|unable to connect to api|fetch failed|network error|other side closed|terminated/i;
-/** True when a thrown prompt error is a connection/transport fault, not an agent decision. */
-export function isTransportError(message) {
-    return TRANSPORT_ERROR_RE.test(message);
-}
-export class AcpProtocolError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'AcpProtocolError';
-    }
-}
-function nowIso() {
-    return new Date().toISOString();
-}
-function summarize(raw, max = 240) {
-    let s;
-    try {
-        s = typeof raw === 'string' ? raw : JSON.stringify(raw);
-    }
-    catch {
-        s = String(raw);
-    }
-    if (s.length > max)
-        s = s.slice(0, max) + '…';
-    return s;
-}
-function extractTextContent(content) {
-    if (!content || typeof content !== 'object')
-        return '';
-    const c = content;
-    if (c.type === 'text' && typeof c.text === 'string')
-        return c.text;
-    return '';
-}
-function truncate(s, max) {
-    return s.length > max ? s.slice(0, max) + '…' : s;
-}
-// Transform that hands each newline-delimited frame to `onLine` while passing the raw bytes
-// through to downstream consumers unchanged. Used to tap the ACP JSON-RPC transport in both
-// directions for the per-issue JSONL run log. Buffering lives in `_transform`; a final flush
-// surfaces any unterminated tail so a clean shutdown does not drop the last frame.
-//
-// We decode with a `StringDecoder` rather than `chunk.toString('utf8')` because TCP/stdout
-// chunk boundaries can fall inside a multibyte UTF-8 sequence: an unaccompanied byte split
-// would otherwise be silently converted to a U+FFFD replacement character, corrupting the
-// JSON we record. The decoder buffers the trailing incomplete sequence and returns it
-// prepended to the next chunk's decode.
-class LineTap extends Transform {
-    onLine;
-    buf = '';
-    decoder = new StringDecoder('utf8');
-    constructor(onLine) {
-        super();
-        this.onLine = onLine;
-    }
-    _transform(chunk, _enc, cb) {
-        this.buf +=
-            typeof chunk === 'string' ? chunk : this.decoder.write(chunk);
-        let idx;
-        while ((idx = this.buf.indexOf('\n')) !== -1) {
-            const line = this.buf.slice(0, idx);
-            this.buf = this.buf.slice(idx + 1);
-            if (line.length > 0) {
-                try {
-                    this.onLine(line);
-                }
-                catch {
-                    // Tap failures must not interrupt the stream.
-                }
-            }
-        }
-        cb(null, chunk);
-    }
-    _flush(cb) {
-        // Drain any incomplete multibyte sequence the decoder is still holding, then surface
-        // an unterminated tail so a clean shutdown does not drop the last frame.
-        const tail = this.decoder.end();
-        if (tail.length > 0)
-            this.buf += tail;
-        if (this.buf.length > 0) {
-            try {
-                this.onLine(this.buf);
-            }
-            catch {
-                /* see _transform */
-            }
-            this.buf = '';
-        }
-        cb();
-    }
-}
-// Record one ACP frame to the run log. Lines that parse as JSON are stored as parsed values
-// so the evaluator agent doesn't double-decode; anything else lands as `kind: "unparseable"`
-// with the raw bytes preserved for forensic value.
-//
-// Before recording, capability tokens in the frame are redacted in place. The most common
-// one is the symphony MCP bearer that we inject into `session/new` as
-// `mcpServers[].headers[].value = "Bearer <token>"`; that token is the agent's per-issue
-// capability to call `transition` and `request_human_steering`, and the JSONL log is a
-// long-lived append-only file an evaluator may share. Replace any string starting with
-// `Bearer ` with `Bearer <redacted>` anywhere in the tree.
-function recordAcpFrame(runLog, direction, line) {
-    if (!runLog)
-        return;
-    let frame;
-    try {
-        frame = JSON.parse(line);
-    }
-    catch {
-        runLog.record({ channel: 'acp', direction, kind: 'unparseable', raw: line });
-        return;
-    }
-    redactBearerTokens(frame);
-    runLog.record({ channel: 'acp', direction, frame });
-}
-// Walk `value` and replace any string of the form `Bearer <token>` with `Bearer <redacted>`.
-// Mutates in place; callers must pass the parsed JSON (which is single-use per call). We
-// walk arrays and plain objects only; primitives other than strings are skipped, and we
-// guard against cycles even though ACP frames shouldn't contain them.
-function redactBearerTokens(value, seen = new WeakSet()) {
-    if (!value || typeof value !== 'object')
-        return;
-    if (seen.has(value))
-        return;
-    seen.add(value);
-    if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-            const redacted = redactedBearer(value[i]);
-            if (redacted !== undefined)
-                value[i] = redacted;
-            else
-                redactBearerTokens(value[i], seen);
-        }
-        return;
-    }
-    const obj = value;
-    for (const k of Object.keys(obj)) {
-        const redacted = redactedBearer(obj[k]);
-        if (redacted !== undefined)
-            obj[k] = redacted;
-        else
-            redactBearerTokens(obj[k], seen);
-    }
-}
-// Returns the redacted replacement when `v` is a Bearer-token string, else
-// undefined. Non-string and non-Bearer values fall through so the caller can
-// decide whether to recurse.
-function redactedBearer(v) {
-    if (typeof v === 'string' && v.startsWith('Bearer '))
-        return 'Bearer <redacted>';
-    return undefined;
-}
-// One open ACP session bound to a single child process. The adapter is expected to be
-// already running; `initSession()` performs `initialize` + `session/new`, and `runPrompt()`
-// drives one prompt-to-stop_reason cycle.
-export class AcpClient {
-    opts;
-    conn;
-    sessionId = null;
-    closed = false;
-    cancelled = false;
-    // Tracked here so the runner snapshot picks up the most recent assistant text per turn.
-    lastAssistantText = '';
-    // Held so `handleTransportClose` can forcibly end the SDK's reader/writer streams.
-    // Without this, destroying the underlying socket emits `'close'` on `opts.stdout` but
-    // the LineTap Transform in between may not propagate end-of-stream synchronously to
-    // `Readable.toWeb`'s output. The SDK's `receive()` reader loop then stays parked in
-    // `reader.read()`, so the in-flight `session/prompt` promise never rejects and the
-    // runner hangs in `runPrompt()` despite the socket being gone.
-    inboundTap;
-    outboundTap;
-    constructor(opts) {
-        this.opts = opts;
-        // Bridge child stdio to the WHATWG streams the SDK speaks. `ndJsonStream` expects raw
-        // bytes; we use Readable.toWeb / Writable.toWeb for the conversion. Both directions
-        // pass through a LineTap so the per-issue JSONL run log captures every JSON-RPC frame
-        // verbatim (parsed JSON when possible, raw bytes when not).
-        this.inboundTap = new LineTap((line) => recordAcpFrame(opts.runLog, 'vm_to_host', line));
-        this.outboundTap = new LineTap((line) => recordAcpFrame(opts.runLog, 'host_to_vm', line));
-        opts.stdout.pipe(this.inboundTap);
-        this.outboundTap.pipe(opts.stdin);
-        const input = Readable.toWeb(this.inboundTap);
-        const output = Writable.toWeb(this.outboundTap);
-        const stream = ndJsonStream(output, input);
-        this.conn = new ClientSideConnection((_agent) => this.makeClient(), stream);
-        // Stderr handling lives in the AgentRunner now — it attaches a tap immediately after
-        // launching the sandbox process so pre-bridge startup failures (vm-agent missing,
-        // bad env, adapter crash before connect) are captured in the JSONL run log and the
-        // per-issue event ring. AcpClient no longer consumes opts.stderr; the field is kept
-        // on the options type for backward compatibility and so callers retain a single
-        // place to think about where the stderr stream goes.
-        opts.stdout.on('close', () => this.handleTransportClose('stdout_closed'));
-        opts.stdin.on('error', () => {
-            /* surface through transport close */
-        });
-    }
-    // The Client interface implementation that the adapter calls back into. Every method is
-    // implemented because we run the agent inside a Gondolin VM; ACP requires the client to handle
-    // requests it advertises, and the SDK's Client interface lists them all.
-    makeClient() {
-        const self = this;
-        return {
-            async sessionUpdate(params) {
-                return self.onSessionUpdate(params);
-            },
-            async requestPermission(params) {
-                return self.onPermissionRequest(params);
-            },
-            async readTextFile(_params) {
-                // §6.1 "high-trust" posture: the agent has direct workspace access inside the VM,
-                // so client-mediated reads are unsupported. Returning an error keeps the session
-                // alive (per §6.1 "unsupported dynamic tool calls return failure without stall").
-                throw new AcpProtocolError('client_capability_not_implemented', 'client fs read not supported');
-            },
-            async writeTextFile(_params) {
-                throw new AcpProtocolError('client_capability_not_implemented', 'client fs write not supported');
-            },
-            async createTerminal(_params) {
-                throw new AcpProtocolError('client_capability_not_implemented', 'client terminal not supported');
-            },
-            async terminalOutput(_params) {
-                throw new AcpProtocolError('client_capability_not_implemented', 'client terminal not supported');
-            },
-            async waitForTerminalExit(_params) {
-                throw new AcpProtocolError('client_capability_not_implemented', 'client terminal not supported');
-            },
-            async killTerminal(_params) {
-                throw new AcpProtocolError('client_capability_not_implemented', 'client terminal not supported');
-            },
-            async releaseTerminal(_params) {
-                throw new AcpProtocolError('client_capability_not_implemented', 'client terminal not supported');
-            },
-        };
-    }
-    emit(event, message) {
-        this.opts.onEvent({ at: nowIso(), event, message });
-    }
-    onSessionUpdate(params) {
-        const update = params.update;
-        switch (update.sessionUpdate) {
-            case 'agent_message_chunk':
-                return this.onAgentMessageChunk(update);
-            case 'agent_thought_chunk':
-                return this.onAgentThoughtChunk(update);
-            case 'tool_call':
-                return this.emit('tool_call', summarizeToolCall(update));
-            case 'tool_call_update':
-                return this.emit('tool_call_update', summarizeToolCallUpdate(update));
-            case 'plan':
-                return this.emit('plan', summarize(update.entries ?? update));
-            case 'usage_update':
-                return this.onUsageUpdate(update);
-            default:
-                return this.emit('session_update', `${update.sessionUpdate}: ${summarize(update)}`);
-        }
-    }
-    onAgentMessageChunk(update) {
-        const text = extractTextContent(update.content);
-        if (!text)
-            return;
-        this.lastAssistantText += text;
-        this.emit('agent_message_chunk', truncate(text, 80));
-    }
-    onAgentThoughtChunk(update) {
-        const text = extractTextContent(update.content);
-        if (text)
-            this.emit('agent_thought_chunk', truncate(text, 80));
-    }
-    // ACP usage is "context-window used / size", not cumulative I/O tokens. We map it
-    // into total_tokens so the existing orchestrator accounting stays meaningful; the
-    // I/O split is recorded as zero because ACP does not expose it.
-    onUsageUpdate(update) {
-        const used = Number(update.used ?? 0);
-        const size = Number(update.size ?? 0);
-        this.opts.onTokenUsage({ input_tokens: 0, output_tokens: 0, total_tokens: used });
-        this.emit('usage_update', `used=${used}/${size}`);
-    }
-    onPermissionRequest(params) {
-        // §6.1 high-trust posture: auto-approve every prompt with "allow_always" so the
-        // agent doesn't ask twice in the same session. Falls back to the first listed option
-        // if no "allow_*" kind is present, which keeps the session alive in degraded mode.
-        const preferred = params.options.find((o) => o.kind === 'allow_always') ??
-            params.options.find((o) => o.kind === 'allow_once') ??
-            params.options[0];
-        const optionId = preferred?.optionId ?? '';
-        const tool = summarizeToolCallUpdate(params.toolCall);
-        this.emit('approval_auto_approved', `${optionId || 'unknown'}: ${tool}`);
-        return { outcome: { outcome: 'selected', optionId } };
-    }
-    handleTransportClose(reason) {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.emit('subprocess_exit', reason);
-        // Force-end the LineTap streams so the SDK's `receive()` reader loop observes
-        // `done: true` from `reader.read()`. That makes the SDK call its internal `close()`,
-        // which rejects every entry in `pendingResponses` (including the in-flight
-        // `session/prompt`). Without this, the runner hangs in `runPrompt()` for the full
-        // `prompt_timeout_ms` (30 min) even though the socket is gone, because `socket.destroy()`
-        // emits `'close'` on the socket but Node's pipe machinery does not always propagate an
-        // end-of-stream through the Transform synchronously. `Transform.end()` is idempotent
-        // and safe to call here even if the natural pipe-EOF would have eventually arrived.
-        try {
-            this.inboundTap.end();
-        }
-        catch {
-            /* idempotent — already ended */
-        }
-        try {
-            this.outboundTap.end();
-        }
-        catch {
-            /* idempotent — already ended */
-        }
-    }
-    /**
-     * Explicit force-close for cancel paths. Idempotent. Triggers `handleTransportClose`
-     * (and thus the SDK's internal close + pendingResponses rejection) without waiting for
-     * the underlying socket to surface its own `'close'` event. Safe to call from cancel
-     * timers that fire repeatedly.
-     */
-    forceClose(reason) {
-        this.handleTransportClose(reason);
-    }
-    // Negotiate protocol + open a session. Throws on either failure.
-    async initSession() {
-        const init = await withTimeout(this.conn.initialize({
-            protocolVersion: PROTOCOL_VERSION,
-            clientInfo: { name: 'smol-symphony', version: '0.1.0' },
-            clientCapabilities: {
-                // Advertise the minimum: the agent can read/write the workspace itself inside
-                // the VM, so we do not offer fs/terminal capabilities.
-                fs: { readTextFile: false, writeTextFile: false },
-                terminal: false,
-            },
-        }), this.opts.readTimeoutMs, 'initialize');
-        this.emit('session_init', `protocolVersion=${init.protocolVersion}`);
-        // MCP is required for symphony operations: if the agent doesn't advertise support
-        // for a requested transport, we refuse to start the session rather than silently
-        // dropping the entry and running a degraded agent that has no transition /
-        // request_human_steering tools. ACP's mcpCapabilities is optional and advertises
-        // `http`/`sse`/`acp` as booleans; missing/undefined means "not supported." Stdio is
-        // implicit (the spec treats it as the baseline) and has no `type` discriminator.
-        const requested = this.opts.mcpServers ?? [];
-        const caps = (init.agentCapabilities ?? {});
-        const mcpCaps = caps.mcpCapabilities ?? {};
-        const supportsKind = (kind) => {
-            if (kind === 'stdio')
-                return true;
-            if (kind === 'http')
-                return mcpCaps.http === true;
-            if (kind === 'sse')
-                return mcpCaps.sse === true;
-            if (kind === 'acp')
-                return mcpCaps.acp === true;
-            return false;
-        };
-        const unsupported = requested.filter((s) => {
-            const kind = (s.type ?? 'stdio');
-            return !supportsKind(kind);
-        });
-        if (unsupported.length > 0) {
-            const kinds = unsupported
-                .map((s) => s.type ?? 'stdio')
-                .join(', ');
-            this.emit('mcp_capability_mismatch', `unsupported=${kinds} adapter_caps=${JSON.stringify(mcpCaps)}`);
-            throw new AcpProtocolError('mcp_capability_mismatch', `agent does not support required MCP transport(s): ${kinds}. Adapter caps: ${JSON.stringify(mcpCaps)}`);
-        }
-        const session = await withTimeout(this.conn.newSession({ cwd: this.opts.cwd, mcpServers: requested }), this.opts.readTimeoutMs, 'session/new');
-        this.sessionId = session.sessionId;
-        this.emit('session_started', `sessionId=${session.sessionId} cwd=${this.opts.cwd} mcp_servers=${requested.length}`);
-        return { sessionId: session.sessionId };
-    }
-    async runPrompt(promptText) {
-        if (this.closed)
-            return { reason: 'subprocess_exit', message: 'adapter already closed' };
-        if (!this.sessionId)
-            return { reason: 'startup_failed', message: 'no active session' };
-        this.lastAssistantText = '';
-        const request = {
-            sessionId: this.sessionId,
-            prompt: [{ type: 'text', text: promptText }],
-        };
-        let resp;
-        try {
-            resp = await withTimeout(this.conn.prompt(request), this.opts.promptTimeoutMs, 'session/prompt');
-        }
-        catch (err) {
-            if (err instanceof TimeoutError) {
-                // Best-effort cancel so the adapter doesn't keep working in the background.
-                this.cancel().catch(() => undefined);
-                return { reason: 'prompt_timeout', message: err.message };
-            }
-            if (this.closed)
-                return { reason: 'subprocess_exit', message: err.message };
-            const message = err.message;
-            if (isTransportError(message))
-                return { reason: 'transport_error', message };
-            return { reason: 'refusal', message };
-        }
-        return mapStopReason(resp.stopReason, this.lastAssistantText);
-    }
-    async cancel() {
-        if (!this.sessionId || this.closed || this.cancelled)
-            return;
-        this.cancelled = true;
-        const note = { sessionId: this.sessionId };
-        try {
-            await this.conn.cancel(note);
-        }
-        catch (err) {
-            log.debug('acp cancel failed', { error: err.message });
-        }
-    }
-}
-function mapStopReason(stopReason, lastText) {
-    switch (stopReason) {
-        case 'end_turn':
-            return { reason: 'end_turn', message: summarize(lastText) };
-        case 'max_tokens':
-        case 'max_turn_requests':
-        case 'refusal':
-        case 'cancelled':
-            return { reason: stopReason, message: summarize(lastText) };
-        default:
-            return { reason: 'refusal', message: `unknown stop_reason ${stopReason}` };
-    }
-}
-class TimeoutError extends Error {
-}
-function withTimeout(p, ms, label) {
-    return new Promise((resolve, reject) => {
-        const t = setTimeout(() => reject(new TimeoutError(`${label} timed out after ${ms}ms`)), ms);
-        p.then((v) => {
-            clearTimeout(t);
-            resolve(v);
-        }, (e) => {
-            clearTimeout(t);
-            reject(e);
-        });
-    });
-}
-//# sourceMappingURL=acp.js.map