smol-symphony 0.2.0 → 0.3.1

package/dist/mcp.js

@@ -1,706 +0,0 @@
-// Per-issue MCP server. Each active dispatch registers an entry here; the agent inside
-// the Gondolin VM connects to /api/v1/issues/<id>/mcp with the per-dispatch bearer token and
-// sees these tools:
-//
-//   transition(to_state, notes?)    ─ atomic file move into another declared state,
-//                                     optionally appending notes to the issue body
-//                                     first. Sets the `transitioned` flag so the runner
-//                                     exits cleanly on next post-turn check.
-//   request_human_steering(question, context?)
-//                                   ─ stashes the question on the RunningEntry, returns
-//                                     an ack to the agent. The runner then pauses the
-//                                     autonomous loop and awaits a human reply submitted
-//                                     via POST /api/v1/issues/<id>/steering-reply.
-//   propose_issue(title, ...)       ─ drops a new issue file into the first declared
-//                                     holding state directory for operator triage.
-//
-// The URL is the capability: the agent only ever knows its own /<id>/mcp endpoint. The
-// bearer token is belt-and-braces in case a non-agent caller can reach 8787.
-//
-// MCP wire format here is JSON-RPC 2.0 over HTTP (the "Streamable HTTP" transport's
-// non-SSE subset). We implement only the subset our tools need: initialize, tools/list,
-// tools/call, plus a polite notifications/initialized acknowledgement.
-import { log } from './logging.js';
-import { writeIssueFile, pickHoldingState, NoHoldingStateError } from './issues.js';
-import { realClock, isoFromClock } from './util/clock.js';
-import { realCrypto } from './util/crypto.js';
-const PROTOCOL_VERSION = '2025-06-18';
-const TOOL_LIST = [
-    {
-        name: 'request_human_steering',
-        description: 'Pause work and ask the human operator a question. Your current turn will end immediately after this returns; the human response will arrive as the prompt for your next turn. Use only when you cannot proceed without a decision a human must make.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                question: {
-                    type: 'string',
-                    description: 'The question to ask the human. Be specific about what decision they need to make.',
-                },
-                context: {
-                    type: 'string',
-                    description: 'Optional: relevant context the human needs to answer (file paths, options considered, etc.).',
-                },
-            },
-            required: ['question'],
-        },
-    },
-    {
-        name: 'transition',
-        description: 'Move this issue into another declared state, optionally appending notes to its body for the next agent. Use this for handoffs — implementer → reviewer, reviewer → implementer (rework), or implementer → terminal Done — rather than only at the very end of the work. Notes are appended to the issue file BEFORE the state move, so the next dispatch sees them in `issue.description` along with everything the previous agents wrote. `to_state` must be one of the states declared in WORKFLOW.md; if the current state declares `allowed_transitions`, `to_state` must also be in that list. On a terminal target, the workspace is removed after your turn ends and no further turns will be dispatched. On a non-terminal target, the same workspace and `agent/<id>` git branch survive into the next state.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                to_state: {
-                    type: 'string',
-                    description: 'Declared state to transition into (case-insensitive match against `states:` in WORKFLOW.md). Examples: "Review", "Done", "Todo".',
-                },
-                notes: {
-                    type: 'string',
-                    description: 'Optional markdown notes to append to the issue body before the move. These become part of the issue description the next agent (in `to_state`) reads. Use this for review findings, rework instructions, or PR-body content on a terminal transition.',
-                },
-            },
-            required: ['to_state'],
-        },
-    },
-    {
-        name: 'propose_issue',
-        description: 'Propose a new issue for the human to triage. The orchestrator drops the proposal into a non-active "Triage" state directory and does NOT dispatch it — the operator approves (moves to the active queue) or discards it from the dashboard. Use this when you notice work that is out of scope for your current task: an unrelated bug, a follow-up the operator should size, a refactor a future agent could pick up. The parent issue you are working on is automatically recorded; do not paste it into the body.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                title: {
-                    type: 'string',
-                    description: 'Short single-line title in imperative voice (≤72 chars recommended). Example: "Fix race condition in workspace cleanup".',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional multi-paragraph body for the issue. Explain what you observed, where (file paths), and why it is worth handling separately from your current task.',
-                },
-                labels: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Optional list of label strings.',
-                },
-                priority: {
-                    type: 'number',
-                    description: 'Optional integer priority hint (tracker-defined meaning).',
-                },
-            },
-            required: ['title'],
-        },
-    },
-];
-export class McpRegistry {
-    tracker;
-    byIdentifier = new Map();
-    effectivePort = null;
-    // Live state-config map, kept in sync with the orchestrator's view via
-    // `updateStates`. Used by `transition` to validate `to_state` and to resolve
-    // the role of the target (terminal => set cleanup_workspace_on_exit). An
-    // empty map means every transition call lands in the "unknown_state" branch,
-    // which is the correct behaviour: without a declared states map, the agent
-    // has no valid target to name.
-    states = {};
-    // Issue 38 (generalised in issue 144): when the PR engine is enabled,
-    // transitions into the merge state do NOT flip `cleanup_workspace_on_exit`
-    // even though the target state's role is `terminal`. The pr resource owns
-    // the workspace lifecycle for those issues — it rebases inside the workspace
-    // and cleans it up after the PR merges/closes. Without this gate the
-    // terminal-cleanup path would reap the workspace before the engine could
-    // ever use it. The caller (bin/symphony.ts) derives `mergeState` from
-    // `derivePrRouting(cfg.states).mergeState` and `enabled` from `cfg.pr.enabled`.
-    prMerge = { enabled: false, mergeState: null };
-    // Injected wall clock. Tests pin time; production wires `Date.now` (or
-    // accepts the realClock default). Used to stamp `proposed_at` on
-    // propose_issue submissions so the core is deterministic under test.
-    now;
-    // Injected crypto port. Production wires `realCrypto` (randomBytes +
-    // timingSafeEqual); tests can pin deterministic tokens to assert wire
-    // format without sampling randomness.
-    crypto;
-    constructor(tracker, opts = {}) {
-        this.tracker = tracker;
-        if (opts.states)
-            this.states = opts.states;
-        if (opts.prMerge)
-            this.prMerge = opts.prMerge;
-        this.now = opts.now ?? realClock;
-        this.crypto = opts.crypto ?? realCrypto;
-    }
-    /**
-     * Push the latest state-config map (and optional PR merge-cleanup gate) in
-     * after a workflow reload. Tests that don't care about the PR engine can call
-     * with a single argument; production wires both so reloads that flip
-     * `pr.enabled` or move the merge state take effect on subsequent transitions.
-     */
-    updateStates(states, prMerge) {
-        this.states = states;
-        if (prMerge !== undefined) {
-            this.prMerge = prMerge ?? { enabled: false, mergeState: null };
-        }
-    }
-    /** Called once after the HTTP server binds, so URL construction uses the real port. */
-    setEffectivePort(port) {
-        this.effectivePort = port;
-    }
-    /**
-     * The bound HTTP port, or null until the server binds. Exposed so the Gondolin
-     * dispatch can wire the guest→host MCP `tcp.hosts` tunnel to the real
-     * `mcp.host:effectivePort` while the guest dials a fixed synthetic host.
-     */
-    getEffectivePort() {
-        return this.effectivePort;
-    }
-    /**
-     * Build the URL the ACP agent will be told to POST to. Returns null when no HTTP server
-     * is available and no explicit URL is configured; the runner uses that to skip MCP
-     * injection (with a warning) instead of advertising an unreachable endpoint.
-     *
-     * `baseOverride` (e.g. the Gondolin guest synthetic base `http://symphony-mcp:7001`)
-     * wins over both `explicit_host_url` and the real host:port: under Gondolin the
-     * guest cannot reach the host loopback directly, so the runner passes the synthetic
-     * base that a per-dispatch `tcp.hosts` entry tunnels to the real MCP server.
-     */
-    buildUrl(identifier, mcp, baseOverride) {
-        const base = baseOverride
-            ? baseOverride.replace(/\/+$/, '')
-            : mcp.explicit_host_url
-                ? mcp.explicit_host_url.replace(/\/+$/, '')
-                : this.effectivePort === null
-                    ? null
-                    : `http://${mcp.host}:${this.effectivePort}`;
-        if (!base)
-            return null;
-        return `${base}/api/v1/issues/${encodeURIComponent(identifier)}/mcp`;
-    }
-    /**
-     * Register an active dispatch. Returns the bearer token the runner injects into the
-     * agent's MCP server config via ACP's session/new mcpServers field.
-     */
-    activate(entry) {
-        const token = this.crypto.newToken();
-        entry.mcp_token = token;
-        entry.transitioned = false;
-        entry.steering_requested = false;
-        entry.steering_question = null;
-        entry.steering_context = null;
-        // Carry the dispatch-time tracker-root snapshot through verbatim. Reading
-        // this.tracker.currentRoot() here would be wrong: activate runs AFTER
-        // workspace setup and Gondolin VM bring-up — a window during
-        // which a WORKFLOW.md reload can mutate tracker.root. The dispatch-time
-        // value is the only one that accurately reflects the world the run was
-        // started in.
-        const active = {
-            issueId: entry.issue_id,
-            identifier: entry.identifier,
-            entry,
-            token,
-            pendingReply: null,
-            trackerRootSnapshot: entry.tracker_root_at_dispatch,
-        };
-        this.byIdentifier.set(entry.identifier, active);
-        log.debug('mcp activated', {
-            issue_identifier: entry.identifier,
-            tracker_root: active.trackerRootSnapshot,
-        });
-        return token;
-    }
-    deactivate(identifier) {
-        const active = this.byIdentifier.get(identifier);
-        if (!active)
-            return;
-        // Reject any waiter so the runner unblocks instead of hanging.
-        if (active.pendingReply) {
-            active.pendingReply.reject(new Error('mcp deactivated while awaiting human reply'));
-            active.pendingReply = null;
-        }
-        this.byIdentifier.delete(identifier);
-        log.debug('mcp deactivated', { issue_identifier: identifier });
-    }
-    /**
-     * Resolve a pending human reply. Returns false if no waiter exists (the agent hasn't
-     * requested steering, or the reply was already delivered).
-     */
-    submitSteeringReply(identifier, text) {
-        const active = this.byIdentifier.get(identifier);
-        if (!active || !active.pendingReply)
-            return false;
-        const { resolve } = active.pendingReply;
-        active.pendingReply = null;
-        resolve(text);
-        return true;
-    }
-    /**
-     * Block until a human reply arrives, the cancel signal trips, or the active entry is
-     * deactivated. Returns the reply text or null if cancelled.
-     */
-    async awaitSteeringReply(identifier, cancelSignal) {
-        const active = this.byIdentifier.get(identifier);
-        if (!active)
-            return null;
-        if (active.pendingReply) {
-            throw new Error('steering reply already being awaited for this issue');
-        }
-        let timer = null;
-        try {
-            return await new Promise((resolve, reject) => {
-                active.pendingReply = {
-                    resolve: (text) => resolve(text),
-                    reject: (err) => reject(err),
-                };
-                // Poll cancellation every 250ms (same cadence as the runner's cancel-check timer).
-                timer = setInterval(() => {
-                    if (cancelSignal.cancelled) {
-                        if (active.pendingReply) {
-                            active.pendingReply = null;
-                            resolve(null);
-                        }
-                    }
-                }, 250);
-            });
-        }
-        finally {
-            if (timer)
-                clearInterval(timer);
-        }
-    }
-    /**
-     * Handle a single JSON-RPC envelope. The HTTP layer takes care of routing (identifier
-     * lookup, token check) and passes us the parsed body. Returns null for notifications
-     * (no `id`); the HTTP layer responds with 204 in that case.
-     */
-    async handleJsonRpc(identifier, token, body) {
-        const active = this.byIdentifier.get(identifier);
-        if (!active) {
-            return makeError(getId(body), -32001, 'issue not active');
-        }
-        if (!this.crypto.constantTimeEqual(active.token, token)) {
-            return makeError(getId(body), -32002, 'invalid token');
-        }
-        if (!isRpcRequest(body)) {
-            return makeError(getId(body), -32600, 'invalid JSON-RPC request');
-        }
-        const id = body.id ?? null;
-        const isNotification = body.id === undefined;
-        try {
-            switch (body.method) {
-                case 'initialize': {
-                    if (isNotification)
-                        return null;
-                    return {
-                        jsonrpc: '2.0',
-                        id,
-                        result: {
-                            protocolVersion: PROTOCOL_VERSION,
-                            capabilities: {
-                                tools: { listChanged: false },
-                            },
-                            serverInfo: {
-                                name: 'smol-symphony',
-                                version: '0.1.0',
-                            },
-                        },
-                    };
-                }
-                case 'notifications/initialized':
-                case 'notifications/cancelled':
-                case 'notifications/progress': {
-                    return null;
-                }
-                case 'tools/list': {
-                    if (isNotification)
-                        return null;
-                    return { jsonrpc: '2.0', id, result: { tools: TOOL_LIST } };
-                }
-                case 'tools/call': {
-                    if (isNotification)
-                        return null;
-                    const params = (body.params ?? {});
-                    const name = params.name;
-                    const args = params.arguments ?? {};
-                    if (name === 'transition') {
-                        return await this.callTransition(active, id, args);
-                    }
-                    if (name === 'request_human_steering') {
-                        return this.callRequestHumanSteering(active, id, args);
-                    }
-                    if (name === 'propose_issue') {
-                        return await this.callProposeIssue(active, id, args);
-                    }
-                    return makeError(id, -32601, `unknown tool: ${name}`);
-                }
-                case 'ping': {
-                    if (isNotification)
-                        return null;
-                    return { jsonrpc: '2.0', id, result: {} };
-                }
-                default:
-                    if (isNotification)
-                        return null;
-                    return makeError(id, -32601, `unknown method: ${body.method}`);
-            }
-        }
-        catch (err) {
-            log.warn('mcp handler error', {
-                issue_identifier: identifier,
-                method: body.method,
-                error: err.message,
-            });
-            return makeError(id, -32603, err.message);
-        }
-    }
-    /**
-     * Shared file-move + flag-flip path used by `transition`. Returns the tracker's
-     * resolved {from, to, newPath} on success, throwing the underlying TrackerError
-     * on failure so the caller can wrap it in a tool-error response.
-     *
-     * Cleanup-on-exit is decided by the role of the canonical target state: terminal
-     * targets clean the workspace, active/holding targets preserve it so the same
-     * `agent/<id>` git branch survives across the handoff. Callers must have already
-     * resolved `toState` to its canonical declared name via `canonicalStateName`, so
-     * this routine assumes the lookup is in the states map.
-     */
-    async performTransition(active, toState, notes, actor) {
-        if (!this.tracker.moveIssueToState) {
-            throw new Error('this tracker does not support state transitions');
-        }
-        const fromRoot = active.trackerRootSnapshot ?? undefined;
-        const fromState = active.entry.issue.state;
-        const result = await this.tracker.moveIssueToState(active.issueId, toState, {
-            fromRoot,
-            fromState,
-            notes: notes.length > 0 ? notes : undefined,
-            actor,
-        });
-        active.entry.transitioned = true;
-        // Look up the canonical declared name (preserving operator-supplied casing)
-        // so the role lookup matches the workflow's `states:` map.
-        const stateMap = this.states;
-        const canonicalName = canonicalStateName(stateMap, result.toState);
-        const targetIsTerminal = canonicalName !== null && stateMap[canonicalName].role === 'terminal';
-        // Issue 38 / 144: suppress terminal cleanup when the PR engine owns this
-        // state's workspace. The pr resource will reap the workspace once the
-        // PR has merged (or been closed). Other terminal states (Cancelled
-        // typically) still cleanup immediately — the close path only needs to talk
-        // to GitHub, not the workspace.
-        const suppressCleanupForMerge = targetIsTerminal &&
-            canonicalName !== null &&
-            this.prMerge.enabled &&
-            this.prMerge.mergeState !== null &&
-            canonicalName.toLowerCase() === this.prMerge.mergeState.toLowerCase();
-        active.entry.cleanup_workspace_on_exit = targetIsTerminal && !suppressCleanupForMerge;
-        // Mutate the entry's view of the issue's state so downstream code (runner's
-        // cleanup, orchestrator's terminal-state workspace removal) resolves the right
-        // state's `actions:`. Without this, the terminal-state cleanup actions would
-        // resolve against the pre-transition state and a terminal-state handoff
-        // (e.g. Done's push_branch + create_pr_if_missing) would never fire.
-        active.entry.issue.state = canonicalName ?? result.toState;
-        // Stash the transition so the orchestrator shell can fold it into the run
-        // log as a `transition` lifecycle event after the attempt unwinds (issue
-        // 123). Pure here — no IO; the run-log write happens host-side.
-        active.entry.last_transition = {
-            from_state: result.fromState,
-            to_state: canonicalName ?? result.toState,
-            notes,
-            actor,
-            terminal: targetIsTerminal,
-        };
-        return result;
-    }
-    /**
-     * `symphony.transition({ to_state, notes? })`: validate the target against the
-     * declared `states:` map + the current state's `allowed_transitions` list, then
-     * delegate to `performTransition` which owns the actual file move and flag flip.
-     *
-     * Validation failures return MCP tool-result errors (`isError: true`) with a
-     * human-readable text block AND a structured JSON block describing the error
-     * shape. This is NOT a JSON-RPC `error` envelope — the SDK delivers it as a
-     * normal tool result and the agent reads the structured payload to pick a valid
-     * target on its next call. `transitioned` stays false; no file is touched.
-     */
-    async callTransition(active, id, args) {
-        const toStateRaw = typeof args.to_state === 'string' ? args.to_state.trim() : '';
-        const notes = typeof args.notes === 'string' ? args.notes : '';
-        if (!toStateRaw) {
-            return makeToolError(id, 'to_state is required and must be a non-empty string');
-        }
-        if (!this.tracker.moveIssueToState) {
-            return makeToolError(id, 'this tracker does not support state transitions');
-        }
-        const stateMap = this.states;
-        const declaredNames = Object.keys(stateMap);
-        const canonicalTarget = canonicalStateName(stateMap, toStateRaw);
-        if (canonicalTarget === null) {
-            const text = `state "${toStateRaw}" is not declared. declared: ${declaredNames.length > 0 ? declaredNames.join(', ') : '<none>'}`;
-            log.info('mcp transition rejected: unknown_state', {
-                issue_identifier: active.identifier,
-                requested_to_state: toStateRaw,
-                declared_states: declaredNames,
-            });
-            return makeStructuredToolError(id, text, {
-                error: 'unknown_state',
-                declared_states: declaredNames,
-            });
-        }
-        const fromStateRaw = active.entry.issue.state;
-        const canonicalFrom = canonicalStateName(stateMap, fromStateRaw);
-        if (canonicalFrom !== null) {
-            // Per the brief: `allowed_transitions: null | undefined` => "any declared
-            // state is reachable"; a present array => restrict to that list (empty
-            // list => no transitions out, agent must wait for human cleanup).
-            const allowed = stateMap[canonicalFrom].allowed_transitions;
-            if (allowed) {
-                const allowedLower = new Set(allowed.map((s) => s.toLowerCase()));
-                if (!allowedLower.has(canonicalTarget.toLowerCase())) {
-                    const text = `transition to "${canonicalTarget}" is not allowed from "${canonicalFrom}". allowed: ${allowed.length > 0 ? allowed.join(', ') : '<none>'}`;
-                    log.info('mcp transition rejected: transition_not_allowed', {
-                        issue_identifier: active.identifier,
-                        from_state: canonicalFrom,
-                        requested_to_state: canonicalTarget,
-                        allowed_transitions: allowed,
-                    });
-                    return makeStructuredToolError(id, text, {
-                        error: 'transition_not_allowed',
-                        from_state: canonicalFrom,
-                        requested_to_state: canonicalTarget,
-                        allowed_transitions: allowed,
-                    });
-                }
-            }
-        }
-        const actor = active.entry.resolved_actor;
-        try {
-            const result = await this.performTransition(active, canonicalTarget, notes, actor);
-            log.info('mcp transition', {
-                issue_identifier: active.identifier,
-                from: result.fromState,
-                to: result.toState,
-                notes_len: notes.length,
-                actor,
-                cleanup: active.entry.cleanup_workspace_on_exit,
-            });
-            return {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Transitioned ${active.identifier} from ${result.fromState} to ${result.toState}${notes.length > 0 ? ` with notes (${notes.length} chars) appended` : ''}. End this turn now; the next dispatch will pick up under the new state.`,
-                        },
-                    ],
-                    isError: false,
-                    structuredContent: {
-                        from_state: result.fromState,
-                        to_state: result.toState,
-                        cleanup_workspace_on_exit: active.entry.cleanup_workspace_on_exit,
-                        notes_appended: notes.length > 0,
-                    },
-                },
-            };
-        }
-        catch (err) {
-            return makeToolError(id, `failed to transition: ${err.message}`);
-        }
-    }
-    callRequestHumanSteering(active, id, args) {
-        const question = typeof args.question === 'string' ? args.question.trim() : '';
-        const context = typeof args.context === 'string' ? args.context.trim() : '';
-        if (!question) {
-            return makeToolError(id, 'question is required and must be a non-empty string');
-        }
-        if (active.entry.steering_requested) {
-            return makeToolError(id, 'a steering request is already pending for this issue; end the turn and wait for the response');
-        }
-        active.entry.steering_requested = true;
-        active.entry.steering_question = question;
-        active.entry.steering_context = context.length > 0 ? context : null;
-        log.info('mcp request_human_steering', {
-            issue_identifier: active.identifier,
-            question_chars: question.length,
-            has_context: context.length > 0,
-        });
-        return {
-            jsonrpc: '2.0',
-            id,
-            result: {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Question queued. End this turn now. The human response will arrive as the prompt for your next turn.',
-                    },
-                ],
-                isError: false,
-            },
-        };
-    }
-    /**
-     * Drop a new issue file into the tracker's Triage/ directory. The orchestrator
-     * never dispatches Triage entries because the state's role is `holding`, not
-     * `active`; the operator approves or discards from the dashboard. Parent issue (the active
-     * dispatch this MCP call came from) is stamped into the front-matter as
-     * `proposed_by` so provenance is visible in the file and the UI.
-     *
-     * Uses the dispatch-time tracker root snapshot — same rationale as `transition`:
-     * a WORKFLOW.md reload that mutates tracker.root mid-flight must not redirect
-     * an in-flight propose call to a different filesystem location.
-     */
-    async callProposeIssue(active, id, args) {
-        const titleRaw = typeof args.title === 'string' ? args.title.trim() : '';
-        const description = typeof args.description === 'string' ? args.description : '';
-        if (!titleRaw) {
-            return makeToolError(id, 'title is required and must be a non-empty string');
-        }
-        if (titleRaw.includes('\n')) {
-            return makeToolError(id, 'title must be a single line (no embedded newlines)');
-        }
-        const labels = Array.isArray(args.labels)
-            ? args.labels.filter((x) => typeof x === 'string')
-            : [];
-        const priority = typeof args.priority === 'number' && Number.isFinite(args.priority) ? args.priority : null;
-        // Resolve the tracker root: prefer the dispatch-time snapshot, fall back to the
-        // tracker's live root (e.g. for tests / trackers without a snapshot). Without a
-        // resolvable root we can't write the file, so surface a clean tool error.
-        const root = active.trackerRootSnapshot ??
-            (this.tracker.currentRoot ? this.tracker.currentRoot() : null);
-        if (!root) {
-            return makeToolError(id, 'tracker root is not available; cannot create issue files (is this a non-local tracker?)');
-        }
-        // Landing state: first declared `holding` state in declaration order. The
-        // workflow parser refuses configs without one, but if validation was
-        // bypassed we surface a structured `no_holding_state` error so the agent
-        // doesn't keep retrying against a misconfigured workflow.
-        let landingState;
-        try {
-            landingState = pickHoldingState(this.states);
-        }
-        catch (err) {
-            if (err instanceof NoHoldingStateError) {
-                return makeStructuredToolError(id, 'cannot propose issue: workflow has no holding-role state declared', {
-                    error: 'no_holding_state',
-                    declared_states: Object.keys(this.states),
-                });
-            }
-            throw err;
-        }
-        try {
-            const result = await writeIssueFile({
-                trackerRoot: root,
-                state: landingState,
-                title: titleRaw,
-                description,
-                priority,
-                labels,
-                now: realClock,
-                extra_front_matter: {
-                    proposed_by: active.identifier,
-                    proposed_at: isoFromClock(this.now),
-                },
-            });
-            log.info('mcp propose_issue', {
-                proposed_by: active.identifier,
-                identifier: result.identifier,
-                state: result.state,
-                title: titleRaw,
-                description_chars: description.length,
-            });
-            return {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Proposed issue ${result.identifier} in ${result.state}/. The operator will approve or discard from the dashboard; do not wait for it. Continue your current task.`,
-                        },
-                    ],
-                    isError: false,
-                    // Structured data alongside the human-readable text — MCP clients that
-                    // surface this make the identifier programmatically available without
-                    // re-parsing the content string.
-                    structuredContent: {
-                        identifier: result.identifier,
-                        state: result.state,
-                        path: result.path,
-                    },
-                },
-            };
-        }
-        catch (err) {
-            return makeToolError(id, `failed to propose issue: ${err.message}`);
-        }
-    }
-    /** Snapshot of currently active issues, used by HTTP for routing lookups. */
-    isActive(identifier, token) {
-        const active = this.byIdentifier.get(identifier);
-        return !!active && this.crypto.constantTimeEqual(active.token, token);
-    }
-}
-function getId(body) {
-    if (body && typeof body === 'object' && !Array.isArray(body)) {
-        const rec = body;
-        if (typeof rec.id === 'string' || typeof rec.id === 'number')
-            return rec.id;
-    }
-    return null;
-}
-function isRpcRequest(body) {
-    if (!body || typeof body !== 'object' || Array.isArray(body))
-        return false;
-    const rec = body;
-    return rec.jsonrpc === '2.0' && typeof rec.method === 'string';
-}
-function makeError(id, code, message) {
-    return { jsonrpc: '2.0', id, error: { code, message } };
-}
-function makeToolError(id, message) {
-    // MCP convention: tool errors return result.isError=true rather than JSON-RPC error.
-    return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-            content: [{ type: 'text', text: message }],
-            isError: true,
-        },
-    };
-}
-/**
- * MCP tool error with both a human-readable text block and a structured JSON
- * block. Used by `symphony.transition` so agents can read the rejection's
- * structured payload (`declared_states`, `allowed_transitions`, etc.) to pick a
- * valid target on their next call without re-parsing the prose. Pairs with
- * `makeToolError` (text-only) for everything else.
- */
-function makeStructuredToolError(id, text, json) {
-    return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-            // MCP 2025-06-18 `CallToolResult.content` is `ContentBlock[]` and does not
-            // define a `json` block type; the canonical home for machine-readable
-            // payloads is `structuredContent`. Keep only the text block in `content[]`
-            // for human display and put the structured shape on the SDK-recognised slot.
-            content: [{ type: 'text', text }],
-            isError: true,
-            structuredContent: json,
-        },
-    };
-}
-/**
- * Resolve a caller-supplied state name to its canonical declared form (the
- * casing the operator wrote in `states:`). Comparison is case-insensitive to
- * mirror the rest of symphony (eligibility, reconciliation, the local-tracker
- * directory scan all compare lowercase). Returns null when no declared name
- * matches.
- */
-function canonicalStateName(states, name) {
-    if (Object.prototype.hasOwnProperty.call(states, name))
-        return name;
-    const lower = name.toLowerCase();
-    for (const declared of Object.keys(states)) {
-        if (declared.toLowerCase() === lower)
-            return declared;
-    }
-    return null;
-}
-//# sourceMappingURL=mcp.js.map