smol-symphony 0.2.0 → 0.3.1

package/dist/core/mcp/post-move.js

@@ -0,0 +1,92 @@
+// FCIS rewrite — FUNCTIONAL CORE: MCP transition POST-move fold.
+//
+// Closes the decide→IO→decide loop for `symphony.transition`. The PRE-move
+// decider (core/mcp/dispatch — written concurrently) validates the envelope,
+// resolves the canonical target, and emits a `move_state` McpEffect. The SHELL
+// performs the tracker file-move and hands the RESOLVED result back as an
+// McpEffectResult. THIS module folds that resolved result into the post-move
+// flags the original `performTransition` derived inline (impureCoreRisk fix):
+//
+//   - the cleanup-on-exit gate (terminal role, minus PR-merge suppression),
+//   - the TransitionRecord stashed for the run-log `transition` event,
+//   - the notes header that the shell prepends when appending notes to the body.
+//
+// Pure + synchronous. The only nondeterministic input — the wall-clock ISO used
+// in the notes header — is injected as a plain `nowIso` parameter (the shell
+// passes Clock.iso()), never read here.
+//
+// Reference behavior (read-only): undefined/src/mcp.ts performTransition
+// (post-move flag derivation) + undefined/src/trackers/local.ts
+// buildNotesAppendedBody (notes header format).
+/** Case-insensitive equality with explicit null handling (matches the original). */
+function eqIgnoreCase(a, b) {
+    return b !== null && a.toLowerCase() === b.toLowerCase();
+}
+/**
+ * Build the notes-append header. Mirrors `buildNotesAppendedBody`'s header line
+ * exactly: `## <who> — <iso> — <from> → <to>`, with `who` defaulting to
+ * 'unknown' when the actor is null/empty.
+ */
+export function buildNotesHeader(actor, nowIso, fromState, toState) {
+    const who = actor && actor.length > 0 ? actor : 'unknown';
+    return `## ${who} — ${nowIso} — ${fromState} → ${toState}`;
+}
+/**
+ * Fold the resolved tracker result into the post-move flags. Pure: returns a
+ * decision object; the shell mutates the running entry and folds the record into
+ * the run log. Failed / non-move results produce an inert decision (no terminal
+ * gate, no record) so the shell can leave the entry untouched and surface the
+ * error response the pre-move decider already shaped.
+ */
+export function foldPostMove(input) {
+    const { result, targetState, prMerge, fromState, notes, actor, nowIso } = input;
+    // Only a successful `move_state` (kind: 'moved') drives the post-move flags.
+    // `move_failed` and `written` (propose_issue) are no-ops here — the dispatch
+    // layer owns their responses; nothing transitioned, so no flags flip.
+    if (result.kind !== 'moved') {
+        return {
+            moved: false,
+            toState: null,
+            terminal: false,
+            cleanupWorkspaceOnExit: false,
+            suppressCleanupForMerge: false,
+            notesHeader: null,
+            transitionRecord: null,
+        };
+    }
+    // Prefer the canonical declared name (operator-supplied casing) for the role
+    // lookup + downstream state resolution; fall back to the tracker's resolved
+    // toState when it no longer maps to a declared state (canonicalName === null).
+    const canonicalName = targetState !== null ? targetState.name : null;
+    const resolvedTo = canonicalName ?? result.toState;
+    const targetIsTerminal = targetState !== null && targetState.role === 'terminal';
+    // Issue 38/144 (mustFix): suppress terminal cleanup when the PR engine owns
+    // this state's workspace — the pr resource reaps it after the PR merges/closes.
+    // Other terminal states (Cancelled) still clean up immediately.
+    const suppressCleanupForMerge = targetIsTerminal &&
+        canonicalName !== null &&
+        prMerge.enabled &&
+        prMerge.mergeState !== null &&
+        eqIgnoreCase(canonicalName, prMerge.mergeState);
+    const cleanupWorkspaceOnExit = targetIsTerminal && !suppressCleanupForMerge;
+    const notesHeader = notes.length > 0 ? buildNotesHeader(actor, nowIso, fromState, resolvedTo) : null;
+    // Stash the transition for the shell-side run-log fold (issue 123). `from_state`
+    // is the tracker's resolved source; `to_state` is the canonical resolved target.
+    const transitionRecord = {
+        from_state: result.fromState,
+        to_state: resolvedTo,
+        notes,
+        actor,
+        terminal: targetIsTerminal,
+    };
+    return {
+        moved: true,
+        toState: resolvedTo,
+        terminal: targetIsTerminal,
+        cleanupWorkspaceOnExit,
+        suppressCleanupForMerge,
+        notesHeader,
+        transitionRecord,
+    };
+}
+//# sourceMappingURL=post-move.js.map

package/dist/core/mcp/post-move.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-move.js","sourceRoot":"","sources":["../../../src/core/mcp/post-move.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,EAAE;AACF,2EAA2E;AAC3E,6EAA6E;AAC7E,+EAA+E;AAC/E,0EAA0E;AAC1E,6EAA6E;AAC7E,8EAA8E;AAC9E,EAAE;AACF,4EAA4E;AAC5E,uEAAuE;AACvE,iFAAiF;AACjF,EAAE;AACF,gFAAgF;AAChF,6EAA6E;AAC7E,wCAAwC;AACxC,EAAE;AACF,yEAAyE;AACzE,gEAAgE;AAChE,gDAAgD;AAShD,oFAAoF;AACpF,SAAS,YAAY,CAAC,CAAS,EAAE,CAAgB;IAC/C,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;AAC3D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAoB,EACpB,MAAc,EACd,SAAiB,EACjB,OAAe;IAEf,MAAM,GAAG,GAAG,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IAC1D,OAAO,MAAM,GAAG,MAAM,MAAM,MAAM,SAAS,MAAM,OAAO,EAAE,CAAC;AAC7D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,KAAoB;IAC/C,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;IAEhF,6EAA6E;IAC7E,6EAA6E;IAC7E,sEAAsE;IACtE,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO;YACL,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE,IAAI;YACb,QAAQ,EAAE,KAAK;YACf,sBAAsB,EAAE,KAAK;YAC7B,uBAAuB,EAAE,KAAK;YAC9B,WAAW,EAAE,IAAI;YACjB,gBAAgB,EAAE,IAAI;SACvB,CAAC;IACJ,CAAC;IAED,6EAA6E;IAC7E,4EAA4E;IAC5E,+EAA+E;IAC/E,MAAM,aAAa,GAAG,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACrE,MAAM,UAAU,GAAG,aAAa,IAAI,MAAM,CAAC,OAAO,CAAC;IAEnD,MAAM,gBAAgB,GAAG,WAAW,KAAK,IAAI,IAAI,WAAW,CAAC,IAAI,KAAK,UAAU,CAAC;IAEjF,4EAA4E;IAC5E,gFAAgF;IAChF,gEAAgE;IAChE,MAAM,uBAAuB,GAC3B,gBAAgB;QAChB,aAAa,KAAK,IAAI;QACtB,OAAO,CAAC,OAAO;QACf,OAAO,CAAC,UAAU,KAAK,IAAI;QAC3B,YAAY,CAAC,aAAa,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAElD,MAAM,sBAAsB,GAAG,gBAAgB,IAAI,CAAC,uBAAuB,CAAC;IAE5E,MAAM,WAAW,GACf,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEnF,iFAAiF;IACjF,iFAAiF;IACjF,MAAM,gBAAgB,GAAqB;QACzC,UAAU,EAAE,MAAM,CAAC,SAAS;QAC5B,QAAQ,EAAE,UAAU;QACpB,KAAK;QACL,KAAK;QACL,QAAQ,EAAE,gBAAgB;KAC3B,CAAC;IAEF,OAAO;QACL,KAAK,EAAE,IAAI;QACX,OAAO,EAAE,UAAU;QACnB,QAAQ,EAAE,gBAAgB;QAC1B,sBAAsB;QACtB,uBAAuB;QACvB,WAAW;QACX,gBAAgB;KACjB,CAAC;AACJ,CAAC"}

package/dist/core/mcp/protocol.js

@@ -0,0 +1,293 @@
+// FCIS rewrite — pure MCP JSON-RPC framing.
+//
+// Functional-core port of the JSON-RPC *envelope* handling the original spread
+// through `src/mcp.ts` (`isRpcRequest`, `getId`, `makeError`, `makeToolError`,
+// `makeStructuredToolError`, the `PROTOCOL_VERSION`/`TOOL_LIST` catalog and the
+// `initialize` / `tools/list` / `ping` / notification method routing inside
+// `handleJsonRpc`).
+//
+// This module owns ONLY the framing — the parts that are a pure function of the
+// inbound envelope and need neither the live `ActiveEntry` registry nor any IO:
+//
+//   - validate the JSON-RPC request envelope          (validateEnvelope)
+//   - extract the response id from arbitrary input     (extractId)
+//   - the protocol-version + tool catalog              (PROTOCOL_VERSION / TOOL_LIST)
+//   - the static `initialize` / `tools/list` / `ping`  (routeFraming)
+//     results and the notification "no reply" decision
+//   - error / tool-error / structured-tool-error
+//     response shaping                                 (makeError / makeToolError /
+//                                                       makeStructuredToolError)
+//
+// What it deliberately does NOT do: the stateful `tools/call` dispatch
+// (transition / propose_issue / request_human_steering). Those mutate the
+// running entry and emit McpEffect[]; they belong to the registry decider
+// (core/mcp/dispatch) which calls `routeFraming` first and only falls through to
+// its own logic on a `tools/call` method.
+//
+// HARD CONSTRAINTS (gate-enforced):
+//   - 100% SYNCHRONOUS. No async/await/Promise anywhere (not even in a type).
+//   - No IO, no node: imports, no process/fetch, no wall clock, no randomness.
+//   - Imports ONLY from src/types/**.
+//
+// Behavior ported faithfully:
+//   - `isRpcRequest`: a body is a valid request iff it is a non-array object
+//     with `jsonrpc === '2.0'` and a string `method`.
+//   - `getId`: only string|number ids survive; everything else (including a
+//     literal null id, an array, a primitive body) collapses to `null`.
+//   - A notification is a request with NO `id` key at all (`id === undefined`);
+//     a present `id: null` is a request that still expects a response keyed null.
+//   - `initialize` / `tools/list` / `ping` as notifications get no reply (null);
+//     `notifications/*` always get no reply.
+//   - MCP convention: tool errors are NOT JSON-RPC `error` envelopes — they are
+//     successful results with `isError: true`; structured tool errors put the
+//     machine-readable payload on `structuredContent` (MCP 2025-06-18 has no
+//     `json` content-block type).
+/** MCP protocol version advertised in the `initialize` result. */
+export const PROTOCOL_VERSION = '2025-06-18';
+/**
+ * The static tool catalog returned from `tools/list`. Verbatim from the
+ * original `src/mcp.ts:TOOL_LIST` (declaration order: steering, transition,
+ * propose_issue). Declared `as const` so callers cannot accidentally mutate the
+ * shared catalog.
+ */
+export 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.yaml; 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.yaml). 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'],
+        },
+    },
+];
+/**
+ * JSON-RPC error codes used by the framing layer. Ported from the literals the
+ * original passed to `makeError`. Exposed as a const-object enum so callers (the
+ * shell router doing token/active checks) share one vocabulary.
+ */
+export const JsonRpcErrorCode = {
+    /** Reserved JSON-RPC: malformed request envelope. */
+    InvalidRequest: -32600,
+    /** Reserved JSON-RPC: unknown method (or unknown tool name). */
+    MethodNotFound: -32601,
+    /** Reserved JSON-RPC: handler threw. */
+    InternalError: -32603,
+    /** Implementation-defined: the issue identifier is not an active dispatch. */
+    IssueNotActive: -32001,
+    /** Implementation-defined: the bearer token did not match. */
+    InvalidToken: -32002,
+};
+/**
+ * Validate the JSON-RPC request envelope. Faithful port of the original
+ * `isRpcRequest` type-guard: a body is a request iff it is a non-array object
+ * carrying `jsonrpc: '2.0'` and a string `method`. Used by the shell before
+ * routing; the `is` predicate narrows `body` for the caller.
+ */
+export function validateEnvelope(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return false;
+    const rec = body;
+    return rec.jsonrpc === '2.0' && typeof rec.method === 'string';
+}
+/**
+ * Extract the response id from an arbitrary (possibly malformed) body. Faithful
+ * port of the original `getId`: only a string or number `id` survives;
+ * everything else — a non-object body, an array, a missing id, or a literal
+ * `id: null` — collapses to `null`. This is the id used to key error envelopes
+ * for bodies that fail `validateEnvelope`.
+ */
+export function extractId(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;
+}
+/**
+ * Is this validated request a notification (no reply expected)? In JSON-RPC a
+ * notification is a request with NO `id` member at all. The original keyed this
+ * off `body.id === undefined`; a present `id: null` is NOT a notification (it
+ * expects a response keyed `null`).
+ */
+export function isNotification(req) {
+    return req.id === undefined;
+}
+/**
+ * The response id for a validated request: the present id, or `null` when the
+ * request omitted it. Mirrors the original `const id = body.id ?? null;`.
+ */
+export function responseId(req) {
+    return req.id ?? null;
+}
+/** The static `initialize` result body (no id binding). */
+function initializeResult() {
+    return {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: {
+            tools: { listChanged: false },
+        },
+        serverInfo: {
+            name: 'smol-symphony',
+            version: '0.1.0',
+        },
+    };
+}
+/**
+ * Route the *framing* methods of a validated JSON-RPC request. Pure mirror of
+ * the method switch in the original `handleJsonRpc`, minus the stateful
+ * `tools/call` arms (collapsed into a `dispatch` outcome the caller forwards to
+ * the registry decider). The caller is responsible for the active-issue +
+ * token checks (which need the registry) BEFORE calling this; framing assumes
+ * the envelope is already validated.
+ *
+ *   - notification (id omitted)        -> { kind: 'none' }   (HTTP 204)
+ *   - notifications/initialized
+ *     | notifications/cancelled
+ *     | notifications/progress         -> { kind: 'none' }
+ *   - initialize                       -> static initialize result
+ *   - tools/list                       -> static TOOL_LIST result
+ *   - ping                             -> empty {} result
+ *   - tools/call                       -> { kind: 'dispatch', id, toolName, args }
+ *   - any other method                 -> MethodNotFound error
+ */
+export function routeFraming(req) {
+    const notification = isNotification(req);
+    const id = responseId(req);
+    switch (req.method) {
+        case 'notifications/initialized':
+        case 'notifications/cancelled':
+        case 'notifications/progress':
+            // These are always notifications; reply with nothing regardless of id.
+            return { kind: 'none' };
+        case 'initialize': {
+            if (notification)
+                return { kind: 'none' };
+            return { kind: 'respond', response: { jsonrpc: '2.0', id, result: initializeResult() } };
+        }
+        case 'tools/list': {
+            if (notification)
+                return { kind: 'none' };
+            return { kind: 'respond', response: { jsonrpc: '2.0', id, result: { tools: TOOL_LIST } } };
+        }
+        case 'ping': {
+            if (notification)
+                return { kind: 'none' };
+            return { kind: 'respond', response: { jsonrpc: '2.0', id, result: {} } };
+        }
+        case 'tools/call': {
+            if (notification)
+                return { kind: 'none' };
+            const params = (req.params ?? {});
+            return { kind: 'dispatch', id, toolName: params.name, args: params.arguments ?? {} };
+        }
+        default: {
+            if (notification)
+                return { kind: 'none' };
+            return {
+                kind: 'respond',
+                response: makeError(id, JsonRpcErrorCode.MethodNotFound, `unknown method: ${req.method}`),
+            };
+        }
+    }
+}
+/**
+ * Shape a JSON-RPC `error` envelope. Used for protocol-level failures
+ * (malformed envelope, unknown method, inactive issue, bad token, handler
+ * threw). Faithful port of the original module-level `makeError`.
+ */
+export function makeError(id, code, message) {
+    return { jsonrpc: '2.0', id, error: { code, message } };
+}
+/**
+ * Shape an MCP *tool* error: a SUCCESSFUL JSON-RPC result whose payload carries
+ * `isError: true` and a single human-readable text block. Per MCP convention a
+ * tool's own failure is NOT a JSON-RPC `error` envelope — the SDK delivers it as
+ * a normal tool result the agent can read. Faithful port of `makeToolError`.
+ */
+export function makeToolError(id, message) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+            content: [{ type: 'text', text: message }],
+            isError: true,
+        },
+    };
+}
+/**
+ * Shape an MCP tool error that also carries a machine-readable payload. The
+ * human-readable prose stays in `content[]`; the structured shape goes on
+ * `structuredContent` (MCP 2025-06-18's `CallToolResult.content` defines no
+ * `json` block, so structured data lives on the SDK-recognised slot). Used by
+ * `transition` rejections (`unknown_state` / `transition_not_allowed`) and
+ * `propose_issue`'s `no_holding_state`. Faithful port of
+ * `makeStructuredToolError`.
+ */
+export function makeStructuredToolError(id, text, json) {
+    return {
+        jsonrpc: '2.0',
+        id,
+        result: {
+            content: [{ type: 'text', text }],
+            isError: true,
+            structuredContent: json,
+        },
+    };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/core/mcp/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/core/mcp/protocol.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,EAAE;AACF,+EAA+E;AAC/E,+EAA+E;AAC/E,gFAAgF;AAChF,4EAA4E;AAC5E,oBAAoB;AACpB,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,yEAAyE;AACzE,mEAAmE;AACnE,sFAAsF;AACtF,sEAAsE;AACtE,uDAAuD;AACvD,iDAAiD;AACjD,oFAAoF;AACpF,iFAAiF;AACjF,EAAE;AACF,uEAAuE;AACvE,0EAA0E;AAC1E,0EAA0E;AAC1E,iFAAiF;AACjF,0CAA0C;AAC1C,EAAE;AACF,oCAAoC;AACpC,8EAA8E;AAC9E,+EAA+E;AAC/E,sCAAsC;AACtC,EAAE;AACF,8BAA8B;AAC9B,6EAA6E;AAC7E,sDAAsD;AACtD,4EAA4E;AAC5E,wEAAwE;AACxE,gFAAgF;AAChF,kFAAkF;AAClF,iFAAiF;AACjF,6CAA6C;AAC7C,gFAAgF;AAChF,8EAA8E;AAC9E,6EAA6E;AAC7E,kCAAkC;AAIlC,kEAAkE;AAClE,MAAM,CAAC,MAAM,gBAAgB,GAAG,YAAqB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB;QACE,IAAI,EAAE,wBAAwB;QAC9B,WAAW,EACT,sPAAsP;QACxP,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,mFAAmF;iBACtF;gBACD,OAAO,EAAE;oBACP,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,8FAA8F;iBACjG;aACF;YACD,QAAQ,EAAE,CAAC,UAAU,CAAC;SACvB;KACF;IACD;QACE,IAAI,EAAE,YAAY;QAClB,WAAW,EACT,0xBAA0xB;QAC5xB,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,oIAAoI;iBACvI;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,uPAAuP;iBAC1P;aACF;YACD,QAAQ,EAAE,CAAC,UAAU,CAAC;SACvB;KACF;IACD;QACE,IAAI,EAAE,eAAe;QACrB,WAAW,EACT,sfAAsf;QACxf,WAAW,EAAE;YACX,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,KAAK,EAAE;oBACL,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,0HAA0H;iBAC7H;gBACD,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,WAAW,EACT,6JAA6J;iBAChK;gBACD,MAAM,EAAE;oBACN,IAAI,EAAE,OAAO;oBACb,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;oBACzB,WAAW,EAAE,iCAAiC;iBAC/C;gBACD,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,2DAA2D;iBACzE;aACF;YACD,QAAQ,EAAE,CAAC,OAAO,CAAC;SACpB;KACF;CACO,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,qDAAqD;IACrD,cAAc,EAAE,CAAC,KAAK;IACtB,gEAAgE;IAChE,cAAc,EAAE,CAAC,KAAK;IACtB,wCAAwC;IACxC,aAAa,EAAE,CAAC,KAAK;IACrB,8EAA8E;IAC9E,cAAc,EAAE,CAAC,KAAK;IACtB,8DAA8D;IAC9D,YAAY,EAAE,CAAC,KAAK;CACZ,CAAC;AAoBX;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAa;IAC5C,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,OAAO,KAAK,CAAC;IAC3E,MAAM,GAAG,GAAG,IAA+B,CAAC;IAC5C,OAAO,GAAG,CAAC,OAAO,KAAK,KAAK,IAAI,OAAO,GAAG,CAAC,MAAM,KAAK,QAAQ,CAAC;AACjE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,SAAS,CAAC,IAAa;IACrC,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7D,MAAM,GAAG,GAAG,IAA+B,CAAC;QAC5C,IAAI,OAAO,GAAG,CAAC,EAAE,KAAK,QAAQ,IAAI,OAAO,GAAG,CAAC,EAAE,KAAK,QAAQ;YAAE,OAAO,GAAG,CAAC,EAAE,CAAC;IAC9E,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAsB;IACnD,OAAO,GAAG,CAAC,EAAE,KAAK,SAAS,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,GAAsB;IAC/C,OAAO,GAAG,CAAC,EAAE,IAAI,IAAI,CAAC;AACxB,CAAC;AAED,2DAA2D;AAC3D,SAAS,gBAAgB;IACvB,OAAO;QACL,eAAe,EAAE,gBAAgB;QACjC,YAAY,EAAE;YACZ,KAAK,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE;SAC9B;QACD,UAAU,EAAE;YACV,IAAI,EAAE,eAAe;YACrB,OAAO,EAAE,OAAO;SACjB;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,YAAY,CAAC,GAAsB;IACjD,MAAM,YAAY,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;IACzC,MAAM,EAAE,GAAG,UAAU,CAAC,GAAG,CAAC,CAAC;IAE3B,QAAQ,GAAG,CAAC,MAAM,EAAE,CAAC;QACnB,KAAK,2BAA2B,CAAC;QACjC,KAAK,yBAAyB,CAAC;QAC/B,KAAK,wBAAwB;YAC3B,uEAAuE;YACvE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAC1B,KAAK,YAAY,CAAC,CAAC,CAAC;YAClB,IAAI,YAAY;gBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC1C,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC;QAC3F,CAAC;QACD,KAAK,YAAY,CAAC,CAAC,CAAC;YAClB,IAAI,YAAY;gBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC1C,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;QAC7F,CAAC;QACD,KAAK,MAAM,CAAC,CAAC,CAAC;YACZ,IAAI,YAAY;gBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC1C,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QAC3E,CAAC;QACD,KAAK,YAAY,CAAC,CAAC,CAAC;YAClB,IAAI,YAAY;gBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC1C,MAAM,MAAM,GAAG,CAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAA2D,CAAC;YAC5F,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC;QACvF,CAAC;QACD,OAAO,CAAC,CAAC,CAAC;YACR,IAAI,YAAY;gBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;YAC1C,OAAO;gBACL,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,SAAS,CAAC,EAAE,EAAE,gBAAgB,CAAC,cAAc,EAAE,mBAAmB,GAAG,CAAC,MAAM,EAAE,CAAC;aAC1F,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CACvB,EAA0B,EAC1B,IAAY,EACZ,OAAe;IAEf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC;AAC1D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,EAA0B,EAAE,OAAe;IACvE,OAAO;QACL,OAAO,EAAE,KAAK;QACd,EAAE;QACF,MAAM,EAAE;YACN,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;YAC1C,OAAO,EAAE,IAAI;SACd;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CACrC,EAA0B,EAC1B,IAAY,EACZ,IAA6B;IAE7B,OAAO;QACL,OAAO,EAAE,KAAK;QACd,EAAE;QACF,MAAM,EAAE;YACN,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;YACjC,OAAO,EAAE,IAAI;YACb,iBAAiB,EAAE,IAAI;SACxB;KACF,CAAC;AACJ,CAAC"}

package/dist/core/mcp/url.js

@@ -0,0 +1,162 @@
+// FCIS rewrite — pure MCP/ACP URL + state-name resolution.
+//
+// Functional core: every export here is a pure, synchronous (data) -> data
+// function. No IO, no clock, no randomness, no node: imports. Imports ONLY
+// from src/types. The original spread this logic across:
+//   - src/mcp.ts: McpRegistry.buildUrl (base resolution + path) and the
+//     module-private canonicalStateName (case-insensitive declared-name lookup).
+//   - src/agent/vm-acp-mapping.ts: the synthetic guest control-plane constants
+//     (MCP_GUEST_BASE_URL / ACP_WS_GUEST_URL), acpWsUrlFromExplicit,
+//     buildMcpTcpHostEntry — the Gondolin guest→host tunnel rewire.
+//   - src/agent/runner.ts: the `useSyntheticGuestHost` decision (when to dial
+//     the synthetic base vs. the explicit URL).
+//
+// All wall-clock / IO inputs the original read live (the bound HTTP port) are
+// PARAMETERS here: `effectivePort` is passed in by the shell, never read.
+import { resolveStateKey } from '../state-resolve.js';
+// ── Synthetic guest control-plane constants (ported verbatim from vm-acp-mapping.ts) ──
+//
+// Gondolin blocks guest→host loopback by default. The supported rewire is a
+// `tcp.hosts` mapping: the guest dials a synthetic hostname on a fixed port,
+// Gondolin's synthetic per-host DNS resolves it, and the entry tunnels the flow
+// to the host's unified HTTP server loopback. Both control planes (MCP HTTP +
+// the `/acp` WebSocket) ride the SAME entry (`symphony-mcp:7001`).
+/** The synthetic guest hostname the in-VM agent dials for the control plane (MCP + ACP). */
+export const MCP_SYNTHETIC_HOST = 'symphony-mcp';
+/**
+ * The fixed guest-side port the synthetic name is reached on. Both the MCP HTTP
+ * endpoint and the `/acp` WebSocket ride this one host:port (the unified HTTP
+ * server), so they share a single `tcp.hosts` entry.
+ */
+export const MCP_GUEST_PORT = 7001;
+/** Guest-facing base URL the in-VM agent dials for MCP (the `/api/v1/...` path is appended). */
+export const MCP_GUEST_BASE_URL = `http://${MCP_SYNTHETIC_HOST}:${MCP_GUEST_PORT}`;
+/** Path the in-VM agent dials for the ACP control plane on the unified HTTP server. */
+export const ACP_WS_PATH = '/acp';
+/**
+ * Guest-facing WebSocket URL the in-VM agent dials for ACP: `ws://symphony-mcp:7001/acp`.
+ * ACP rides the SAME synthetic `tcp.hosts` entry MCP uses ({@link buildMcpTcpHostEntry});
+ * only the scheme (`ws`) and path (`/acp`) differ from the MCP base URL.
+ */
+export const ACP_WS_GUEST_URL = `ws://${MCP_SYNTHETIC_HOST}:${MCP_GUEST_PORT}${ACP_WS_PATH}`;
+/** Trim trailing slashes from a URL base (mirror of `replace(/\/+$/, '')`). */
+function trimTrailingSlashes(base) {
+    return base.replace(/\/+$/, '');
+}
+/**
+ * The MCP path appended to every base. Kept here so {@link buildUrl} and any
+ * caller deriving the per-issue endpoint agree on a single shape.
+ */
+export function mcpIssuePath(identifier) {
+    return `/api/v1/issues/${encodeURIComponent(identifier)}/mcp`;
+}
+/**
+ * Build the per-issue MCP URL the ACP agent will be told to POST to. Returns
+ * null when no HTTP server is available (`effectivePort === null`) and no
+ * explicit/override URL is configured; the runner uses that to skip MCP
+ * injection instead of advertising an unreachable endpoint.
+ *
+ * Base-resolution precedence (ported verbatim from McpRegistry.buildUrl):
+ *   1. `baseOverride` (e.g. the Gondolin guest synthetic base
+ *      `http://symphony-mcp:7001`) — wins over everything: under Gondolin the
+ *      guest cannot reach the host loopback directly.
+ *   2. `mcp.explicit_host_url` — a directly-reachable URL (no tunnel).
+ *   3. `http://${mcp.host}:${effectivePort}` — the bound HTTP server loopback.
+ *
+ * The original took `effectivePort` from live registry state (`this.effectivePort`);
+ * here it is an explicit parameter so the function stays pure.
+ */
+export function buildUrl(identifier, mcp, effectivePort, baseOverride) {
+    const base = baseOverride
+        ? trimTrailingSlashes(baseOverride)
+        : mcp.explicit_host_url
+            ? trimTrailingSlashes(mcp.explicit_host_url)
+            : effectivePort === null
+                ? null
+                : `http://${mcp.host}:${effectivePort}`;
+    if (!base)
+        return null;
+    return `${base}${mcpIssuePath(identifier)}`;
+}
+/**
+ * Decide whether the in-VM agent should dial the synthetic guest base (the
+ * Gondolin `tcp.hosts` tunnel) instead of an explicit URL / direct loopback.
+ *
+ * Ported from runner.ts `useSyntheticGuestHost`: true iff there is NO
+ * `explicit_host_url` (no direct reachability) AND the HTTP server is bound
+ * (a live tunnel target exists). The condition MUST match the tunnel-injection
+ * predicate so the advertised URL is always backed by a live `tcp.hosts` entry.
+ */
+export function useSyntheticGuestHost(mcp, effectivePort) {
+    return !mcp.explicit_host_url && effectivePort !== null;
+}
+/**
+ * Resolve the guest-facing MCP URL the in-VM agent is told to use, applying the
+ * synthetic-base override when the tunnel is in play. Composes
+ * {@link useSyntheticGuestHost} + {@link buildUrl} the way the runner does:
+ * synthetic base when tunnelled, otherwise the explicit/loopback base.
+ */
+export function guestMcpUrl(identifier, mcp, effectivePort) {
+    const base = useSyntheticGuestHost(mcp, effectivePort) ? MCP_GUEST_BASE_URL : undefined;
+    return buildUrl(identifier, mcp, effectivePort, base);
+}
+/**
+ * Resolve the guest-facing ACP WebSocket URL.
+ *   - No `explicit_host_url` → the synthetic tunnel URL `ws://symphony-mcp:7001/acp`.
+ *   - `explicit_host_url` set → derive from it via {@link acpWsUrlFromExplicit}
+ *     (direct reachability; null when the URL can't be parsed).
+ *
+ * Ported from runner.ts's ACP-back-dial derivation. Note: unlike the MCP path,
+ * the synthetic ACP URL does NOT depend on `effectivePort` — the constant tunnel
+ * URL is fixed and the runner gates the tunnel injection separately.
+ */
+export function guestAcpWsUrl(mcp) {
+    if (mcp.explicit_host_url)
+        return acpWsUrlFromExplicit(mcp.explicit_host_url);
+    return ACP_WS_GUEST_URL;
+}
+/**
+ * Derive the guest ACP WebSocket URL from an explicit MCP host URL (direct
+ * reachability — `mcp.explicit_host_url`). Swaps the `http(s)` scheme for
+ * `ws(s)` and points at `/acp`. Returns null when the URL can't be parsed.
+ *
+ * Ported verbatim from vm-acp-mapping.ts. `URL` is a JS-standard global
+ * (ECMAScript / WHATWG), not a node: import — pure and allowed in core.
+ */
+export function acpWsUrlFromExplicit(explicitHostUrl) {
+    try {
+        const u = new URL(explicitHostUrl);
+        const scheme = u.protocol === 'https:' ? 'wss:' : 'ws:';
+        return `${scheme}//${u.host}${ACP_WS_PATH}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build the `tcp.hosts` entry that tunnels the in-VM agent's control-plane
+ * traffic to the host's unified HTTP server loopback `mcpHost:mcpPort`. The
+ * channel carries only the per-dispatch bearer and is PORT-SPECIFIC so it can
+ * never be reused to reach another host-loopback service.
+ *
+ * Ported verbatim from vm-acp-mapping.ts. The caller pairs this entry with
+ * `dns: { mode: 'synthetic', syntheticHostMapping: 'per-host' }`.
+ */
+export function buildMcpTcpHostEntry(mcpHost, mcpPort) {
+    return { [`${MCP_SYNTHETIC_HOST}:${MCP_GUEST_PORT}`]: `${mcpHost}:${mcpPort}` };
+}
+/**
+ * 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.
+ *
+ * Thin alias over the canonical {@link resolveStateKey} (core/state-resolve.ts);
+ * kept exported here so MCP-URL importers keep their `core/mcp/url` specifier.
+ * Only the keys of `states` matter; the per-state config is unused.
+ */
+export function canonicalStateName(states, name) {
+    return resolveStateKey(states, name);
+}
+//# sourceMappingURL=url.js.map

package/dist/core/mcp/url.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.js","sourceRoot":"","sources":["../../../src/core/mcp/url.ts"],"names":[],"mappings":"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"}

package/dist/core/path.js

@@ -0,0 +1,63 @@
+// FCIS rewrite — canonical LEXICAL POSIX path helpers for the functional core.
+// Pure + synchronous; imports nothing. These replace the ~6 near-identical (and
+// DRIFTING) inline `joinPosix`/`basename`/`posixDirname` copies that core may not
+// satisfy via `node:path` (forbidden in the pure core).
+//
+// 100% PURE + SYNCHRONOUS. No IO, no node: imports, no clock/randomness.
+//
+// SCOPE: these are the simple LEXICAL helpers (one-shot join / strip a segment).
+// They are deliberately NOT a `path.resolve` equivalent — the workflow `extends:`
+// resolver in core/workflow/parse.ts keeps its own `.`/`..`-normalizing
+// `joinPath`/`resolvePath`/`dirname` suite, which is a distinct concept.
+//
+// ─── Resolved drift (the reason this module exists) ──────────────────────────
+//   • joinPosix: core/vm-guards.ts had NO empty-base / absolute-rel handling
+//     while core/actions/predicates.ts did. The canonical adopts the SUPERSET
+//     (predicates form): an empty base or an absolute `rel` returns `rel`
+//     verbatim, else the trailing separator on `base` is collapsed to exactly
+//     one. This matches every vm-guards call site identically (they only ever
+//     pass a non-empty base + a relative rel) AND the predicates behaviour the
+//     existing file_present tests pin. Pinned by tests/core/path.test.ts.
+const SEP = '/';
+/**
+ * Lexical POSIX join of a base path and a relative segment. An empty `base` or
+ * an absolute `rel` (leading `/`) returns `rel` verbatim; otherwise a single
+ * trailing separator on `base` is collapsed so the result has exactly one `/`
+ * at the seam. No `.`/`..` normalization, no fs access.
+ */
+export function joinPosix(base, rel) {
+    if (base.length === 0 || rel.startsWith(SEP))
+        return rel;
+    const trimmedBase = base.endsWith(SEP) ? base.slice(0, -1) : base;
+    return `${trimmedBase}${SEP}${rel}`;
+}
+/**
+ * Variadic POSIX join over already-clean literal segments (the `node:path.join`
+ * shape the credential host-path builders need): empty parts are dropped, the
+ * rest are joined with `/`, and any run of 2+ separators is collapsed to one.
+ * No `.`/`..` normalization.
+ */
+export function joinPosixParts(...parts) {
+    return parts.filter((p) => p.length > 0).join(SEP).replace(/\/{2,}/g, SEP);
+}
+/**
+ * Pure basename: the final path segment, with any trailing `/` or `\` stripped
+ * first. Handles BOTH separators so a workflow path copied from any platform
+ * resolves to its filename. An input with no separator returns itself.
+ */
+export function basename(p) {
+    const trimmed = p.replace(/[/\\]+$/, '');
+    const idx = Math.max(trimmed.lastIndexOf('/'), trimmed.lastIndexOf('\\'));
+    return idx >= 0 ? trimmed.slice(idx + 1) : trimmed;
+}
+/**
+ * POSIX dirname for an absolute `/`-separated path: everything before the final
+ * `/`. The root (and any path whose only `/` is leading) collapses to `/`.
+ */
+export function posixDirname(p) {
+    const idx = p.lastIndexOf(SEP);
+    if (idx <= 0)
+        return SEP;
+    return p.slice(0, idx);
+}
+//# sourceMappingURL=path.js.map

package/dist/core/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../../src/core/path.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,gFAAgF;AAChF,kFAAkF;AAClF,wDAAwD;AACxD,EAAE;AACF,yEAAyE;AACzE,EAAE;AACF,iFAAiF;AACjF,kFAAkF;AAClF,wEAAwE;AACxE,yEAAyE;AACzE,EAAE;AACF,gFAAgF;AAChF,6EAA6E;AAC7E,8EAA8E;AAC9E,0EAA0E;AAC1E,8EAA8E;AAC9E,8EAA8E;AAC9E,+EAA+E;AAC/E,0EAA0E;AAE1E,MAAM,GAAG,GAAG,GAAG,CAAC;AAEhB;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,IAAY,EAAE,GAAW;IACjD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,GAAG,CAAC;IACzD,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAClE,OAAO,GAAG,WAAW,GAAG,GAAG,GAAG,GAAG,EAAE,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,GAAG,KAAe;IAC/C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;AAC7E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAS;IAChC,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1E,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;AACrD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,CAAS;IACpC,MAAM,GAAG,GAAG,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC/B,IAAI,GAAG,IAAI,CAAC;QAAE,OAAO,GAAG,CAAC;IACzB,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;AACzB,CAAC"}