labre-mcp 0.1.0

package/dist/core/transport/labre-stdio.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// Stdio transport entrypoint for labre-mcp (ARCH-14 companion).
+//
+// Speaks the MCP protocol over newline-delimited JSON-RPC 2.0 on
+// stdin/stdout, the transport Claude Code / the Agent SDK spawn directly
+// (`{ "command": "npx", "args": ["-y", "labre-mcp"] }`). It reuses the exact
+// same `dispatch` + four-tool registry as the HTTP daemon — only the framing
+// differs, so the surface is identical regardless of how the client connects.
+//
+// Protocol invariant: stdout carries ONLY MCP messages (responses + the
+// fire-and-forget notifications emitted by src/lib/mcp-notifications.mts).
+// Everything else — boot logs, health checks, stray console output — is routed
+// to stderr so it never corrupts the JSON-RPC stream.
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+import { dispatch } from "./mcp-handler.mjs";
+import { JsonRpcRequestSchema } from "./json-rpc.schema.mjs";
+import { extractContext } from "./context-extractor.mjs";
+import { noopAuthMiddleware } from "./auth-middleware.mjs";
+import { buildBootRegistry } from "./boot-tool-registry.mjs";
+import { buildStrategyRegistry } from "./strategy-registry-boot.mjs";
+import { registerBootHealthChecks } from "./boot-health-checks.mjs";
+import { runAllHealthChecks } from "#lib/degradation/index.mjs";
+/**
+ * Handle a single raw stdin line. Returns the JSON-RPC response to write back,
+ * or `null` for notifications (and blank lines) which produce no output.
+ * Parse/validation failures resolve to a JSON-RPC error envelope (id: null)
+ * rather than throwing, so the read loop never breaks on malformed input.
+ */
+export async function handleLine(line, deps) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let body;
+    try {
+        body = JSON.parse(trimmed);
+    }
+    catch {
+        return { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } };
+    }
+    const parsed = JsonRpcRequestSchema.safeParse(body);
+    if (!parsed.success) {
+        return {
+            jsonrpc: "2.0",
+            id: null,
+            error: { code: -32600, message: "Invalid Request", data: parsed.error.issues },
+        };
+    }
+    const auth = deps.auth ?? noopAuthMiddleware;
+    const context = await auth.authenticate({}, extractContext(parsed.data.params));
+    return dispatch({ request: parsed.data, context, tools: deps.tools });
+}
+function writeMessage(message) {
+    process.stdout.write(JSON.stringify(message) + "\n");
+}
+async function main() {
+    // Guard the protocol channel: redirect any stray console.* writes to stderr.
+    // Intentional protocol writes go through process.stdout.write directly
+    // (here and in mcp-notifications.mts) and are unaffected.
+    console.log = (...args) => process.stderr.write(args.map(String).join(" ") + "\n");
+    console.info = console.log;
+    console.debug = console.log;
+    const tools = buildBootRegistry();
+    const strategies = buildStrategyRegistry();
+    process.stderr.write(`[labre-mcp] stdio transport ready (newline-delimited JSON-RPC on stdin/stdout)\n`);
+    process.stderr.write(`[labre-mcp] Tools registered: ${tools.list().map((t) => t.name).join(", ") || "(none)"}\n`);
+    process.stderr.write(`[labre-mcp] Strategies registered: ${strategies.size()}\n`);
+    // Boot health checks (config/env presence only — no network). Never blocks boot.
+    registerBootHealthChecks();
+    const healthEvents = await runAllHealthChecks();
+    if (healthEvents.length === 0) {
+        process.stderr.write("[labre-mcp] Health checks: all dependencies ready\n");
+    }
+    else {
+        process.stderr.write(`[labre-mcp] Health checks — ${healthEvents.length} dependency(ies) degraded:\n${healthEvents
+            .map((e) => `  - ${e.source}: ${e.reason}`)
+            .join("\n")}\n`);
+    }
+    // Sequential read loop. `for await` awaits each dispatch before reading the
+    // next line, which both honours the V1 synchronous model (ARCH-11) and keeps
+    // stdout writes from interleaving across concurrent calls.
+    const rl = createInterface({ input: process.stdin });
+    for await (const line of rl) {
+        const response = await handleLine(line, { tools });
+        if (response !== null)
+            writeMessage(response);
+    }
+    // stdin closed (EOF) — the client disconnected. Exit cleanly.
+    process.exit(0);
+}
+// Only run when executed as a script (not when imported by tests).
+const isMain = process.argv[1] !== undefined && process.argv[1] === fileURLToPath(import.meta.url);
+if (isMain) {
+    main().catch((err) => {
+        process.stderr.write(`[labre-mcp] Fatal: ${err.message}\n`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=labre-stdio.mjs.map

package/dist/core/transport/labre-stdio.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"labre-stdio.mjs","sourceRoot":"","sources":["../../../src/core/transport/labre-stdio.mts"],"names":[],"mappings":";AACA,gEAAgE;AAChE,EAAE;AACF,iEAAiE;AACjE,yEAAyE;AACzE,6EAA6E;AAC7E,6EAA6E;AAC7E,8EAA8E;AAC9E,EAAE;AACF,wEAAwE;AACxE,2EAA2E;AAC3E,+EAA+E;AAC/E,sDAAsD;AAEtD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAqB,MAAM,mBAAmB,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAwB,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAuB,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAOhE;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC9B,IAAY,EACZ,IAAe;IAEf,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAE1B,IAAI,IAAa,CAAC;IAClB,IAAI,CAAC;QACH,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,EAAE,CAAC;IACvF,CAAC;IAED,MAAM,MAAM,GAAG,oBAAoB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACpD,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,EAAE,EAAE,IAAI;YACR,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE;SAC/E,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,kBAAkB,CAAC;IAC7C,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,EAAE,EAAE,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAChF,OAAO,QAAQ,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;AACxE,CAAC;AAED,SAAS,YAAY,CAAC,OAAwB;IAC5C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC;AACvD,CAAC;AAED,KAAK,UAAU,IAAI;IACjB,6EAA6E;IAC7E,uEAAuE;IACvE,0DAA0D;IAC1D,OAAO,CAAC,GAAG,GAAG,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC;IAC9F,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC;IAC3B,OAAO,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC;IAE5B,MAAM,KAAK,GAAG,iBAAiB,EAAE,CAAC;IAClC,MAAM,UAAU,GAAG,qBAAqB,EAAE,CAAC;IAE3C,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,kFAAkF,CACnF,CAAC;IACF,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,iCAAiC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,QAAQ,IAAI,CAC5F,CAAC;IACF,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,sCAAsC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAElF,iFAAiF;IACjF,wBAAwB,EAAE,CAAC;IAC3B,MAAM,YAAY,GAAG,MAAM,kBAAkB,EAAE,CAAC;IAChD,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,qDAAqD,CAAC,CAAC;IAC9E,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,+BAA+B,YAAY,CAAC,MAAM,+BAA+B,YAAY;aAC1F,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;aAC1C,IAAI,CAAC,IAAI,CAAC,IAAI,CAClB,CAAC;IACJ,CAAC;IAED,4EAA4E;IAC5E,6EAA6E;IAC7E,2DAA2D;IAC3D,MAAM,EAAE,GAAG,eAAe,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;IACrD,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,EAAE,EAAE,CAAC;QAC5B,MAAM,QAAQ,GAAG,MAAM,UAAU,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;QACnD,IAAI,QAAQ,KAAK,IAAI;YAAE,YAAY,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAED,8DAA8D;IAC9D,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,mEAAmE;AACnE,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACnG,IAAI,MAAM,EAAE,CAAC;IACX,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;QACnB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAuB,GAAa,CAAC,OAAO,IAAI,CAAC,CAAC;QACvE,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/core/transport/mcp-handler.d.mts

@@ -0,0 +1,21 @@
+import type { RequestContext } from "../context/request-context.mjs";
+import { type JsonRpcRequest, type JsonRpcResponse } from "./json-rpc.schema.mjs";
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler: (args: unknown, context: RequestContext) => Promise<unknown>;
+}
+export declare class ToolRegistry {
+    private readonly map;
+    register(tool: ToolDefinition): void;
+    list(): Array<Pick<ToolDefinition, "name" | "description" | "inputSchema">>;
+    get(name: string): ToolDefinition | undefined;
+}
+export interface DispatchOptions {
+    request: JsonRpcRequest;
+    context: RequestContext;
+    tools: ToolRegistry;
+}
+export declare function dispatch(options: DispatchOptions): Promise<JsonRpcResponse | null>;
+//# sourceMappingURL=mcp-handler.d.mts.map

package/dist/core/transport/mcp-handler.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-handler.d.mts","sourceRoot":"","sources":["../../../src/core/transport/mcp-handler.mts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAoB,MAAM,uBAAuB,CAAC;AAGpG,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IAEpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACvE;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqC;IAEzD,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI;IAOpC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC;IAQ3E,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS;CAG9C;AAgBD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,cAAc,CAAC;IACxB,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAkDxF"}

package/dist/core/transport/mcp-handler.mjs

@@ -0,0 +1,95 @@
+// MCP method dispatcher. Maps incoming JSON-RPC method names to handlers:
+//   initialize → server info + capabilities
+//   ping → empty success
+//   notifications/initialized → no-op (one-way)
+//   tools/list → list of registered tools
+//   tools/call → invoke a tool by name
+//
+// Tool registration is decoupled from this module: a ToolRegistry is passed
+// in. Concrete tools (estimateEvolution, evaluateMap, etc.) register
+// themselves at boot. CP4-CP6 will migrate the existing 5 tools to this
+// registry; CP3 ships with the registry empty (or holding only smoke tools).
+import { JsonRpcErrorCode } from "./json-rpc.schema.mjs";
+import { withMcpDegradation } from "#lib/degradation/index.mjs";
+export class ToolRegistry {
+    map = new Map();
+    register(tool) {
+        if (this.map.has(tool.name)) {
+            throw new Error(`Tool "${tool.name}" already registered`);
+        }
+        this.map.set(tool.name, tool);
+    }
+    list() {
+        return [...this.map.values()].map(({ name, description, inputSchema }) => ({
+            name,
+            description,
+            inputSchema,
+        }));
+    }
+    get(name) {
+        return this.map.get(name);
+    }
+}
+const SERVER_INFO = {
+    name: "labre-mcp",
+    version: "1.0.0-migration",
+};
+const SERVER_CAPABILITIES = {
+    tools: {},
+    // The daemon emits MCP log notifications (`notifications/message`) and the
+    // Claude Code chat channel (`notifications/claude/channel`) — see
+    // src/lib/mcp-notifications.mts. Declare them so strict clients process them.
+    logging: {},
+    experimental: { "claude/channel": {} },
+};
+export async function dispatch(options) {
+    const { request, context, tools } = options;
+    const id = request.id ?? null;
+    // Notifications (no id) — one-way, no response.
+    if (request.method.startsWith("notifications/")) {
+        return null;
+    }
+    try {
+        switch (request.method) {
+            case "initialize":
+                return success(id, {
+                    protocolVersion: "2024-11-05",
+                    serverInfo: SERVER_INFO,
+                    capabilities: SERVER_CAPABILITIES,
+                });
+            case "ping":
+                return success(id, {});
+            case "tools/list":
+                return success(id, { tools: tools.list() });
+            case "tools/call": {
+                // any: params validated below
+                const params = request.params ?? {};
+                if (!params.name || typeof params.name !== "string") {
+                    return error(id, JsonRpcErrorCode.InvalidParams, "tools/call requires a 'name' string parameter");
+                }
+                const tool = tools.get(params.name);
+                if (!tool) {
+                    return error(id, JsonRpcErrorCode.MethodNotFound, `Unknown tool: ${params.name}`);
+                }
+                // ARCH-22 / hard rule #18: every tool handler is wrapped here, once,
+                // so each tools/call response is a Degradable<T> envelope and any
+                // tryDegradeAmbient deep in the call tree records into the ambient
+                // collector (AsyncLocalStorage). Handlers must NOT self-wrap.
+                const degradable = await withMcpDegradation(params.name, () => tool.handler(params.arguments ?? {}, context));
+                return success(id, degradable);
+            }
+            default:
+                return error(id, JsonRpcErrorCode.MethodNotFound, `Method not found: ${request.method}`);
+        }
+    }
+    catch (err) {
+        return error(id, JsonRpcErrorCode.InternalError, err.message ?? String(err));
+    }
+}
+function success(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+function error(id, code, message, data) {
+    return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+//# sourceMappingURL=mcp-handler.mjs.map

package/dist/core/transport/mcp-handler.mjs.map

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

package/dist/core/transport/strategy-registry-boot.d.mts

@@ -0,0 +1,15 @@
+import { StrategyRegistry } from "../registry/strategy-registry.mjs";
+import type { BaseStrategy } from "../ast/base-strategy.mjs";
+/**
+ * Build the strategy registry by importing every framework's register
+ * function. Each framework module side-effects-imports its strategy
+ * classes at load time; the register function wires them into the shared
+ * registry. Idempotent (throws on duplicate methodId — catches accidental
+ * double-boot).
+ *
+ * Mocks (CP10) scaffold the rest of the v0.1.0 catalogue. Set
+ * `LABRE_DISABLE_MOCKS=1` to skip — useful for prod runs where only real
+ * strategies should be exposed.
+ */
+export declare function buildStrategyRegistry(): StrategyRegistry<BaseStrategy>;
+//# sourceMappingURL=strategy-registry-boot.d.mts.map

package/dist/core/transport/strategy-registry-boot.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-registry-boot.d.mts","sourceRoot":"","sources":["../../../src/core/transport/strategy-registry-boot.mts"],"names":[],"mappings":"AAWA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAO7D;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,IAAI,gBAAgB,CAAC,YAAY,CAAC,CAUtE"}

package/dist/core/transport/strategy-registry-boot.mjs

@@ -0,0 +1,39 @@
+// Strategy registry boot wiring.
+//
+// Extracted from labre-daemon.mts to break the circular dependency that
+// used to form when the recipe runner (loaded via the MCP tool handler in
+// estimate-evolution-via-recipe.mts) reached back into the daemon to grab
+// `buildStrategyRegistry`. Both the daemon and the recipe handler now
+// depend on this leaf module instead.
+//
+// Side-effects-imports every framework's register function so adding a
+// new framework only means appending one import + one call below.
+import { StrategyRegistry } from "../registry/strategy-registry.mjs";
+import { registerEvolutionStrategies } from "#frameworks/wardley/evolution/registry.mjs";
+import { registerChainStrategies } from "#frameworks/wardley/chain/registry.mjs";
+import { registerCommonStrategies } from "#frameworks/common/registry.mjs";
+import { registerRenderStrategies } from "#frameworks/render/registry.mjs";
+import { registerMocks } from "#frameworks/mocks-registry.mjs";
+/**
+ * Build the strategy registry by importing every framework's register
+ * function. Each framework module side-effects-imports its strategy
+ * classes at load time; the register function wires them into the shared
+ * registry. Idempotent (throws on duplicate methodId — catches accidental
+ * double-boot).
+ *
+ * Mocks (CP10) scaffold the rest of the v0.1.0 catalogue. Set
+ * `LABRE_DISABLE_MOCKS=1` to skip — useful for prod runs where only real
+ * strategies should be exposed.
+ */
+export function buildStrategyRegistry() {
+    const registry = new StrategyRegistry();
+    registerEvolutionStrategies(registry);
+    registerChainStrategies(registry);
+    registerCommonStrategies(registry);
+    registerRenderStrategies(registry);
+    if (process.env.LABRE_DISABLE_MOCKS !== "1") {
+        registerMocks(registry);
+    }
+    return registry;
+}
+//# sourceMappingURL=strategy-registry-boot.mjs.map

package/dist/core/transport/strategy-registry-boot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy-registry-boot.mjs","sourceRoot":"","sources":["../../../src/core/transport/strategy-registry-boot.mts"],"names":[],"mappings":"AAAA,iCAAiC;AACjC,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,0EAA0E;AAC1E,sEAAsE;AACtE,sCAAsC;AACtC,EAAE;AACF,uEAAuE;AACvE,kEAAkE;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAErE,OAAO,EAAE,2BAA2B,EAAE,MAAM,4CAA4C,CAAC;AACzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,MAAM,UAAU,qBAAqB;IACnC,MAAM,QAAQ,GAAG,IAAI,gBAAgB,EAAgB,CAAC;IACtD,2BAA2B,CAAC,QAAQ,CAAC,CAAC;IACtC,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAClC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IACnC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IACnC,IAAI,OAAO,CAAC,GAAG,CAAC,mBAAmB,KAAK,GAAG,EAAE,CAAC;QAC5C,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC1B,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/frameworks/common/layout/quality/overlap-check-strategy.d.mts

@@ -0,0 +1,16 @@
+import { BaseStrategy as CoreBaseStrategy, type StrategyResult } from '#core/ast/base-strategy.mjs';
+import type { RequestContext } from '#core/context/request-context.mjs';
+import { type WardleyMap } from '#schemas/wardley-map.schema.mjs';
+export interface OverlapCheckResult {
+    map: WardleyMap;
+    unresolvedHard: number;
+    unresolvedSpacing: number;
+    unresolvedEdge: number;
+    unresolvedAxis: number;
+    iterations: number;
+}
+export declare class OverlapCheckStrategy extends CoreBaseStrategy<unknown, OverlapCheckResult | null> {
+    static get method(): string;
+    evaluate(input: unknown, _context: RequestContext): Promise<StrategyResult<OverlapCheckResult | null>>;
+}
+//# sourceMappingURL=overlap-check-strategy.d.mts.map

package/dist/frameworks/common/layout/quality/overlap-check-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap-check-strategy.d.mts","sourceRoot":"","sources":["../../../../../src/frameworks/common/layout/quality/overlap-check-strategy.mts"],"names":[],"mappings":"AAYA,OAAO,EACL,YAAY,IAAI,gBAAgB,EAChC,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAYpF,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,UAAU,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,oBAAqB,SAAQ,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAC5F,MAAM,KAAK,MAAM,IAAI,MAAM,CAE1B;IAEK,QAAQ,CACZ,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,cAAc,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;CAmDtD"}

package/dist/frameworks/common/layout/quality/overlap-check-strategy.mjs

@@ -0,0 +1,71 @@
+// Wardley map value-chain overlap audit strategy.
+//
+// Wraps the `verifyLayout` pipeline (force-directed labels + component nudge
+// + canonical snap + strict projection) and surfaces residual overlap counts
+// under the methodId `wardley:map:value-chain:audit:overlap-check`
+// (ast-schema.md v0.1.0). Typically attached as a listener of
+// `wardley:map:value-chain:prevent-collision:default` to flag any residual
+// overlaps that the placement pass could not resolve.
+//
+// The algorithm is geometry-only and framework-agnostic; file location
+// preserved for this checkpoint, physical relocation deferred.
+import { BaseStrategy as CoreBaseStrategy, } from '#core/ast/base-strategy.mjs';
+import { WardleyMapSchema } from '#schemas/wardley-map.schema.mjs';
+import { fromPositionedValueChain, toPositionedValueChain, } from '#frameworks/render/wardley-map/acl/value-chain.mjs';
+import { verifyLayout, } from '#frameworks/wardley/chain/_legacy/write/chain/lib/layout/verify-layout.mjs';
+const NEW_METHOD_ID_OVERLAP_CHECK = 'wardley:map:value-chain:audit:overlap-check';
+export class OverlapCheckStrategy extends CoreBaseStrategy {
+    static get method() {
+        return NEW_METHOD_ID_OVERLAP_CHECK;
+    }
+    async evaluate(input, _context) {
+        const capturedAt = new Date().toISOString();
+        const parsed = WardleyMapSchema.safeParse(input);
+        if (!parsed.success) {
+            return {
+                signals: [{ name: 'input-valid', value: false, source: 'computed', capturedAt }],
+                reasoning: [],
+                insights: [
+                    { text: 'overlap-check skipped: input is not a canonical WardleyMap', by: NEW_METHOD_ID_OVERLAP_CHECK, type: 'other' },
+                ],
+                result: null,
+            };
+        }
+        // Overlap geometry is orientation-invariant, so the ACL round-trip (which
+        // flips visibility) does not affect the residual counts.
+        const { chain, report } = verifyLayout(toPositionedValueChain(parsed.data), {});
+        const totals = report;
+        const totalSoft = totals.unresolvedSpacing + totals.unresolvedEdge + totals.unresolvedAxis;
+        const insights = totals.unresolvedHard > 0
+            ? [{
+                    text: `Hard overlap residuals: ${totals.unresolvedHard} (post-projection — indicates a geometry corner case).`,
+                    by: NEW_METHOD_ID_OVERLAP_CHECK,
+                    type: 'other',
+                }]
+            : totalSoft > 0
+                ? [{
+                        text: `Soft overlap residuals: spacing=${totals.unresolvedSpacing}, edge=${totals.unresolvedEdge}, axis=${totals.unresolvedAxis}.`,
+                        by: NEW_METHOD_ID_OVERLAP_CHECK,
+                        type: 'other',
+                    }]
+                : [];
+        return {
+            signals: [
+                { name: 'componentCount', value: parsed.data.components.length, source: 'computed', capturedAt },
+                { name: 'iterations', value: report.iterations, source: 'computed', capturedAt },
+                { name: 'unresolvedHard', value: report.unresolvedHard, source: 'computed', capturedAt },
+            ],
+            reasoning: [],
+            insights,
+            result: {
+                map: fromPositionedValueChain(chain),
+                unresolvedHard: report.unresolvedHard,
+                unresolvedSpacing: report.unresolvedSpacing,
+                unresolvedEdge: report.unresolvedEdge,
+                unresolvedAxis: report.unresolvedAxis,
+                iterations: report.iterations,
+            },
+        };
+    }
+}
+//# sourceMappingURL=overlap-check-strategy.mjs.map

package/dist/frameworks/common/layout/quality/overlap-check-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap-check-strategy.mjs","sourceRoot":"","sources":["../../../../../src/frameworks/common/layout/quality/overlap-check-strategy.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/common/layout/write/place-labels-strategy.d.mts

@@ -0,0 +1,8 @@
+import { BaseStrategy as CoreBaseStrategy, type StrategyResult } from '#core/ast/base-strategy.mjs';
+import type { RequestContext } from '#core/context/request-context.mjs';
+import { type WardleyMap } from '#schemas/wardley-map.schema.mjs';
+export declare class PlaceLabelsStrategy extends CoreBaseStrategy<unknown, WardleyMap> {
+    static get method(): string;
+    evaluate(input: unknown, _context: RequestContext): Promise<StrategyResult<WardleyMap>>;
+}
+//# sourceMappingURL=place-labels-strategy.d.mts.map

package/dist/frameworks/common/layout/write/place-labels-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-labels-strategy.d.mts","sourceRoot":"","sources":["../../../../../src/frameworks/common/layout/write/place-labels-strategy.mts"],"names":[],"mappings":"AAgBA,OAAO,EACL,YAAY,IAAI,gBAAgB,EAChC,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAKpF,qBAAa,mBAAoB,SAAQ,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC;IAC5E,MAAM,KAAK,MAAM,IAAI,MAAM,CAE1B;IAEK,QAAQ,CACZ,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;CAsCvC"}

package/dist/frameworks/common/layout/write/place-labels-strategy.mjs

@@ -0,0 +1,60 @@
+// Wardley map value-chain label de-collision step
+// `wardley:map:value-chain:prevent-collision:default` (ast-schema.md v0.1.0).
+//
+// BLIND by design: this strategy owns no pixel geometry. Label placement needs
+// font metrics and the canvas size, which are the render command's concern, not
+// a layout strategy's. Its single job is to UN-PIN every label (drop any
+// `label.position`): a label that carries a position is treated as "pinned" and
+// is skipped by the renderer's collision avoidance. Un-pinning hands placement
+// to the render command (`render:wardley-map:image:emit:svg`), which turns its
+// own multi-directional avoidance on and positions each label (right / left /
+// top / bottom) while pushing apart residual overlaps — the natural look.
+//
+// The upstream depth-band layout (organized-y-position) already guarantees nodes
+// never overlap, which gives the renderer's avoidance room to keep every label
+// readable and close to its node. Pure WardleyMap → WardleyMap.
+import { BaseStrategy as CoreBaseStrategy, } from '#core/ast/base-strategy.mjs';
+import { WardleyMapSchema } from '#schemas/wardley-map.schema.mjs';
+import { readRenderConfig, withoutRenderConfig } from '#schemas/render-config-passthrough.mjs';
+const NEW_METHOD_ID_PLACE_LABELS = 'wardley:map:value-chain:prevent-collision:default';
+export class PlaceLabelsStrategy extends CoreBaseStrategy {
+    static get method() {
+        return NEW_METHOD_ID_PLACE_LABELS;
+    }
+    async evaluate(input, _context) {
+        const capturedAt = new Date().toISOString();
+        // Preserve the upstream view config (input shape) untouched across this step.
+        const view = readRenderConfig(input);
+        const parsed = WardleyMapSchema.safeParse(withoutRenderConfig(input));
+        if (!parsed.success) {
+            return {
+                signals: [{ name: 'input-valid', value: false, source: 'computed', capturedAt }],
+                reasoning: [],
+                insights: [
+                    { text: 'cannot configure labels: input is not a canonical WardleyMap', by: NEW_METHOD_ID_PLACE_LABELS, type: 'other' },
+                ],
+                result: WardleyMapSchema.parse({ title: 'Untitled map', components: [], relations: [] }),
+            };
+        }
+        const map = parsed.data;
+        const laid = WardleyMapSchema.parse({
+            ...map,
+            // Un-pin labels so the renderer is free to reposition them. A label with a
+            // `position` is treated as pinned and skipped by the renderer's avoidance.
+            components: map.components.map((c) => ({ ...c, label: { name: c.label.name } })),
+        });
+        const result = (view ? { ...laid, renderConfig: view } : laid);
+        return {
+            signals: [
+                { name: 'componentCount', value: map.components.length, source: 'computed', capturedAt },
+                { name: 'labelsUnpinned', value: true, source: 'computed', capturedAt },
+            ],
+            reasoning: [],
+            insights: [
+                { text: 'labels un-pinned — placement delegated to the render command (avoidCollisions)', by: NEW_METHOD_ID_PLACE_LABELS, type: 'other' },
+            ],
+            result,
+        };
+    }
+}
+//# sourceMappingURL=place-labels-strategy.mjs.map

package/dist/frameworks/common/layout/write/place-labels-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-labels-strategy.mjs","sourceRoot":"","sources":["../../../../../src/frameworks/common/layout/write/place-labels-strategy.mts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,8EAA8E;AAC9E,EAAE;AACF,+EAA+E;AAC/E,gFAAgF;AAChF,yEAAyE;AACzE,gFAAgF;AAChF,+EAA+E;AAC/E,+EAA+E;AAC/E,8EAA8E;AAC9E,0EAA0E;AAC1E,EAAE;AACF,iFAAiF;AACjF,+EAA+E;AAC/E,gEAAgE;AAEhE,OAAO,EACL,YAAY,IAAI,gBAAgB,GAEjC,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,gBAAgB,EAAmB,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAE/F,MAAM,0BAA0B,GAAG,mDAAmD,CAAC;AAEvF,MAAM,OAAO,mBAAoB,SAAQ,gBAAqC;IAC5E,MAAM,KAAK,MAAM;QACf,OAAO,0BAA0B,CAAC;IACpC,CAAC;IAED,KAAK,CAAC,QAAQ,CACZ,KAAc,EACd,QAAwB;QAExB,MAAM,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAE5C,8EAA8E;QAC9E,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QACrC,MAAM,MAAM,GAAG,gBAAgB,CAAC,SAAS,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;gBAChF,SAAS,EAAE,EAAE;gBACb,QAAQ,EAAE;oBACR,EAAE,IAAI,EAAE,8DAA8D,EAAE,EAAE,EAAE,0BAA0B,EAAE,IAAI,EAAE,OAAO,EAAE;iBACxH;gBACD,MAAM,EAAE,gBAAgB,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;aACzF,CAAC;QACJ,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC;QAExB,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC;YAClC,GAAG,GAAG;YACN,2EAA2E;YAC3E,2EAA2E;YAC3E,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;SACjF,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAe,CAAC;QAE7E,OAAO;YACL,OAAO,EAAE;gBACP,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE;gBACxF,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE;aACxE;YACD,SAAS,EAAE,EAAE;YACb,QAAQ,EAAE;gBACR,EAAE,IAAI,EAAE,gFAAgF,EAAE,EAAE,EAAE,0BAA0B,EAAE,IAAI,EAAE,OAAO,EAAE;aAC1I;YACD,MAAM;SACP,CAAC;IACJ,CAAC;CACF"}

package/dist/frameworks/common/registry.d.mts

@@ -0,0 +1,7 @@
+import type { StrategyRegistry } from '#core/registry/strategy-registry.mjs';
+import type { BaseStrategy } from '#core/ast/base-strategy.mjs';
+/**
+ * Register every common-namespace strategy on the provided core registry.
+ */
+export declare function registerCommonStrategies(registry: StrategyRegistry<BaseStrategy>): void;
+//# sourceMappingURL=registry.d.mts.map

package/dist/frameworks/common/registry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.mts","sourceRoot":"","sources":["../../../src/frameworks/common/registry.mts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,gBAAgB,CAAC,YAAY,CAAC,GACvC,IAAI,CAGN"}

package/dist/frameworks/common/registry.mjs

@@ -0,0 +1,15 @@
+// Framework registry for cross-framework `common:` strategies (ARCH-25).
+//
+// At daemon boot, `labre-daemon.mts` calls `registerCommonStrategies(coreRegistry)`
+// to populate the shared `StrategyRegistry` with strategies that are
+// framework-agnostic by design (e.g. 2D layout primitives).
+import { PlaceLabelsStrategy } from './layout/write/place-labels-strategy.mjs';
+import { OverlapCheckStrategy } from './layout/quality/overlap-check-strategy.mjs';
+/**
+ * Register every common-namespace strategy on the provided core registry.
+ */
+export function registerCommonStrategies(registry) {
+    registry.register(PlaceLabelsStrategy.method, PlaceLabelsStrategy);
+    registry.register(OverlapCheckStrategy.method, OverlapCheckStrategy);
+}
+//# sourceMappingURL=registry.mjs.map

package/dist/frameworks/common/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.mjs","sourceRoot":"","sources":["../../../src/frameworks/common/registry.mts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,EAAE;AACF,oFAAoF;AACpF,qEAAqE;AACrE,4DAA4D;AAK5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAEnF;;GAEG;AACH,MAAM,UAAU,wBAAwB,CACtC,QAAwC;IAExC,QAAQ,CAAC,QAAQ,CAAC,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACnE,QAAQ,CAAC,QAAQ,CAAC,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AACvE,CAAC"}

package/dist/frameworks/common/toolbox/list/emit/default.mock-strategy.d.mts

@@ -0,0 +1,15 @@
+import { BaseStrategy as CoreBaseStrategy, type StrategyResult } from '#core/ast/base-strategy.mjs';
+import type { RequestContext } from '#core/context/request-context.mjs';
+export interface CommonToolboxListEmitDefaultInput {
+    [key: string]: unknown;
+}
+export interface CommonToolboxListEmitDefaultResult {
+    mock: true;
+    methodId: string;
+    [key: string]: unknown;
+}
+export declare class MockCommonToolboxListEmitDefaultStrategy extends CoreBaseStrategy<CommonToolboxListEmitDefaultInput, CommonToolboxListEmitDefaultResult> {
+    static get method(): string;
+    evaluate(_input: CommonToolboxListEmitDefaultInput, _context: RequestContext): Promise<StrategyResult<CommonToolboxListEmitDefaultResult>>;
+}
+//# sourceMappingURL=default.mock-strategy.d.mts.map

package/dist/frameworks/common/toolbox/list/emit/default.mock-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.mock-strategy.d.mts","sourceRoot":"","sources":["../../../../../../src/frameworks/common/toolbox/list/emit/default.mock-strategy.mts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,IAAI,gBAAgB,EAChC,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAIxE,MAAM,WAAW,iCAAiC;IAGhD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,kCAAkC;IACjD,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IAEjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,qBAAa,wCAAyC,SAAQ,gBAAgB,CAAC,iCAAiC,EAAE,kCAAkC,CAAC;IACnJ,MAAM,KAAK,MAAM,IAAI,MAAM,CAAsB;IAE3C,QAAQ,CACZ,MAAM,EAAE,iCAAiC,EACzC,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,cAAc,CAAC,kCAAkC,CAAC,CAAC;CAS/D"}

package/dist/frameworks/common/toolbox/list/emit/default.mock-strategy.mjs

@@ -0,0 +1,21 @@
+// Mock strategy for `common:toolbox:list:emit:default` (ast-schema.md v0.1.0 § 3.4 — status: "mock").
+//
+// Returns deterministic test data so recipes that depend on this command
+// can run end-to-end without a real implementation. The Input/Result
+// shapes declared here are the I/O contract a future real strategy must
+// honour when it replaces this mock.
+import { BaseStrategy as CoreBaseStrategy, } from '#core/ast/base-strategy.mjs';
+const METHOD_ID = 'common:toolbox:list:emit:default';
+export class MockCommonToolboxListEmitDefaultStrategy extends CoreBaseStrategy {
+    static get method() { return METHOD_ID; }
+    async evaluate(_input, _context) {
+        const capturedAt = new Date().toISOString();
+        return {
+            signals: [{ name: 'mock', value: true, source: 'computed', capturedAt }],
+            reasoning: [],
+            insights: [{ text: `mock strategy for ${METHOD_ID}`, by: METHOD_ID, type: 'other' }],
+            result: { mock: true, methodId: METHOD_ID },
+        };
+    }
+}
+//# sourceMappingURL=default.mock-strategy.mjs.map

package/dist/frameworks/common/toolbox/list/emit/default.mock-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.mock-strategy.mjs","sourceRoot":"","sources":["../../../../../../src/frameworks/common/toolbox/list/emit/default.mock-strategy.mts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,EAAE;AACF,yEAAyE;AACzE,qEAAqE;AACrE,wEAAwE;AACxE,qCAAqC;AAErC,OAAO,EACL,YAAY,IAAI,gBAAgB,GAEjC,MAAM,6BAA6B,CAAC;AAGrC,MAAM,SAAS,GAAG,kCAAkC,CAAC;AAerD,MAAM,OAAO,wCAAyC,SAAQ,gBAAuF;IACnJ,MAAM,KAAK,MAAM,KAAa,OAAO,SAAS,CAAC,CAAC,CAAC;IAEjD,KAAK,CAAC,QAAQ,CACZ,MAAyC,EACzC,QAAwB;QAExB,MAAM,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC5C,OAAO;YACL,OAAO,EAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;YAC1E,SAAS,EAAE,EAAE;YACb,QAAQ,EAAG,CAAC,EAAE,IAAI,EAAE,qBAAqB,SAAS,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;YACrF,MAAM,EAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE;SAC/C,CAAC;IACJ,CAAC;CACF"}

package/dist/frameworks/common/toolbox/wardley/json-boilerplate/default.mock-strategy.d.mts

@@ -0,0 +1,15 @@
+import { BaseStrategy as CoreBaseStrategy, type StrategyResult } from '#core/ast/base-strategy.mjs';
+import type { RequestContext } from '#core/context/request-context.mjs';
+export interface CommonToolboxWardleyJsonBoilerplateDefaultInput {
+    [key: string]: unknown;
+}
+export interface CommonToolboxWardleyJsonBoilerplateDefaultResult {
+    mock: true;
+    methodId: string;
+    [key: string]: unknown;
+}
+export declare class MockCommonToolboxWardleyJsonBoilerplateDefaultStrategy extends CoreBaseStrategy<CommonToolboxWardleyJsonBoilerplateDefaultInput, CommonToolboxWardleyJsonBoilerplateDefaultResult> {
+    static get method(): string;
+    evaluate(_input: CommonToolboxWardleyJsonBoilerplateDefaultInput, _context: RequestContext): Promise<StrategyResult<CommonToolboxWardleyJsonBoilerplateDefaultResult>>;
+}
+//# sourceMappingURL=default.mock-strategy.d.mts.map

package/dist/frameworks/common/toolbox/wardley/json-boilerplate/default.mock-strategy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.mock-strategy.d.mts","sourceRoot":"","sources":["../../../../../../src/frameworks/common/toolbox/wardley/json-boilerplate/default.mock-strategy.mts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,IAAI,gBAAgB,EAChC,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAIxE,MAAM,WAAW,+CAA+C;IAG9D,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,gDAAgD;IAC/D,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IAEjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,qBAAa,sDAAuD,SAAQ,gBAAgB,CAAC,+CAA+C,EAAE,gDAAgD,CAAC;IAC7L,MAAM,KAAK,MAAM,IAAI,MAAM,CAAsB;IAE3C,QAAQ,CACZ,MAAM,EAAE,+CAA+C,EACvD,QAAQ,EAAE,cAAc,GACvB,OAAO,CAAC,cAAc,CAAC,gDAAgD,CAAC,CAAC;CAS7E"}

package/dist/frameworks/common/toolbox/wardley/json-boilerplate/default.mock-strategy.mjs

@@ -0,0 +1,21 @@
+// Mock strategy for `common:toolbox:wardley:json-boilerplate:default` (ast-schema.md v0.1.0 § 3.4 — status: "mock").
+//
+// Returns deterministic test data so recipes that depend on this command
+// can run end-to-end without a real implementation. The Input/Result
+// shapes declared here are the I/O contract a future real strategy must
+// honour when it replaces this mock.
+import { BaseStrategy as CoreBaseStrategy, } from '#core/ast/base-strategy.mjs';
+const METHOD_ID = 'common:toolbox:wardley:json-boilerplate:default';
+export class MockCommonToolboxWardleyJsonBoilerplateDefaultStrategy extends CoreBaseStrategy {
+    static get method() { return METHOD_ID; }
+    async evaluate(_input, _context) {
+        const capturedAt = new Date().toISOString();
+        return {
+            signals: [{ name: 'mock', value: true, source: 'computed', capturedAt }],
+            reasoning: [],
+            insights: [{ text: `mock strategy for ${METHOD_ID}`, by: METHOD_ID, type: 'other' }],
+            result: { mock: true, methodId: METHOD_ID },
+        };
+    }
+}
+//# sourceMappingURL=default.mock-strategy.mjs.map

package/dist/frameworks/common/toolbox/wardley/json-boilerplate/default.mock-strategy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.mock-strategy.mjs","sourceRoot":"","sources":["../../../../../../src/frameworks/common/toolbox/wardley/json-boilerplate/default.mock-strategy.mts"],"names":[],"mappings":"AAAA,qHAAqH;AACrH,EAAE;AACF,yEAAyE;AACzE,qEAAqE;AACrE,wEAAwE;AACxE,qCAAqC;AAErC,OAAO,EACL,YAAY,IAAI,gBAAgB,GAEjC,MAAM,6BAA6B,CAAC;AAGrC,MAAM,SAAS,GAAG,iDAAiD,CAAC;AAepE,MAAM,OAAO,sDAAuD,SAAQ,gBAAmH;IAC7L,MAAM,KAAK,MAAM,KAAa,OAAO,SAAS,CAAC,CAAC,CAAC;IAEjD,KAAK,CAAC,QAAQ,CACZ,MAAuD,EACvD,QAAwB;QAExB,MAAM,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAC5C,OAAO;YACL,OAAO,EAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;YAC1E,SAAS,EAAE,EAAE;YACb,QAAQ,EAAG,CAAC,EAAE,IAAI,EAAE,qBAAqB,SAAS,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;YACrF,MAAM,EAAK,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE;SAC/C,CAAC;IACJ,CAAC;CACF"}

package/dist/frameworks/mocks-registry.d.mts

@@ -0,0 +1,4 @@
+import type { StrategyRegistry } from '#core/registry/strategy-registry.mjs';
+import type { BaseStrategy } from '#core/ast/base-strategy.mjs';
+export declare function registerMocks(registry: StrategyRegistry<BaseStrategy>): void;
+//# sourceMappingURL=mocks-registry.d.mts.map