wingfoil 0.2.1

package/dist/mcp/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startMcpServer = exports.createMcpServer = exports.roleSessionPromptName = exports.registerRolePrompts = exports.WRITE_INTENT_META_KEY = exports.WRITE_REFUSAL_MESSAGE = exports.resourceNotFoundError = exports.refuseIfWriteIntent = exports.registerWriteRefusalHandler = exports.WORKFLOW_DOCUMENT_URI_TEMPLATE = exports.WORKFLOWS_COLLECTION_URI = exports.registerWorkflowResources = exports.DNA_SECTION_URI_TEMPLATE = exports.DNA_WHOLE_URI = exports.registerDnaResources = exports.MEMORY_DOCUMENT_URI_TEMPLATE = exports.MEMORY_COLLECTION_URI_TEMPLATE = exports.registerMemoryResources = exports.deriveMcpResourceUri = exports.deriveMcpToolName = exports.registerCoreModules = exports.MODULE_NAME = void 0;
+exports.registerReadOnlyResources = registerReadOnlyResources;
+/** This module's `dna.yaml` name (`mcp-server`) — the stable identifier surfaces and tests key it by. */
+exports.MODULE_NAME = 'mcp-server';
+var registrar_1 = require("./registrar");
+Object.defineProperty(exports, "registerCoreModules", { enumerable: true, get: function () { return registrar_1.registerCoreModules; } });
+Object.defineProperty(exports, "deriveMcpToolName", { enumerable: true, get: function () { return registrar_1.deriveMcpToolName; } });
+Object.defineProperty(exports, "deriveMcpResourceUri", { enumerable: true, get: function () { return registrar_1.deriveMcpResourceUri; } });
+var memory_resource_1 = require("./memory-resource");
+Object.defineProperty(exports, "registerMemoryResources", { enumerable: true, get: function () { return memory_resource_1.registerMemoryResources; } });
+Object.defineProperty(exports, "MEMORY_COLLECTION_URI_TEMPLATE", { enumerable: true, get: function () { return memory_resource_1.MEMORY_COLLECTION_URI_TEMPLATE; } });
+Object.defineProperty(exports, "MEMORY_DOCUMENT_URI_TEMPLATE", { enumerable: true, get: function () { return memory_resource_1.MEMORY_DOCUMENT_URI_TEMPLATE; } });
+var dna_resource_1 = require("./dna-resource");
+Object.defineProperty(exports, "registerDnaResources", { enumerable: true, get: function () { return dna_resource_1.registerDnaResources; } });
+Object.defineProperty(exports, "DNA_WHOLE_URI", { enumerable: true, get: function () { return dna_resource_1.DNA_WHOLE_URI; } });
+Object.defineProperty(exports, "DNA_SECTION_URI_TEMPLATE", { enumerable: true, get: function () { return dna_resource_1.DNA_SECTION_URI_TEMPLATE; } });
+var workflow_resource_1 = require("./workflow-resource");
+Object.defineProperty(exports, "registerWorkflowResources", { enumerable: true, get: function () { return workflow_resource_1.registerWorkflowResources; } });
+Object.defineProperty(exports, "WORKFLOWS_COLLECTION_URI", { enumerable: true, get: function () { return workflow_resource_1.WORKFLOWS_COLLECTION_URI; } });
+Object.defineProperty(exports, "WORKFLOW_DOCUMENT_URI_TEMPLATE", { enumerable: true, get: function () { return workflow_resource_1.WORKFLOW_DOCUMENT_URI_TEMPLATE; } });
+var read_only_1 = require("./read-only");
+Object.defineProperty(exports, "registerWriteRefusalHandler", { enumerable: true, get: function () { return read_only_1.registerWriteRefusalHandler; } });
+Object.defineProperty(exports, "refuseIfWriteIntent", { enumerable: true, get: function () { return read_only_1.refuseIfWriteIntent; } });
+Object.defineProperty(exports, "resourceNotFoundError", { enumerable: true, get: function () { return read_only_1.resourceNotFoundError; } });
+Object.defineProperty(exports, "WRITE_REFUSAL_MESSAGE", { enumerable: true, get: function () { return read_only_1.WRITE_REFUSAL_MESSAGE; } });
+Object.defineProperty(exports, "WRITE_INTENT_META_KEY", { enumerable: true, get: function () { return read_only_1.WRITE_INTENT_META_KEY; } });
+// task-039-mcp-prompts-role-based-infra adds the spec-004 §3 Prompts channel (REQ-INT-02): one
+// `{role}-session` prompt per `dna.yaml` role, embedding that role's directives, resolved per
+// request. Deliberately NOT folded into `registerReadOnlyResources` below (that call is spec-004 §2's
+// Resources bundle); `createMcpServer` registers it alongside that bundle since
+// `task-058-mcp-prompts-role-based` (P5.2.2, spec-014 §3). See `./prompt.ts`.
+var prompt_1 = require("./prompt");
+Object.defineProperty(exports, "registerRolePrompts", { enumerable: true, get: function () { return prompt_1.registerRolePrompts; } });
+Object.defineProperty(exports, "roleSessionPromptName", { enumerable: true, get: function () { return prompt_1.roleSessionPromptName; } });
+const dna_resource_2 = require("./dna-resource");
+const memory_resource_2 = require("./memory-resource");
+const read_only_2 = require("./read-only");
+const workflow_resource_2 = require("./workflow-resource");
+/**
+ * Wire the full spec-004 §2 read-only Resources channel onto `server` in one call: the Memory, DNA,
+ * and Workflow Resources plus the structural `resources/write` refusal. Deliberately does not touch
+ * `registerCoreModules`/`CORE_MODULES` — a caller building a real server still calls that separately
+ * for the (today, zero) Tools/legacy-shaped Resources it derives from `src/core`.
+ */
+function registerReadOnlyResources(server, options) {
+    (0, read_only_2.registerWriteRefusalHandler)(server);
+    (0, memory_resource_2.registerMemoryResources)(server, options);
+    (0, dna_resource_2.registerDnaResources)(server, options);
+    (0, workflow_resource_2.registerWorkflowResources)(server, options);
+}
+// The production stdio entry point (task-030-implement-mcp-resources, spec-014-mcp-server-entry-point):
+// `createMcpServer` builds a real `McpServer` with the read-only Resources and Prompts channels above wired on,
+// `startMcpServer` connects it over `StdioServerTransport`. Exported here so the `bin`/`wingfoil mcp`
+// seam imports the whole `src/mcp` surface from one module.
+var server_1 = require("./server");
+Object.defineProperty(exports, "createMcpServer", { enumerable: true, get: function () { return server_1.createMcpServer; } });
+Object.defineProperty(exports, "startMcpServer", { enumerable: true, get: function () { return server_1.startMcpServer; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";;;AA8EA,8DAKC;AA7DD,yGAAyG;AAC5F,QAAA,WAAW,GAAG,YAAqB,CAAC;AAEjD,yCAA2F;AAAlF,gHAAA,mBAAmB,OAAA;AAAE,8GAAA,iBAAiB,OAAA;AAAE,iHAAA,oBAAoB,OAAA;AAGrE,qDAI2B;AAHzB,0HAAA,uBAAuB,OAAA;AACvB,iIAAA,8BAA8B,OAAA;AAC9B,+HAAA,4BAA4B,OAAA;AAI9B,+CAA+F;AAAtF,oHAAA,oBAAoB,OAAA;AAAE,6GAAA,aAAa,OAAA;AAAE,wHAAA,wBAAwB,OAAA;AAGtE,yDAI6B;AAH3B,8HAAA,yBAAyB,OAAA;AACzB,6HAAA,wBAAwB,OAAA;AACxB,mIAAA,8BAA8B,OAAA;AAIhC,yCAMqB;AALnB,wHAAA,2BAA2B,OAAA;AAC3B,gHAAA,mBAAmB,OAAA;AACnB,kHAAA,qBAAqB,OAAA;AACrB,kHAAA,qBAAqB,OAAA;AACrB,kHAAA,qBAAqB,OAAA;AAGvB,+FAA+F;AAC/F,8FAA8F;AAC9F,sGAAsG;AACtG,gFAAgF;AAChF,8EAA8E;AAC9E,mCAAsE;AAA7D,6GAAA,mBAAmB,OAAA;AAAE,+GAAA,qBAAqB,OAAA;AAGnD,iDAAsD;AACtD,uDAA4D;AAC5D,2CAA0D;AAC1D,2DAAgE;AAQhE;;;;;GAKG;AACH,SAAgB,yBAAyB,CAAC,MAAiB,EAAE,OAAyC;IACpG,IAAA,uCAA2B,EAAC,MAAM,CAAC,CAAC;IACpC,IAAA,yCAAuB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,IAAA,mCAAoB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,IAAA,6CAAyB,EAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAC7C,CAAC;AAED,wGAAwG;AACxG,gHAAgH;AAChH,sGAAsG;AACtG,4DAA4D;AAC5D,mCAA2D;AAAlD,yGAAA,eAAe,OAAA;AAAE,wGAAA,cAAc,OAAA"}

package/dist/mcp/memory-resource.d.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Options for {@link registerMemoryResources}. */
+export interface RegisterMemoryResourcesOptions {
+    /** Resolves the project root each Memory Resource read is served from (an ambient concern, not a request parameter). */
+    readonly resolveRoot: () => string;
+}
+/** spec-004 §2.1 — collection listing (frontmatter only, no `{id}`). */
+export declare const MEMORY_COLLECTION_URI_TEMPLATE = "wingfoil://memory/{type}";
+/** spec-004 §2.1 — a single Memory document (full frontmatter + body). */
+export declare const MEMORY_DOCUMENT_URI_TEMPLATE = "wingfoil://memory/{type}/{id}";
+/**
+ * Register both Memory Resources on `server`. Reads `.wingfoil/memory.yaml` fresh on every request
+ * (no server-lifetime cache) — same "no cold-start cost, no stale-config either" contract the rest of
+ * `src/mcp`'s Resources already follow.
+ */
+export declare function registerMemoryResources(server: McpServer, options: RegisterMemoryResourcesOptions): void;
+//# sourceMappingURL=memory-resource.d.ts.map

package/dist/mcp/memory-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-resource.d.ts","sourceRoot":"","sources":["../../src/mcp/memory-resource.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AASzE,mDAAmD;AACnD,MAAM,WAAW,8BAA8B;IAC7C,wHAAwH;IACxH,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;CACpC;AAED,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,6BAA6B,CAAC;AACzE,0EAA0E;AAC1E,eAAO,MAAM,4BAA4B,kCAAkC,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,8BAA8B,GAAG,IAAI,CAyFxG"}

package/dist/mcp/memory-resource.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_DOCUMENT_URI_TEMPLATE = exports.MEMORY_COLLECTION_URI_TEMPLATE = void 0;
+exports.registerMemoryResources = registerMemoryResources;
+/**
+ * `wingfoil://memory/{type}` (collection) and `wingfoil://memory/{type}/{id}` (single document)
+ * Resources — task-011-mcp-resources-read-only, REQ-INT-01, spec-004-mcp-surface-contract §2.1/§2.2.
+ * This REPLACES task-009-mcp-resource-fetch-latency's placeholder `wingfoil://memory/{id}` adapter
+ * (that module's own doc-comment flagged itself as non-conformant and due for replacement, not
+ * extension, precisely because its single `{id}` segment collides with spec-004's `{type}` segment —
+ * see `src/memory/query.ts`'s `findMemoryDocumentById` doc comment for the full history). REQ-PERF-04
+ * coverage is ported forward onto this conformant URI, not dropped (`test/mcp/resource-latency.test.ts`).
+ *
+ * The two handlers differ deliberately on **archived content** (REQ-STATE-06, the set ratified by
+ * `dl-028-archived-states-excluded-from-context`, fixed by
+ * `task-069-fix-archived-excluded-from-agent-context` for `bug-010-deprecated-reaches-agent-context`).
+ * The **collection** withholds documents whose `status` is archived (`{deprecated, superseded}`), so
+ * an agent browsing a type is never handed a replaced or retired decision as if it were current — the
+ * same guarantee `wingfoil://memory/search` and default `memory search` already give. The
+ * **single-document** Resource does **not** filter: addressing a document by its id is explicit
+ * retrieval, which REQ-STATE-06 preserves ("remaining present on disk and in git history"). It is the
+ * MCP counterpart of `memory search --status deprecated` on the CLI, whose own opt-in
+ * (`memorySearchFn`, `src/core/index.ts`) is gated on the same `isArchivedStatus`. `draft` is not
+ * archived and is withheld by neither handler; only the *context* path (`src/core/relevance.ts`)
+ * excludes it as well.
+ *
+ * Both handlers are thin adapters over `src/memory/query.ts`'s primitives
+ * (`listMemoryDocumentsByType`, `findMemoryDocumentByTypeAndId`, both new in this task) — no scanning
+ * logic lives here, only URI-variable extraction, the read-only guard (`./read-only`), and MCP
+ * envelope shaping. Registered directly via `McpServer.registerResource` rather than through
+ * `registerCoreModules`'s `CoreModule[]` registry (`src/core/registry.ts`): no `memoryShow`/`memoryList`
+ * `CoreOperation` exists in `src/core`'s production `CORE_MODULES` yet (see `src/core/index.ts`'s SCOPE
+ * note). This is the same spec-006-core-domain-api §4 (Parity rule) deviation task-009 already
+ * documented for this surface — acceptable because it is read-only and has no CLI/Tool counterpart to
+ * keep in parity with, to be reconciled (or re-confirmed as permanent) by
+ * task-030-implement-mcp-resources, which also wires a real `StdioServerTransport`/`wingfoil mcp`
+ * entry point around this registrar (out of this task's scope — see this task's Execution Notes for
+ * the task-011-vs-task-030 boundary).
+ */
+const path_1 = require("path");
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const core_1 = require("../core");
+const query_1 = require("../memory/query");
+const state_machine_1 = require("../memory/state-machine");
+const storage_1 = require("../storage");
+const read_only_1 = require("./read-only");
+/** spec-004 §2.1 — collection listing (frontmatter only, no `{id}`). */
+exports.MEMORY_COLLECTION_URI_TEMPLATE = 'wingfoil://memory/{type}';
+/** spec-004 §2.1 — a single Memory document (full frontmatter + body). */
+exports.MEMORY_DOCUMENT_URI_TEMPLATE = 'wingfoil://memory/{type}/{id}';
+/**
+ * Register both Memory Resources on `server`. Reads `.wingfoil/memory.yaml` fresh on every request
+ * (no server-lifetime cache) — same "no cold-start cost, no stale-config either" contract the rest of
+ * `src/mcp`'s Resources already follow.
+ */
+function registerMemoryResources(server, options) {
+    const collectionTemplate = new mcp_js_1.ResourceTemplate(exports.MEMORY_COLLECTION_URI_TEMPLATE, { list: undefined });
+    server.registerResource('memory.list', collectionTemplate, { description: 'Memory documents of one type, frontmatter only (read-only)' }, async (uri, variables, extra) => {
+        (0, read_only_1.refuseIfWriteIntent)(extra._meta);
+        const root = options.resolveRoot();
+        const memoryYaml = (0, core_1.loadMemoryYaml)(root);
+        // `variables.type` is typed `string | string[]` (the SDK's generic `Variables` shape), but
+        // this template's `{type}` variable has no `*`/`+` explode modifier, so a match always binds
+        // it to a single string (see the SDK's `UriTemplate.match`) — the `string[]` case is
+        // unreachable here (mirrors task-009's own `{id}` reasoning for this same SDK behaviour).
+        const type = variables.type;
+        if (!(type in memoryYaml.types))
+            throw (0, read_only_1.resourceNotFoundError)(`memory/${type}`);
+        // REQ-STATE-06 / `dl-028-archived-states-excluded-from-context` (`bug-010`): this collection is
+        // an agent-facing read path, so archived documents — `{deprecated, superseded}`, per the shared
+        // `isArchivedStatus` — are withheld here. The filter sits at this call site rather than inside
+        // `listMemoryDocumentsByType` because that primitive also serves the single-document Resource's
+        // consumers, which must still see archived content; the *policy* belongs to the surface, while
+        // the *definition* of "archived" stays single, as dl-028 requires. `status` is already
+        // projected to `string | undefined` by the primitive — the shape `isArchivedStatus` takes — so
+        // a non-string frontmatter `status` is never archived. `filter` preserves the primitive's
+        // id-ascending order (REQ-SYS-07).
+        const summaries = (0, query_1.listMemoryDocumentsByType)(root, memoryYaml, type)
+            .filter(({ status }) => !(0, state_machine_1.isArchivedStatus)(status))
+            .map(({ id, title, status, tags }) => ({
+            id,
+            title,
+            status,
+            tags,
+        }));
+        return (0, read_only_1.jsonResourceResult)(uri, summaries);
+    });
+    const documentTemplate = new mcp_js_1.ResourceTemplate(exports.MEMORY_DOCUMENT_URI_TEMPLATE, { list: undefined });
+    server.registerResource('memory.show', documentTemplate, { description: 'one Memory document, full content + metadata (read-only)' }, async (uri, variables, extra) => {
+        (0, read_only_1.refuseIfWriteIntent)(extra._meta);
+        const root = options.resolveRoot();
+        const memoryYaml = (0, core_1.loadMemoryYaml)(root);
+        const type = variables.type;
+        const id = variables.id;
+        if (!(type in memoryYaml.types))
+            throw (0, read_only_1.resourceNotFoundError)(`memory/${type}/${id}`);
+        const doc = (0, query_1.findMemoryDocumentByTypeAndId)(root, memoryYaml, type, id);
+        if (!doc)
+            throw (0, read_only_1.resourceNotFoundError)(`memory/${type}/${id}`);
+        // spec-004 §2.2 wants the *full file content* (frontmatter + body), not the re-serialized
+        // parsed frontmatter `loadMemoryDocumentSummary` already split apart for the scan — so this
+        // re-reads the resolved path's raw bytes via `storage.readDocument` (still a read primitive
+        // reuse, not a reimplemented scan: the scan itself already happened inside
+        // `findMemoryDocumentByTypeAndId`).
+        const fullText = (0, storage_1.readDocument)((0, path_1.join)(root, doc.path));
+        // spec-004 §2.2 depicts `metadata` as a sibling of `uri`/`mimeType`/`text`, i.e. flat on the
+        // result — not nested inside a `contents[]` entry (whose shape the real MCP wire schema fixes
+        // to `{uri, mimeType, text|blob, _meta?}`, `ReadResourceResultSchema`'s `contents` union in the
+        // SDK's `types.d.ts`). The top-level `ReadResourceResultSchema` object itself is passthrough
+        // (`z.core.$loose`), so this extra top-level `metadata` key is preserved end to end (server ->
+        // wire -> client parse) without needing a non-standard content shape. Built via an
+        // untyped-at-the-literal `result` variable (assigned, not returned directly) so TypeScript's
+        // excess-property check — which only applies to object literals in a contextually-typed
+        // position — never triggers on this extra key.
+        const result = {
+            contents: [
+                {
+                    uri: uri.toString(),
+                    mimeType: 'text/markdown',
+                    text: fullText,
+                },
+            ],
+            metadata: {
+                id: doc.frontmatter.id,
+                type: doc.frontmatter.type,
+                status: doc.frontmatter.status,
+                title: doc.frontmatter.title,
+            },
+        };
+        return result;
+    });
+}
+//# sourceMappingURL=memory-resource.js.map

package/dist/mcp/memory-resource.js.map

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

package/dist/mcp/prompt.d.ts

@@ -0,0 +1,48 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Options for {@link registerRolePrompts}. */
+export interface RegisterRolePromptsOptions {
+    /**
+     * Resolves the project root each `prompts/get` is served from — invoked per request by the prompt
+     * handlers, and once by {@link registerRolePrompts} itself to read the DNA role catalogue (see
+     * that function's note on the two different timings spec-004 §3.1 and §3.2 mandate).
+     */
+    readonly resolveRoot: () => string;
+}
+/**
+ * `{role}-session` — spec-004 §3.1's prompt naming convention, as a function so the wire-visible name
+ * is derived in exactly one place (the registrar here, and any later consumer such as
+ * `task-058-mcp-prompts-role-based`) rather than spelled out per call site.
+ */
+export declare function roleSessionPromptName(role: string): string;
+/**
+ * Register the role-scoped Prompts channel: one `{role}-session` Prompt per role in `dna.yaml`'s
+ * `team.roles` catalogue (spec-004 §3.1), each embedding that role's directives (§3.2), and a refusal
+ * for a session prompt naming a role DNA does not declare (P5.2.2's undefined-role scenario).
+ *
+ * **Nothing is read here — every read happens per request** (task-058 second pass, rejection `ff13321`).
+ * spec-014 §2 requires `createMcpServer` to perform "no I/O at construction time beyond wiring
+ * handlers", so the DNA role catalogue is loaded inside the `prompts/list` / `prompts/get` handlers,
+ * next to the per-request directive resolution spec-004 §3.2 already mandated (REQ-INT-02's "a newly
+ * assigned directive appears on the next session start"). Two consequences, both deliberate:
+ *
+ * - `wingfoil mcp` starts in a git root with no `.wingfoil/dna.yaml` (e.g. a repository that has not
+ *   run `wingfoil init`) exactly as the Resources channel always has; the missing DNA surfaces as the
+ *   error of each Prompts request instead of aborting the process start.
+ * - spec-004 §3.1's "fixed set derived from DNA at server start" is served as the DNA role set **at
+ *   request time**: a role added to `dna.yaml` while the server runs is listed on the next
+ *   `prompts/list`. That tension between spec-014 §2 and spec-004 §3.1 is open for the approver.
+ *
+ * **Why the low-level handlers, not `McpServer.registerPrompt`.** The high-level API answers an
+ * unregistered name with its own `Prompt <name> not found` before any WingFoil code runs, so the BDD's
+ * `no prompt for undefined role 'wizard'` cannot be expressed through it (and it would need the role
+ * set at registration time). This function therefore owns `prompts/list` and `prompts/get` on
+ * `server.server` — the same pattern `./read-only.ts`'s `registerWriteRefusalHandler` uses — and a
+ * later `registerPrompt` on the same server fails loudly ("A request handler for prompts/list already
+ * exists") instead of being silently shadowed. A requested name that is not `{role}-session`-shaped
+ * keeps the SDK-equivalent `Prompt <name> not found` wording: it names no role, so it is not an
+ * undefined-role request, and it is answered without reading anything.
+ *
+ * Call before the server is connected (MCP capabilities cannot be registered after connecting).
+ */
+export declare function registerRolePrompts(server: McpServer, options: RegisterRolePromptsOptions): void;
+//# sourceMappingURL=prompt.d.ts.map

package/dist/mcp/prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt.d.ts","sourceRoot":"","sources":["../../src/mcp/prompt.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAQzE,+CAA+C;AAC/C,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;CACpC;AAMD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1D;AAgGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B,GAAG,IAAI,CAkBhG"}

package/dist/mcp/prompt.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roleSessionPromptName = roleSessionPromptName;
+exports.registerRolePrompts = registerRolePrompts;
+/**
+ * The role-scoped MCP **Prompts** channel — `{role}-session` prompts that embed the role's assigned
+ * directives (task-039-mcp-prompts-role-based-infra, **REQ-INT-02**,
+ * `spec-004-mcp-surface-contract` §3). This is the third and last channel type spec-004 §1 names,
+ * alongside the Resources channel (`./index.ts`'s `registerReadOnlyResources`, task-011/task-030) and
+ * the still-unshipped Tools channel (P5.2.3, v0.4).
+ *
+ * **Wired into the production server by `task-058-mcp-prompts-role-based` (P5.2.2).** task-039
+ * shipped this registrar as infra, exactly like `task-011-mcp-resources-read-only` did for Resources;
+ * task-058 adds it to `createMcpServer` (`./server.ts`) per `spec-014-mcp-server-entry-point` §3
+ * ("when Prompts ship (P5.2.2, v0.2), it adds their registrar") and implements the undefined-role
+ * refusal of `p5-interaction/P5.2.2-mcp-prompts.feature` (`no prompt for undefined role '<role>'`).
+ *
+ * **Read-only (spec-004 §3.3).** A prompt handler reads `dna.yaml`, `roles.yaml` and the directive
+ * files and returns text. There is no code path in this module that writes, and it registers no Tool —
+ * so Prompts cannot become the agent write path REQ-SEC-05 reserves for validated Tools
+ * (`test/mcp/role-prompts.test.ts` asserts both: files byte-for-byte unchanged after a round trip, and
+ * `tools/list` still unroutable on a Prompts-only server).
+ *
+ * **Nothing is re-implemented here.** Role catalogue via `loadDnaYaml`, bindings via `loadRolesYaml`,
+ * directive files via `loadDirectives`, and the role → directive resolution itself via
+ * `resolveRoleDirectives` (`src/core/context.ts`, task-037) — the same canonical resolver
+ * `assembleExecutionContext` uses, so REQ-INT-02's "100% of R's currently assigned directives" and
+ * REQ-STATE-05's "100% of the role's directives and 0 of another role's" stay one guarantee rather than
+ * two that can drift apart. The only thing that resolver does not supply is a directive's **body**
+ * (`loadDirectives` returns `{path, frontmatter}`), which {@link readDirectiveBody} reads with the
+ * `storage` primitives `./memory-resource.ts` already uses for the same reason.
+ */
+const path_1 = require("path");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const core_1 = require("../core");
+const storage_1 = require("../storage");
+/** spec-004 §3.1's prompt-name suffix: one prompt per role, named `{role}-session`. Module-local —
+ * {@link roleSessionPromptName} is the only naming API this channel exposes. */
+const ROLE_PROMPT_NAME_SUFFIX = '-session';
+/**
+ * `{role}-session` — spec-004 §3.1's prompt naming convention, as a function so the wire-visible name
+ * is derived in exactly one place (the registrar here, and any later consumer such as
+ * `task-058-mcp-prompts-role-based`) rather than spelled out per call site.
+ */
+function roleSessionPromptName(role) {
+    return `${role}${ROLE_PROMPT_NAME_SUFFIX}`;
+}
+/**
+ * A `prompts/get` refusal whose JSON-RPC error carries `message` **verbatim** with code `InvalidParams`
+ * (-32602, the code the MCP SDK itself uses for an unknown prompt name).
+ *
+ * Deliberately a plain `Error` with a `code`, not the SDK's `McpError`: `McpError`'s constructor
+ * prefixes its own message with `MCP error <code>: `, and the SDK serializes `error.message` as-is, so a
+ * client — which adds that prefix again when it rebuilds the error — would read the prefix twice.
+ */
+function promptRequestError(message) {
+    return Object.assign(new Error(message), { code: types_js_1.ErrorCode.InvalidParams });
+}
+/**
+ * The P5.2.2 undefined-role refusal, verbatim from `p5-interaction/P5.2.2-mcp-prompts.feature`
+ * (Scenario "Error - requesting a prompt for an undefined role"): `no prompt for undefined role '<role>'`.
+ */
+function undefinedRolePromptError(role) {
+    return promptRequestError(`no prompt for undefined role '${role}'`);
+}
+/**
+ * Read one directive file's body — everything after its YAML frontmatter block, trimmed of
+ * surrounding blank lines so the composed prompt is a pure function of the file's content and not of
+ * how many trailing newlines its author happened to leave (REQ-SYS-07).
+ *
+ * `file.path` is root-relative to `.wingfoil/` (`loadDirectives` stores it as `directives/<...>.md`),
+ * so it is resolved against `<root>/.wingfoil` here. A file with no frontmatter block cannot reach
+ * this function — `loadDirectives` rejects that case with `E_MISSING_FRONTMATTER` before any
+ * directive is returned — but `splitFrontmatter` degrades to "whole document is body" anyway.
+ */
+function readDirectiveBody(root, file) {
+    return (0, storage_1.splitFrontmatter)((0, storage_1.readDocument)((0, path_1.join)(root, storage_1.WINGFOIL_DIR, file.path))).body.trim();
+}
+/**
+ * Compose the prompt text for `role` from its already-resolved directives — spec-004 §3.2's shape: a
+ * `# Role: {role}` header followed by one `## Directive: {id}` block per directive, each carrying that
+ * directive's full body.
+ *
+ * The heading uses `frontmatter.id`, not `name`: spec-004 §3.2's own example headings read
+ * `## Directive: code-quality` / `security-secrets`, which are the `id` values of the real directive
+ * files (`code-quality.md` carries `id: code-quality`, `name: "Code Quality"`), and `roles.yaml` binds
+ * by id.
+ *
+ * Block order is `resolveRoleDirectives`' — deduplicated by id and sorted id-ascending per
+ * `spec-012-context-loader-relevance-filtering` §5 / REQ-SYS-07 — rather than the "own directives,
+ * then globals" grouping spec-004 §3.2's illustrative example happens to print. §3.2 states the
+ * resolution itself as a *set* union (`roles.yaml[R].directives` ∪ `global`), which fixes membership,
+ * not sequence; an explicit total order is what makes two runs byte-identical.
+ */
+function composeRolePromptText(role, directives) {
+    const blocks = directives.map(({ id, body }) => `## Directive: ${id}\n${body}`);
+    return [`# Role: ${role}`, ...blocks].join('\n\n');
+}
+/**
+ * Build the `prompts/get` result for `role`: resolve its directives against the project **now**
+ * (spec-004 §3.2 — per request, never cached from server boot) and compose them into one message.
+ *
+ * `resolveRoleDirectives` also returns operator diagnostics (`warnings`, e.g. dl-029's "no directives
+ * assigned to role 'intern'"); they are **not** embedded in the prompt. spec-004 §3.2 defines the
+ * prompt payload as role header + directive blocks, and folding a diagnostic into agent-facing
+ * instruction text would put an unratified string into the payload — the same reasoning
+ * `src/core/context.ts` gives for keeping its own warnings out of the serialized context envelope.
+ */
+function buildRolePrompt(root, role) {
+    const { directives } = (0, core_1.resolveRoleDirectives)((0, core_1.loadDirectives)(root), (0, core_1.loadRolesYaml)(root), role);
+    const text = composeRolePromptText(role, directives.map((file) => ({ id: file.frontmatter.id, body: readDirectiveBody(root, file) })));
+    // MCP's `PromptMessage.role` is the two-value enum `"user" | "assistant"` (the SDK's
+    // `PromptMessageSchema`), so spec-004 §3.2's illustrative `role: "system"` is not representable on
+    // this protocol by any conformant server; `user` is the only wire role that can deliver
+    // instructional content. Open as `dl-039-spec-004-prompt-example-corrections`.
+    return { messages: [{ role: 'user', content: { type: 'text', text } }] };
+}
+/**
+ * The DNA role catalogue as `dna.yaml` declares it **now**, in declaration order. Read per request (see
+ * {@link registerRolePrompts}); a missing or invalid `dna.yaml` throws the loader's own error, which the
+ * SDK returns to the client as that request's error — the same way `wingfoil://dna` reports it.
+ */
+function loadRoleNames(root) {
+    return (0, core_1.loadDnaYaml)(root).team.roles.map(({ name }) => name);
+}
+/**
+ * Register the role-scoped Prompts channel: one `{role}-session` Prompt per role in `dna.yaml`'s
+ * `team.roles` catalogue (spec-004 §3.1), each embedding that role's directives (§3.2), and a refusal
+ * for a session prompt naming a role DNA does not declare (P5.2.2's undefined-role scenario).
+ *
+ * **Nothing is read here — every read happens per request** (task-058 second pass, rejection `ff13321`).
+ * spec-014 §2 requires `createMcpServer` to perform "no I/O at construction time beyond wiring
+ * handlers", so the DNA role catalogue is loaded inside the `prompts/list` / `prompts/get` handlers,
+ * next to the per-request directive resolution spec-004 §3.2 already mandated (REQ-INT-02's "a newly
+ * assigned directive appears on the next session start"). Two consequences, both deliberate:
+ *
+ * - `wingfoil mcp` starts in a git root with no `.wingfoil/dna.yaml` (e.g. a repository that has not
+ *   run `wingfoil init`) exactly as the Resources channel always has; the missing DNA surfaces as the
+ *   error of each Prompts request instead of aborting the process start.
+ * - spec-004 §3.1's "fixed set derived from DNA at server start" is served as the DNA role set **at
+ *   request time**: a role added to `dna.yaml` while the server runs is listed on the next
+ *   `prompts/list`. That tension between spec-014 §2 and spec-004 §3.1 is open for the approver.
+ *
+ * **Why the low-level handlers, not `McpServer.registerPrompt`.** The high-level API answers an
+ * unregistered name with its own `Prompt <name> not found` before any WingFoil code runs, so the BDD's
+ * `no prompt for undefined role 'wizard'` cannot be expressed through it (and it would need the role
+ * set at registration time). This function therefore owns `prompts/list` and `prompts/get` on
+ * `server.server` — the same pattern `./read-only.ts`'s `registerWriteRefusalHandler` uses — and a
+ * later `registerPrompt` on the same server fails loudly ("A request handler for prompts/list already
+ * exists") instead of being silently shadowed. A requested name that is not `{role}-session`-shaped
+ * keeps the SDK-equivalent `Prompt <name> not found` wording: it names no role, so it is not an
+ * undefined-role request, and it is answered without reading anything.
+ *
+ * Call before the server is connected (MCP capabilities cannot be registered after connecting).
+ */
+function registerRolePrompts(server, options) {
+    server.server.registerCapabilities({ prompts: {} });
+    server.server.setRequestHandler(types_js_1.ListPromptsRequestSchema, () => ({
+        prompts: loadRoleNames(options.resolveRoot()).map((role) => ({
+            name: roleSessionPromptName(role),
+            description: `session instructions for the '${role}' role, embedding its assigned directives (read-only)`,
+        })),
+    }));
+    server.server.setRequestHandler(types_js_1.GetPromptRequestSchema, (request) => {
+        const { name } = request.params;
+        if (!name.endsWith(ROLE_PROMPT_NAME_SUFFIX)) {
+            throw promptRequestError(`Prompt ${name} not found`);
+        }
+        const role = name.slice(0, -ROLE_PROMPT_NAME_SUFFIX.length);
+        const root = options.resolveRoot();
+        if (!loadRoleNames(root).includes(role))
+            throw undefinedRolePromptError(role);
+        return buildRolePrompt(root, role);
+    });
+}
+//# sourceMappingURL=prompt.js.map

package/dist/mcp/prompt.js.map

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

package/dist/mcp/read-only.d.ts

@@ -0,0 +1,42 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** spec-004 §2.3's exact, verbatim write-refusal string. */
+export declare const WRITE_REFUSAL_MESSAGE = "resources are read-only";
+/**
+ * The `_meta` key WingFoil's own bespoke Resource handlers treat as "this `resources/read` call is
+ * carrying a write intent/payload" — not an MCP-defined field (see module doc). Any truthy value
+ * under this key refuses the read identically to an unsupported `resources/write` call.
+ */
+export declare const WRITE_INTENT_META_KEY = "wingfoil/write-intent";
+/**
+ * Refuse a read carrying a write intent (see module doc, case 2). Called first, before any other
+ * work, by every bespoke Resource handler this task registers — so the refusal is unconditional and
+ * precedes any read/scan/file-access, never a check bolted on after a read already started.
+ */
+export declare function refuseIfWriteIntent(meta: Record<string, unknown> | undefined): void;
+/** spec-004 §2.2's "resource not found" shape — distinct wording from the write refusal above, per
+ * the BDD scenario (`P5.2.1-mcp-resources.feature`) `resource not found: {identifier}` format. */
+export declare function resourceNotFoundError(identifier: string): Error;
+/**
+ * The `ReadResourceResult` shape every JSON-bodied Resource in `memory-resource.ts` (collection
+ * listing), `dna-resource.ts`, and `workflow-resource.ts` returns — one `contents[]` entry,
+ * `mimeType: 'application/json'`, `value` serialized as its `text`. Factored here purely to avoid
+ * re-deriving the same three-line envelope at each of those five call sites; `memory-resource.ts`'s
+ * single-document read builds its own `text/markdown` + `metadata` result directly, since that shape
+ * differs (spec-004 §2.2).
+ */
+export declare function jsonResourceResult(uri: URL, value: unknown): {
+    contents: [{
+        uri: string;
+        mimeType: string;
+        text: string;
+    }];
+};
+/**
+ * Install the `resources/write` refusal (see module doc, case 1). MCP's own protocol does not define
+ * `resources/write` at all — no client capability or built-in handler exists for it — so this method
+ * name has no default routing on the server; without this handler such a call would fail with a
+ * generic JSON-RPC "Method not found" rather than spec-004 §2.3's specific refusal text. There is no
+ * write path here to gate: the handler always throws, unconditionally.
+ */
+export declare function registerWriteRefusalHandler(server: McpServer): void;
+//# sourceMappingURL=read-only.d.ts.map

package/dist/mcp/read-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-only.d.ts","sourceRoot":"","sources":["../../src/mcp/read-only.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,4DAA4D;AAC5D,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAInF;AAED;kGACkG;AAClG,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,KAAK,CAE/D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,GAAG;IAAE,QAAQ,EAAE,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAU5H;AAUD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAInE"}

package/dist/mcp/read-only.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITE_INTENT_META_KEY = exports.WRITE_REFUSAL_MESSAGE = void 0;
+exports.refuseIfWriteIntent = refuseIfWriteIntent;
+exports.resourceNotFoundError = resourceNotFoundError;
+exports.jsonResourceResult = jsonResourceResult;
+exports.registerWriteRefusalHandler = registerWriteRefusalHandler;
+/**
+ * Shared conventions for every bespoke Resource this task registers (`memory-resource`,
+ * `dna-resource`, `workflow-resource`): the read-only-channel guarantee — spec-004-mcp-surface-contract
+ * §2.3's verbatim write-refusal string, plus the standard MCP "resource not found" shape (§2.2) — and
+ * the common JSON-bodied result envelope, factored once so every module refuses/reports/shapes
+ * identically rather than re-deriving the same strings/shape per handler
+ * (task-011-mcp-resources-read-only, REQ-INT-01 / REQ-SEC-05).
+ *
+ * Two distinct write-attempt shapes must be refused (spec-004 §2.3):
+ *
+ * 1. An unsupported `resources/write` JSON-RPC call — {@link registerWriteRefusalHandler} installs a
+ *    handler for that literal method name (which the MCP protocol itself does not define at all — see
+ *    the SDK's `types.d.ts`: there is no `ResourceWrite*` schema) that unconditionally refuses. This
+ *    is structural, not a gated check: the handler has no branch that could ever succeed.
+ * 2. A `resources/read` request "carrying a write intent/payload". The real wire schema
+ *    (`ReadResourceRequestSchema`) strips any unknown key placed directly on `params` before a
+ *    handler ever sees it (Zod `$strip` mode) — the one part of that schema that is *not* stripped is
+ *    the nested `_meta` sub-object, which the SDK itself models as passthrough (`$loose`) for
+ *    out-of-band caller metadata. {@link WRITE_INTENT_META_KEY} is WingFoil's own convention (MCP
+ *    defines no write-intent field) for exercising that one channel a misbehaving/malicious client
+ *    could still smuggle a write payload through; {@link refuseIfWriteIntent} is called by every
+ *    bespoke read handler before it does anything else.
+ */
+const zod_1 = require("zod");
+/** spec-004 §2.3's exact, verbatim write-refusal string. */
+exports.WRITE_REFUSAL_MESSAGE = 'resources are read-only';
+/**
+ * The `_meta` key WingFoil's own bespoke Resource handlers treat as "this `resources/read` call is
+ * carrying a write intent/payload" — not an MCP-defined field (see module doc). Any truthy value
+ * under this key refuses the read identically to an unsupported `resources/write` call.
+ */
+exports.WRITE_INTENT_META_KEY = 'wingfoil/write-intent';
+/**
+ * Refuse a read carrying a write intent (see module doc, case 2). Called first, before any other
+ * work, by every bespoke Resource handler this task registers — so the refusal is unconditional and
+ * precedes any read/scan/file-access, never a check bolted on after a read already started.
+ */
+function refuseIfWriteIntent(meta) {
+    if (meta && exports.WRITE_INTENT_META_KEY in meta) {
+        throw new Error(exports.WRITE_REFUSAL_MESSAGE);
+    }
+}
+/** spec-004 §2.2's "resource not found" shape — distinct wording from the write refusal above, per
+ * the BDD scenario (`P5.2.1-mcp-resources.feature`) `resource not found: {identifier}` format. */
+function resourceNotFoundError(identifier) {
+    return new Error(`resource not found: ${identifier}`);
+}
+/**
+ * The `ReadResourceResult` shape every JSON-bodied Resource in `memory-resource.ts` (collection
+ * listing), `dna-resource.ts`, and `workflow-resource.ts` returns — one `contents[]` entry,
+ * `mimeType: 'application/json'`, `value` serialized as its `text`. Factored here purely to avoid
+ * re-deriving the same three-line envelope at each of those five call sites; `memory-resource.ts`'s
+ * single-document read builds its own `text/markdown` + `metadata` result directly, since that shape
+ * differs (spec-004 §2.2).
+ */
+function jsonResourceResult(uri, value) {
+    return {
+        contents: [
+            {
+                uri: uri.toString(),
+                mimeType: 'application/json',
+                text: JSON.stringify(value),
+            },
+        ],
+    };
+}
+/** The raw JSON-RPC shape of an (unsupported) `resources/write` request — just enough to extract the
+ * method literal `setRequestHandler` needs; `params` is never inspected, since every call is refused
+ * unconditionally regardless of its payload. */
+const ResourcesWriteRequestSchema = zod_1.z.object({
+    method: zod_1.z.literal('resources/write'),
+    params: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});
+/**
+ * Install the `resources/write` refusal (see module doc, case 1). MCP's own protocol does not define
+ * `resources/write` at all — no client capability or built-in handler exists for it — so this method
+ * name has no default routing on the server; without this handler such a call would fail with a
+ * generic JSON-RPC "Method not found" rather than spec-004 §2.3's specific refusal text. There is no
+ * write path here to gate: the handler always throws, unconditionally.
+ */
+function registerWriteRefusalHandler(server) {
+    server.server.setRequestHandler(ResourcesWriteRequestSchema, async () => {
+        throw new Error(exports.WRITE_REFUSAL_MESSAGE);
+    });
+}
+//# sourceMappingURL=read-only.js.map

package/dist/mcp/read-only.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-only.js","sourceRoot":"","sources":["../../src/mcp/read-only.ts"],"names":[],"mappings":";;;AA0CA,kDAIC;AAID,sDAEC;AAUD,gDAUC;AAiBD,kEAIC;AA7FD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6BAAwB;AAIxB,4DAA4D;AAC/C,QAAA,qBAAqB,GAAG,yBAAyB,CAAC;AAE/D;;;;GAIG;AACU,QAAA,qBAAqB,GAAG,uBAAuB,CAAC;AAE7D;;;;GAIG;AACH,SAAgB,mBAAmB,CAAC,IAAyC;IAC3E,IAAI,IAAI,IAAI,6BAAqB,IAAI,IAAI,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CAAC,6BAAqB,CAAC,CAAC;IACzC,CAAC;AACH,CAAC;AAED;kGACkG;AAClG,SAAgB,qBAAqB,CAAC,UAAkB;IACtD,OAAO,IAAI,KAAK,CAAC,uBAAuB,UAAU,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAAC,GAAQ,EAAE,KAAc;IACzD,OAAO;QACL,QAAQ,EAAE;YACR;gBACE,GAAG,EAAE,GAAG,CAAC,QAAQ,EAAE;gBACnB,QAAQ,EAAE,kBAAkB;gBAC5B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;aAC5B;SACF;KACF,CAAC;AACJ,CAAC;AAED;;gDAEgD;AAChD,MAAM,2BAA2B,GAAG,OAAC,CAAC,MAAM,CAAC;IAC3C,MAAM,EAAE,OAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC;IACpC,MAAM,EAAE,OAAC,CAAC,MAAM,CAAC,OAAC,CAAC,MAAM,EAAE,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACrD,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,SAAgB,2BAA2B,CAAC,MAAiB;IAC3D,MAAM,CAAC,MAAM,CAAC,iBAAiB,CAAC,2BAA2B,EAAE,KAAK,IAAI,EAAE;QACtE,MAAM,IAAI,KAAK,CAAC,6BAAqB,CAAC,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC"}