labre-mcp 0.1.0

package/dist/mcp/estimate-anchor-evolution.tool.mjs

@@ -0,0 +1,22 @@
+// MCP tool wrapper for estimateAnchorEvolution.
+//
+// Estimates the evolution position of an anchor (user need / stakeholder)
+// through the consumption culture lens (user perception + industry perception).
+import { z } from 'zod';
+import { EstimateAnchorEvolutionInputSchema } from '../schemas/estimate-anchor-evolution.schema.mjs';
+import { getStrategyLLM } from '../lib/llm/registry.mjs';
+import { estimateAnchorEvolution } from '#work-on-evolution/write/strategies/anchor/estimate-anchor-evolution.mjs';
+export const ESTIMATE_ANCHOR_EVOLUTION_TOOL = {
+    name: 'estimateAnchorEvolution',
+    description: 'Estimate the evolution position of an anchor (user need / stakeholder) in a Wardley Map. ' +
+        'Unlike components evaluated by technical maturity, anchors are evaluated through ' +
+        'the consumption culture lens (user perception + industry perception). ' +
+        'The LLM determines a single evolution phase (1–4, Genesis → Commodity). ' +
+        'A phase can be provided directly to skip LLM assessment.',
+    inputSchema: z.toJSONSchema(EstimateAnchorEvolutionInputSchema, { io: 'input' }),
+};
+export async function handleEstimateAnchorEvolution(args) {
+    const input = EstimateAnchorEvolutionInputSchema.parse(args);
+    return estimateAnchorEvolution(input, getStrategyLLM('anchor-evolution'));
+}
+//# sourceMappingURL=estimate-anchor-evolution.tool.mjs.map

package/dist/mcp/estimate-anchor-evolution.tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate-anchor-evolution.tool.mjs","sourceRoot":"","sources":["../../src/mcp/estimate-anchor-evolution.tool.mts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,EAAE;AACF,0EAA0E;AAC1E,gFAAgF;AAEhF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,kCAAkC,EAAqC,MAAM,iDAAiD,CAAC;AACxI,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0EAA0E,CAAC;AAEnH,MAAM,CAAC,MAAM,8BAA8B,GAAsB;IAC/D,IAAI,EAAE,yBAAyB;IAC/B,WAAW,EACT,2FAA2F;QAC3F,mFAAmF;QACnF,wEAAwE;QACxE,0EAA0E;QAC1E,0DAA0D;IAC5D,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,kCAAkC,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAe;CAC/F,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,6BAA6B,CAAC,IAA6B;IAC/E,MAAM,KAAK,GAAiC,kCAAkC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC3F,OAAO,uBAAuB,CAAC,KAAK,EAAE,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC;AAC5E,CAAC"}

package/dist/mcp/estimate-evolution-via-recipe.d.mts

@@ -0,0 +1,14 @@
+export interface EstimateEvolutionViaRecipeResult {
+    recipeRunId: string;
+    ast: Record<string, unknown>;
+    artifactPath: string | null;
+    events: unknown[];
+    envelope: import('#core/recipe/recipe-runner.mjs').JsonLabreEnvelope;
+}
+/**
+ * Recipe-based handler. Equivalent to `handleEstimateEvolution` but
+ * dispatched through the kernel. The `_context` field in args (if present)
+ * is parsed as a RequestContext; otherwise a fresh context is synthesised.
+ */
+export declare function handleEstimateEvolutionViaRecipe(rawInput: Record<string, unknown>): Promise<EstimateEvolutionViaRecipeResult>;
+//# sourceMappingURL=estimate-evolution-via-recipe.d.mts.map

package/dist/mcp/estimate-evolution-via-recipe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate-evolution-via-recipe.d.mts","sourceRoot":"","sources":["../../src/mcp/estimate-evolution-via-recipe.mts"],"names":[],"mappings":"AA2BA,MAAM,WAAW,gCAAgC;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,QAAQ,EAAE,OAAO,gCAAgC,EAAE,iBAAiB,CAAC;CACtE;AAED;;;;GAIG;AACH,wBAAsB,gCAAgC,CACpD,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,gCAAgC,CAAC,CA0C3C"}

package/dist/mcp/estimate-evolution-via-recipe.mjs

@@ -0,0 +1,67 @@
+// MCP handler that invokes `estimateEvolution` via the kernel recipe
+// runner instead of the legacy dispatcher.
+//
+// Flow:
+//   1. Validate the MCP arguments (same schema as the legacy handler).
+//   2. Build a RequestContext (ARCH-15) — uses caller-supplied _context when
+//      present, falls back to dev-mode defaults otherwise.
+//   3. Load the canonical `estimate-component-evolution` recipe (shipped + override).
+//   4. Build the strategy registry by importing every framework's register
+//      function (boot wiring).
+//   5. Attach the artefact writer listener (ARCH-12 core listener).
+//   6. Run the recipe via `core/recipe-runner` and await completion.
+//   7. Return the recipeRunId, the AST, and the artefact path.
+//
+// The legacy `handleEstimateEvolution` in estimate-evolution.tool.mts remains
+// available for transition; V1.5 cleanup will decide whether to retire it or
+// align it on this recipe-based path.
+import { EstimateEvolutionInputSchema } from '../schemas/estimate-evolution.schema.mjs';
+import { loadRecipe } from '#core/recipe/recipe-loader.mjs';
+import { runRecipe } from '#core/recipe/recipe-runner.mjs';
+import { buildStrategyRegistry } from '#core/transport/strategy-registry-boot.mjs';
+import { attachArtifactWriter } from '#core/listeners/artifact-writer-listener.mjs';
+import { createEventBus } from '#core/bus/event-bus.mjs';
+import { resolveContext } from './resolve-context.mjs';
+import { SHIPPED_ROOT } from './shipped-root.mjs';
+/**
+ * Recipe-based handler. Equivalent to `handleEstimateEvolution` but
+ * dispatched through the kernel. The `_context` field in args (if present)
+ * is parsed as a RequestContext; otherwise a fresh context is synthesised.
+ */
+export async function handleEstimateEvolutionViaRecipe(rawInput) {
+    // Validate the user-facing args using the existing Zod schema, then strip
+    // the optional _context envelope (extracted separately).
+    const { _context: rawContext, ...args } = rawInput;
+    const validated = EstimateEvolutionInputSchema.parse(args);
+    const context = await resolveContext(rawContext);
+    // Load the canonical recipe (shipped) — user override consulted automatically
+    // when projectRoot points to a different repo.
+    const recipe = await loadRecipe({
+        framework: 'wardley',
+        tool: 'map',
+        name: 'estimate-component-evolution',
+        shippedRoot: SHIPPED_ROOT,
+        projectRoot: context.projectRoot,
+    });
+    const registry = buildStrategyRegistry();
+    const bus = createEventBus();
+    // Initial AST seeds the recipe's `$.input` with the validated component shape.
+    const ast = { input: validated };
+    // Attach the artefact writer core listener BEFORE the run so it captures
+    // every event including step-start and run-end.
+    const artifactHandle = attachArtifactWriter({
+        bus,
+        context,
+        getAst: () => ast,
+    });
+    const outcome = await runRecipe({ recipe, ast, context, registry, bus });
+    const artifactPath = await artifactHandle.artifactPath;
+    return {
+        recipeRunId: outcome.recipeRunId,
+        ast: outcome.ast,
+        artifactPath,
+        events: outcome.events,
+        envelope: outcome.envelope,
+    };
+}
+//# sourceMappingURL=estimate-evolution-via-recipe.mjs.map

package/dist/mcp/estimate-evolution-via-recipe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate-evolution-via-recipe.mjs","sourceRoot":"","sources":["../../src/mcp/estimate-evolution-via-recipe.mts"],"names":[],"mappings":"AAAA,qEAAqE;AACrE,2CAA2C;AAC3C,EAAE;AACF,QAAQ;AACR,uEAAuE;AACvE,6EAA6E;AAC7E,2DAA2D;AAC3D,sFAAsF;AACtF,2EAA2E;AAC3E,+BAA+B;AAC/B,oEAAoE;AACpE,qEAAqE;AACrE,+DAA+D;AAC/D,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,sCAAsC;AAEtC,OAAO,EAAE,4BAA4B,EAAE,MAAM,0CAA0C,CAAC;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,8CAA8C,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAWlD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,QAAiC;IAEjC,0EAA0E;IAC1E,yDAAyD;IACzD,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,GAAG,QAAQ,CAAC;IACnD,MAAM,SAAS,GAAG,4BAA4B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAE3D,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,UAAU,CAAC,CAAC;IAEjD,8EAA8E;IAC9E,+CAA+C;IAC/C,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC;QAC9B,SAAS,EAAE,SAAS;QACpB,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,8BAA8B;QACpC,WAAW,EAAE,YAAY;QACzB,WAAW,EAAE,OAAO,CAAC,WAAW;KACjC,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,qBAAqB,EAAE,CAAC;IACzC,MAAM,GAAG,GAAG,cAAc,EAAE,CAAC;IAE7B,+EAA+E;IAC/E,MAAM,GAAG,GAA4B,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IAE1D,yEAAyE;IACzE,gDAAgD;IAChD,MAAM,cAAc,GAAG,oBAAoB,CAAC;QAC1C,GAAG;QACH,OAAO;QACP,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG;KAClB,CAAC,CAAC;IAEH,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;IACzE,MAAM,YAAY,GAAG,MAAM,cAAc,CAAC,YAAY,CAAC;IAEvD,OAAO;QACL,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,YAAY;QACZ,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,QAAQ,EAAE,OAAO,CAAC,QAAQ;KAC3B,CAAC;AACJ,CAAC"}

package/dist/mcp/estimate-evolution.tool.d.mts

@@ -0,0 +1,3 @@
+import type { ToolDefinition } from "#core/transport/mcp-handler.mjs";
+export declare const ESTIMATE_EVOLUTION_TOOL: ToolDefinition;
+//# sourceMappingURL=estimate-evolution.tool.d.mts.map

package/dist/mcp/estimate-evolution.tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate-evolution.tool.d.mts","sourceRoot":"","sources":["../../src/mcp/estimate-evolution.tool.mts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAItE,eAAO,MAAM,uBAAuB,EAAE,cAerC,CAAC"}

package/dist/mcp/estimate-evolution.tool.mjs

@@ -0,0 +1,27 @@
+// MCP tool definition for `estimateEvolution`.
+//
+// Extracted from labre-daemon.mts to keep the daemon a thin boot wrapper
+// and to isolate the tool's Zod-to-JSON-Schema conversion and handler
+// adaptation in its natural home (the MCP layer).
+//
+// The handler delegates to `handleEstimateEvolutionViaRecipe` which runs
+// the canonical recipe through the kernel runner.
+import { z } from "zod";
+import { EstimateEvolutionInputSchema } from "#schemas/estimate-evolution.schema.mjs";
+import { handleEstimateEvolutionViaRecipe } from "./estimate-evolution-via-recipe.mjs";
+export const ESTIMATE_EVOLUTION_TOOL = {
+    name: "estimateEvolution",
+    description: "Estimate the Wardley Map evolution position of a component via the recipe runner. " +
+        "Dispatches through the canonical estimate-component-evolution recipe (node:identify → position-functional-in-evolution:llm-direct). " +
+        "Returns recipeRunId, the AST, the events trace, and the artifact path under ~/.labre-mcp/runs/.",
+    // any: zod-to-json conversion — the schema is well-typed at the Zod layer
+    inputSchema: z.toJSONSchema(EstimateEvolutionInputSchema, { io: "input" }),
+    async handler(args, context) {
+        // any: args is the open MCP arguments envelope; the handler validates internally
+        return handleEstimateEvolutionViaRecipe({
+            ...args,
+            _context: context,
+        });
+    },
+};
+//# sourceMappingURL=estimate-evolution.tool.mjs.map

package/dist/mcp/estimate-evolution.tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"estimate-evolution.tool.mjs","sourceRoot":"","sources":["../../src/mcp/estimate-evolution.tool.mts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,EAAE;AACF,yEAAyE;AACzE,sEAAsE;AACtE,kDAAkD;AAClD,EAAE;AACF,yEAAyE;AACzE,kDAAkD;AAElD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,EAAE,gCAAgC,EAAE,MAAM,qCAAqC,CAAC;AAEvF,MAAM,CAAC,MAAM,uBAAuB,GAAmB;IACrD,IAAI,EAAE,mBAAmB;IACzB,WAAW,EACT,oFAAoF;QACpF,sIAAsI;QACtI,iGAAiG;IACnG,0EAA0E;IAC1E,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,4BAA4B,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAA4B;IACrG,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO;QACzB,iFAAiF;QACjF,OAAO,gCAAgC,CAAC;YACtC,GAAI,IAAgC;YACpC,QAAQ,EAAE,OAAO;SAClB,CAAC,CAAC;IACL,CAAC;CACF,CAAC"}

package/dist/mcp/evaluate-map.tool.d.mts

@@ -0,0 +1,4 @@
+import type { McpToolDefinition } from '../types/mcp.mjs';
+export declare const EVALUATE_MAP_TOOL: McpToolDefinition;
+export declare function handleEvaluateMap(args: Record<string, unknown>): Promise<unknown>;
+//# sourceMappingURL=evaluate-map.tool.d.mts.map

package/dist/mcp/evaluate-map.tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-map.tool.d.mts","sourceRoot":"","sources":["../../src/mcp/evaluate-map.tool.mts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,kBAAkB,CAAC;AAItE,eAAO,MAAM,iBAAiB,EAAE,iBAO/B,CAAC;AAEF,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAMvF"}

package/dist/mcp/evaluate-map.tool.mjs

@@ -0,0 +1,22 @@
+// MCP tool wrapper for evaluateMap.
+//
+// Evaluates every component of a .wm Wardley Map file via the classification
+// gate + estimateEvolution pipeline, then writes the updated file in place.
+import { z } from 'zod';
+import { EvaluateMapInputSchema } from '../schemas/evaluate-map.schema.mjs';
+import { evaluateMapFile } from '#work-on-evolution/write/evaluate-map/evaluate-map.mjs';
+export const EVALUATE_MAP_TOOL = {
+    name: 'evaluateMap',
+    description: 'Evaluate all components in a .wm Wardley Map file, estimate their evolution positions, ' +
+        'and update the file with new maturity values. Uses the classification gate to skip non-economic ' +
+        'components and runs pluggable evaluation strategies on economic ones.',
+    inputSchema: z.toJSONSchema(EvaluateMapInputSchema, { io: 'input' }),
+};
+export async function handleEvaluateMap(args) {
+    const input = EvaluateMapInputSchema.parse(args);
+    return evaluateMapFile(input.filePath, {
+        strategy: input.strategy,
+        updateFile: input.updateFile,
+    });
+}
+//# sourceMappingURL=evaluate-map.tool.mjs.map

package/dist/mcp/evaluate-map.tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate-map.tool.mjs","sourceRoot":"","sources":["../../src/mcp/evaluate-map.tool.mts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,EAAE;AACF,6EAA6E;AAC7E,4EAA4E;AAE5E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAyB,MAAM,oCAAoC,CAAC;AACnG,OAAO,EAAE,eAAe,EAAE,MAAM,wDAAwD,CAAC;AAEzF,MAAM,CAAC,MAAM,iBAAiB,GAAsB;IAClD,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,yFAAyF;QACzF,kGAAkG;QAClG,uEAAuE;IACzE,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,sBAAsB,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAe;CACnF,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,IAA6B;IACnE,MAAM,KAAK,GAAqB,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACnE,OAAO,eAAe,CAAC,KAAK,CAAC,QAAQ,EAAE;QACrC,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,UAAU,EAAE,KAAK,CAAC,UAAU;KAC7B,CAAC,CAAC;AACL,CAAC"}

package/dist/mcp/generate-value-chain.tool.d.mts

@@ -0,0 +1,10 @@
+import type { McpToolDefinition } from '../types/mcp.mjs';
+import type { ChainMetadata } from '../types/value-chain.mjs';
+export interface GenerateValueChainResult {
+    owm: string;
+    metadata: ChainMetadata;
+    method: string;
+}
+export declare const GENERATE_VALUE_CHAIN_TOOL: McpToolDefinition;
+export declare function handleGenerateValueChain(args: Record<string, unknown>): Promise<GenerateValueChainResult>;
+//# sourceMappingURL=generate-value-chain.tool.d.mts.map

package/dist/mcp/generate-value-chain.tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-value-chain.tool.d.mts","sourceRoot":"","sources":["../../src/mcp/generate-value-chain.tool.mts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,kBAAkB,CAAC;AAOtE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,WAAW,wBAAwB;IACvC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,yBAAyB,EAAE,iBAUvC,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,wBAAwB,CAAC,CASnC"}

package/dist/mcp/generate-value-chain.tool.mjs

@@ -0,0 +1,33 @@
+// MCP tool `generateValueChain` — exposes the TopDownChainStrategy to
+// MCP clients as a single-shot tool that turns a natural-language command
+// into an OWM DSL document plus the chain metadata.
+//
+// The handler is dispatched by mcp-server.mts and wrapped in
+// `withMcpDegradation` by the server, so any failure inside
+// `TopDownChainStrategy.buildFull` flows back to the client as a
+// `Degradable<GenerateValueChainResult>` envelope.
+import { z } from 'zod';
+import { GenerateValueChainInputSchema, } from '../schemas/generate-value-chain.schema.mjs';
+import { getStrategyLLM } from '../lib/llm/registry.mjs';
+import { TopDownChainStrategy } from '#work-on-value-chain/write/chain/strategies/top-down/top-down-strategy.mjs';
+export const GENERATE_VALUE_CHAIN_TOOL = {
+    name: 'generateValueChain',
+    description: 'Build a Wardley value chain from a natural-language command. ' +
+        'Produces a complete OWM DSL document (component declarations + dependency links) ' +
+        'ready to render at onlinewardleymaps.com, together with the chain metadata ' +
+        '(angle, scope, objective, imperatives, temporality, contextSummary) extracted ' +
+        'from the command. Covers phases 1–2 of the Wardley study cycle — downstream ' +
+        'evolution refinement is delegated to estimateEvolution.',
+    inputSchema: z.toJSONSchema(GenerateValueChainInputSchema, { io: 'input' }),
+};
+export async function handleGenerateValueChain(args) {
+    const parsed = GenerateValueChainInputSchema.parse(args);
+    const llmCall = getStrategyLLM('write-chain');
+    const strategy = new TopDownChainStrategy({ llmCall });
+    const full = await strategy.buildFull({
+        nlCommand: parsed.nlCommand,
+        emit: { style: parsed.style, size: parsed.size },
+    });
+    return { ...full, method: TopDownChainStrategy.method };
+}
+//# sourceMappingURL=generate-value-chain.tool.mjs.map

package/dist/mcp/generate-value-chain.tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-value-chain.tool.mjs","sourceRoot":"","sources":["../../src/mcp/generate-value-chain.tool.mts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,0EAA0E;AAC1E,oDAAoD;AACpD,EAAE;AACF,6DAA6D;AAC7D,4DAA4D;AAC5D,iEAAiE;AACjE,mDAAmD;AAEnD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,6BAA6B,GAE9B,MAAM,4CAA4C,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4EAA4E,CAAC;AASlH,MAAM,CAAC,MAAM,yBAAyB,GAAsB;IAC1D,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EACT,+DAA+D;QAC/D,mFAAmF;QACnF,6EAA6E;QAC7E,gFAAgF;QAChF,8EAA8E;QAC9E,yDAAyD;IAC3D,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,6BAA6B,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAe;CAC1F,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,IAA6B;IAE7B,MAAM,MAAM,GAA4B,6BAA6B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClF,MAAM,OAAO,GAAG,cAAc,CAAC,aAAa,CAAC,CAAC;IAC9C,MAAM,QAAQ,GAAG,IAAI,oBAAoB,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC;IACvD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC;QACpC,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE;KACjD,CAAC,CAAC;IACH,OAAO,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,oBAAoB,CAAC,MAAM,EAAE,CAAC;AAC1D,CAAC"}

package/dist/mcp/identify-capability.tool.d.mts

@@ -0,0 +1,4 @@
+import type { McpToolDefinition } from '../types/mcp.mjs';
+export declare const IDENTIFY_CAPABILITY_TOOL: McpToolDefinition;
+export declare function handleIdentifyCapability(args: Record<string, unknown>): Promise<unknown>;
+//# sourceMappingURL=identify-capability.tool.d.mts.map

package/dist/mcp/identify-capability.tool.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify-capability.tool.d.mts","sourceRoot":"","sources":["../../src/mcp/identify-capability.tool.mts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,kBAAkB,CAAC;AAKtE,eAAO,MAAM,wBAAwB,EAAE,iBAQtC,CAAC;AAEF,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAc9F"}

package/dist/mcp/identify-capability.tool.mjs

@@ -0,0 +1,31 @@
+// MCP tool wrapper for identifyCapability.
+//
+// Decodes a Wardley component label (e.g. "Kubernetes", "CRM") into the
+// underlying capability/need it serves. Delegates to the lib function in
+// component/lib/capability/identify-capability.mts.
+import { z } from 'zod';
+import { IdentifyCapabilityInputSchema } from '../schemas/identify-capability.schema.mjs';
+import { getStrategyLLM } from '../lib/llm/registry.mjs';
+import { identifyCapability } from '#work-on-value-chain/write/component/lib/capability/identify-capability.mjs';
+export const IDENTIFY_CAPABILITY_TOOL = {
+    name: 'identifyCapability',
+    description: 'Identify the true underlying capability or need behind a Wardley Map component label. ' +
+        'Decodes technical solution names (CRM, ERP, Kubernetes...) into the capability they serve, ' +
+        'classified by nature (activity, practice, knowledge, data). ' +
+        'Only works for component and pipeline types — other types (anchor, market, ecosystem) are returned as-is.',
+    inputSchema: z.toJSONSchema(IdentifyCapabilityInputSchema, { io: 'input' }),
+};
+export async function handleIdentifyCapability(args) {
+    const parsed = IdentifyCapabilityInputSchema.parse(args);
+    if (!parsed?.name || typeof parsed.name !== 'string' || parsed.name.trim().length === 0) {
+        throw new Error('Required parameter "name" must be a non-empty string');
+    }
+    const component = {
+        name: parsed.name.trim(),
+        ...(parsed.type && { type: parsed.type }),
+        ...(parsed.description && { description: parsed.description.trim() }),
+        ...(parsed.context && { context: parsed.context.trim() }),
+    };
+    return identifyCapability(component, getStrategyLLM('identify-capability'));
+}
+//# sourceMappingURL=identify-capability.tool.mjs.map

package/dist/mcp/identify-capability.tool.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"identify-capability.tool.mjs","sourceRoot":"","sources":["../../src/mcp/identify-capability.tool.mts"],"names":[],"mappings":"AAAA,2CAA2C;AAC3C,EAAE;AACF,wEAAwE;AACxE,yEAAyE;AACzE,oDAAoD;AAEpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,6BAA6B,EAAgC,MAAM,2CAA2C,CAAC;AACxH,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,6EAA6E,CAAC;AAEjH,MAAM,CAAC,MAAM,wBAAwB,GAAsB;IACzD,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EACT,wFAAwF;QACxF,6FAA6F;QAC7F,8DAA8D;QAC9D,2GAA2G;IAC7G,WAAW,EAAE,CAAC,CAAC,YAAY,CAAC,6BAA6B,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAe;CAC1F,CAAC;AAEF,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAAC,IAA6B;IAC1E,MAAM,MAAM,GAA4B,6BAA6B,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAClF,IAAI,CAAC,MAAM,EAAE,IAAI,IAAI,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxF,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IAED,MAAM,SAAS,GAAG;QAChB,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE;QACxB,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC;QACzC,GAAG,CAAC,MAAM,CAAC,WAAW,IAAI,EAAE,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC;QACrE,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;KAC1D,CAAC;IAEF,OAAO,kBAAkB,CAAC,SAAS,EAAE,cAAc,CAAC,qBAAqB,CAAC,CAAC,CAAC;AAC9E,CAAC"}

package/dist/mcp/mcp-server.d.mts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import '../lib/prompts/init.mjs';
+import type { McpToolDefinition, ToolHandler, JsonRpcRequest, JsonRpcResponse } from '../types/mcp.mjs';
+/** All registered MCP tools. Add new tools here if needed. */
+declare const REGISTERED_TOOLS: McpToolDefinition[];
+/** Map of tool name → handler for fast dispatch */
+declare const TOOL_HANDLERS: Map<string, ToolHandler>;
+/**
+ * Route an incoming JSON-RPC request to the appropriate handler.
+ *
+ * Supported methods:
+ *   - initialize          → server info + capabilities
+ *   - tools/list          → list all registered tools
+ *   - tools/call          → dispatch to tool handler by name
+ *   - notifications/initialized → acknowledge (no response)
+ *   - ping                → pong
+ *
+ * @param {Object} request - JSON-RPC 2.0 request
+ * @returns {Promise<Object|null>} JSON-RPC 2.0 response, or null for notifications
+ */
+declare function handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+/**
+ * Start the MCP server listening on stdin/stdout.
+ * Reads newline-delimited JSON-RPC messages from stdin.
+ * Writes JSON-RPC responses to stdout (one per line).
+ */
+export declare function startServer(): void;
+export { REGISTERED_TOOLS, TOOL_HANDLERS, handleRequest };
+//# sourceMappingURL=mcp-server.d.mts.map

package/dist/mcp/mcp-server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.mts","sourceRoot":"","sources":["../../src/mcp/mcp-server.mts"],"names":[],"mappings":";AAgCA,OAAO,yBAAyB,CAAC;AAQjC,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,eAAe,EAGhB,MAAM,kBAAkB,CAAC;AAU1B,8DAA8D;AAC9D,QAAA,MAAM,gBAAgB,EAAE,iBAAiB,EAMxC,CAAC;AAEF,mDAAmD;AACnD,QAAA,MAAM,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAM1C,CAAC;AAiBH;;;;;;;;;;;;GAYG;AACH,iBAAe,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CA2JrF;AAID;;;;GAIG;AACH,wBAAgB,WAAW,SAqD1B;AAID,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,aAAa,EAAE,CAAC"}

package/dist/mcp/mcp-server.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+// LEGACY stdio MCP server. The canonical entrypoint is the HTTP daemon in
+// `src/core/transport/labre-daemon.mts` (ARCH-14). This stdio server is kept
+// for transition compatibility and is reachable via `pnpm mcp:legacy:stdio`.
+// It bypasses the kernel recipe runner and dispatches via the older
+// per-tool handlers; new functionality should land on the daemon path.
+// Slated for full removal in V1.5.
+// Guard: prevent recursive MCP server spawning.
+// When the server spawns a Claude Code agent (via Agent SDK), the child process
+// inherits this env var. If that child's MCP config tries to spawn another
+// labre-mcp server, the nested instance exits cleanly.
+if (process.env._WARDLEY_NESTED) {
+    process.stderr.write('[labre-mcp] Nested MCP server detected — exiting cleanly\n');
+    process.exit(0);
+}
+process.env._WARDLEY_NESTED = '1';
+// MCP Server for labre-mcp (legacy stdio path).
+//
+// Implements the Model Context Protocol (MCP) over stdio using JSON-RPC 2.0.
+// Registers the estimateEvolution tool and routes tool/call requests to its handler.
+//
+// Usage:
+//   node src/mcp/mcp-server.mjs
+//
+// Protocol: JSON-RPC 2.0 over stdin/stdout (newline-delimited)
+// Spec: https://modelcontextprotocol.io/specification
+import { createInterface } from 'node:readline';
+// Register every prompt parser with the registry before any tool handler runs.
+import '../lib/prompts/init.mjs';
+import { ESTIMATE_EVOLUTION_TOOL, handleEstimateEvolution } from './estimate-evolution.tool.mjs';
+import { EVALUATE_MAP_TOOL, handleEvaluateMap } from './evaluate-map.tool.mjs';
+import { IDENTIFY_CAPABILITY_TOOL, handleIdentifyCapability } from './identify-capability.tool.mjs';
+import { ESTIMATE_ANCHOR_EVOLUTION_TOOL, handleEstimateAnchorEvolution } from './estimate-anchor-evolution.tool.mjs';
+import { GENERATE_VALUE_CHAIN_TOOL, handleGenerateValueChain } from './generate-value-chain.tool.mjs';
+import { logInfo, logError, logWarning } from '../lib/mcp-notifications.mjs';
+import { classifyLLMError } from '../lib/llm/llm-error-handler.mjs';
+import { toErrorMessage } from '../lib/errors.mjs';
+import { withMcpDegradation, runAllHealthChecks, } from '../lib/degradation/index.mjs';
+import { registerDefaultHealthChecks } from './boot-health-checks.mjs';
+// ─── Tool Registry ──────────────────────────────────────────────────────────
+/** All registered MCP tools. Add new tools here if needed. */
+const REGISTERED_TOOLS = [
+    ESTIMATE_EVOLUTION_TOOL,
+    EVALUATE_MAP_TOOL,
+    IDENTIFY_CAPABILITY_TOOL,
+    ESTIMATE_ANCHOR_EVOLUTION_TOOL,
+    GENERATE_VALUE_CHAIN_TOOL,
+];
+/** Map of tool name → handler for fast dispatch */
+const TOOL_HANDLERS = new Map([
+    [ESTIMATE_EVOLUTION_TOOL.name, handleEstimateEvolution],
+    [EVALUATE_MAP_TOOL.name, handleEvaluateMap],
+    [IDENTIFY_CAPABILITY_TOOL.name, handleIdentifyCapability],
+    [ESTIMATE_ANCHOR_EVOLUTION_TOOL.name, handleEstimateAnchorEvolution],
+    [GENERATE_VALUE_CHAIN_TOOL.name, handleGenerateValueChain],
+]);
+// ─── MCP Server Implementation ─────────────────────────────────────────────
+const SERVER_INFO = {
+    name: 'labre-mcp',
+    version: '1.0.0',
+};
+const SERVER_CAPABILITIES = {
+    tools: {},
+    logging: {},
+    experimental: {
+        'claude/channel': {},
+    },
+};
+/**
+ * Route an incoming JSON-RPC request to the appropriate handler.
+ *
+ * Supported methods:
+ *   - initialize          → server info + capabilities
+ *   - tools/list          → list all registered tools
+ *   - tools/call          → dispatch to tool handler by name
+ *   - notifications/initialized → acknowledge (no response)
+ *   - ping                → pong
+ *
+ * @param {Object} request - JSON-RPC 2.0 request
+ * @returns {Promise<Object|null>} JSON-RPC 2.0 response, or null for notifications
+ */
+async function handleRequest(request) {
+    const { id, method, params } = request;
+    // Notifications (no id) — no response expected
+    if (id === undefined || id === null) {
+        return null;
+    }
+    switch (method) {
+        // ── Initialize handshake ──────────────────────────────────────────
+        case 'initialize':
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    protocolVersion: '2024-11-05',
+                    serverInfo: SERVER_INFO,
+                    capabilities: SERVER_CAPABILITIES,
+                    instructions: 'Progress notifications arrive as <channel source="labre-mcp" level="..." tool="...">. They are one-way status updates showing tool execution progress. Display them to the user as real-time progress indicators. No reply expected.',
+                },
+            };
+        // ── Ping/pong ────────────────────────────────────────────────────
+        case 'ping':
+            return { jsonrpc: '2.0', id, result: {} };
+        // ── List registered tools ────────────────────────────────────────
+        case 'tools/list':
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    tools: REGISTERED_TOOLS,
+                },
+            };
+        // ── Call a tool ──────────────────────────────────────────────────
+        case 'tools/call': {
+            const callParams = (params ?? {});
+            const toolName = callParams.name ?? '';
+            const handler = TOOL_HANDLERS.get(toolName);
+            if (!handler) {
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: `Unknown tool: "${toolName}". Available: ${REGISTERED_TOOLS.map(t => t.name).join(', ')}`,
+                                }),
+                            },
+                        ],
+                        isError: true,
+                    },
+                };
+            }
+            // Build a concise description of the invocation for log messages
+            const toolArgs = (callParams.arguments ?? {});
+            const subjectRaw = (toolArgs.name ?? toolArgs.filePath ?? toolArgs.description);
+            const toolSubject = typeof subjectRaw === 'string' ? subjectRaw.slice(0, 60) : '';
+            const startMsg = toolSubject
+                ? `Starting ${toolName} for "${toolSubject}"...`
+                : `Starting ${toolName}...`;
+            // Info-level: tool invocation start
+            logInfo(toolName, startMsg);
+            const startTime = Date.now();
+            try {
+                // Wrap the handler in the standard degradation envelope so every
+                // tool result carries `degraded` + `degradationEvents` fields, and
+                // any handler that has been migrated receives the per-invocation
+                // collector via its optional 2nd argument.
+                const wrapped = await withMcpDegradation(toolName, async (collector) => {
+                    return await handler(toolArgs, collector);
+                });
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                // Info-level: tool invocation end (success — possibly degraded)
+                const endMsg = toolSubject
+                    ? `${toolName} completed for "${toolSubject}" in ${elapsed}s${wrapped.degraded ? ' (degraded)' : ''}`
+                    : `${toolName} completed in ${elapsed}s${wrapped.degraded ? ' (degraded)' : ''}`;
+                logInfo(toolName, endMsg);
+                // Backward-compatible serialization: existing handlers return an
+                // object; merge `degraded` + `degradationEvents` as siblings rather
+                // than wrapping (preserves the public shape, adds two optional
+                // fields). Non-object results fall back to the explicit envelope.
+                const payload = wrapped.result !== null && typeof wrapped.result === 'object' && !Array.isArray(wrapped.result)
+                    ? {
+                        ...wrapped.result,
+                        degraded: wrapped.degraded,
+                        degradationEvents: wrapped.degradationEvents,
+                    }
+                    : wrapped;
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(payload, null, 2),
+                            },
+                        ],
+                    },
+                };
+            }
+            catch (err) {
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                // Classify the error to determine if it's an LLM-specific issue
+                const classified = classifyLLMError(err);
+                const isLLMError = classified.type !== 'generic';
+                // Error-level: tool invocation failure with specific error type
+                const typeLabel = isLLMError ? ` [${classified.type}]` : '';
+                const errMsg = toolSubject
+                    ? `${toolName} failed for "${toolSubject}" after ${elapsed}s${typeLabel}: ${toErrorMessage(err)}`
+                    : `${toolName} failed after ${elapsed}s${typeLabel}: ${toErrorMessage(err)}`;
+                logError(toolName, errMsg);
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: toErrorMessage(err) }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    },
+                };
+            }
+        }
+        // ── Unknown method ───────────────────────────────────────────────
+        default:
+            return {
+                jsonrpc: '2.0',
+                id,
+                error: {
+                    code: -32601,
+                    message: `Method not found: ${method}`,
+                },
+            };
+    }
+}
+// ─── Stdio Transport ────────────────────────────────────────────────────────
+/**
+ * Start the MCP server listening on stdin/stdout.
+ * Reads newline-delimited JSON-RPC messages from stdin.
+ * Writes JSON-RPC responses to stdout (one per line).
+ */
+export function startServer() {
+    // Register every default health check and surface known-down dependencies
+    // in the server log so operators see the warning before the first tool
+    // call rather than discovering it inside a degraded result.
+    registerDefaultHealthChecks();
+    void runAllHealthChecks().then((events) => {
+        for (const evt of events) {
+            logWarning('boot', `[${evt.source}] ${evt.reason}`);
+        }
+    });
+    const rl = createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    // Track pending async handlers so we flush before exit
+    const pending = [];
+    rl.on('line', (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let request;
+        try {
+            request = JSON.parse(trimmed);
+        }
+        catch {
+            const errorResponse = {
+                jsonrpc: '2.0',
+                id: null,
+                error: { code: -32700, message: 'Parse error' },
+            };
+            process.stdout.write(JSON.stringify(errorResponse) + '\n');
+            return;
+        }
+        const task = handleRequest(request).then((response) => {
+            // Notifications don't get responses
+            if (response !== null) {
+                process.stdout.write(JSON.stringify(response) + '\n');
+            }
+        });
+        pending.push(task);
+    });
+    rl.on('close', async () => {
+        // Wait for all in-flight requests to complete before exiting
+        await Promise.allSettled(pending);
+        process.exit(0);
+    });
+    // Signal readiness to stderr (not stdout, to avoid protocol pollution)
+    process.stderr.write(`[labre-mcp] MCP server started. Tools: ${REGISTERED_TOOLS.map(t => t.name).join(', ')}\n`);
+}
+// ─── Exports for programmatic use ───────────────────────────────────────────
+export { REGISTERED_TOOLS, TOOL_HANDLERS, handleRequest };
+// ─── Auto-start when run directly ───────────────────────────────────────────
+if (process.argv[1] && import.meta.url === `file:///${process.argv[1].replace(/\\/g, '/')}`) {
+    startServer();
+}
+//# sourceMappingURL=mcp-server.mjs.map