zefiro 0.6.0 → 0.6.1

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import {
   banner,
+  buildV4Graph,
   error,
+  extractStateVariables,
   header,
   info,
   isDAGValid,
@@ -14,7 +16,7 @@ import {
   validateQAMapV3,
   verbose,
   warn
-} from "./cli-fc97msmj.js";
+} from "./cli-ychk5szm.js";
 import {
   CONFIG_DIR,
   getPackageRoot,
@@ -7637,7 +7639,7 @@ async function ensureApiKey(provider) {
   }
 }
 function registerAnalyze(program2) {
-  program2.command("analyze [input]").description("Analyze AST scan with AI to generate QA map (features, workflows, scenarios)").option("--output <file>", "Write QA map to specific file").option("--skip-scenarios", "Only run feature analysis (skip scenario generation)").option("--schema-version <version>", "Output schema version (2 or 3)", "3").action(async (inputArg, opts) => {
+  program2.command("analyze [input]").description("Analyze AST scan with AI to generate QA map (features, workflows, scenarios)").option("--output <file>", "Write QA map to specific file").option("--skip-scenarios", "Only run feature analysis (skip scenario generation)").option("--schema-version <version>", "Output schema version (2, 3, or 4)", "3").action(async (inputArg, opts) => {
     const schemaVersion = parseInt(opts?.schemaVersion ?? "3", 10);
     const ctx = await resolveCommandContext(program2);
     const root = ctx.paths.projectRoot;
@@ -7674,6 +7676,10 @@ function registerAnalyze(program2) {
     if (!hasKey)
       return;
     const spinner = createSpinner();
+    if (schemaVersion === 4) {
+      await runV4Analysis(ctx, ast, outputPath, spinner, opts);
+      return;
+    }
     if (schemaVersion === 3) {
       await runV3Analysis(ctx, ast, outputPath, prevQAMap, affected, spinner, opts);
       return;
@@ -7986,6 +7992,107 @@ async function runV3Analysis(ctx, ast, outputPath, _prevQAMap, _affected, spinne
   writeFile(outputPath, JSON.stringify(normalizedPayload, null, 2));
   success(`V3 QA map written to ${outputPath}`);
 }
+async function runV4Analysis(ctx, ast, outputPath, spinner, opts) {
+  const { join: join5 } = await import("node:path");
+  spinner.start("V4 Stage 1: Extracting state variables...");
+  const scanDir = ast.files?.[0]?.path ? join5(process.cwd(), ast.files[0].path).replace(ast.files[0].path, "") : process.cwd();
+  const filePaths = ast.files.map((f) => join5(scanDir, f.path));
+  const stateVariables = extractStateVariables(filePaths, ast.routes, scanDir);
+  spinner.stop();
+  const highConf = stateVariables.filter((v) => v.extractionConfidence === "high").length;
+  success(`Extracted ${stateVariables.length} state variables (${highConf} high confidence)`);
+  spinner.start("V4 Stage 2: Building formal model (structural graph + state space + transitions)...");
+  const graphResult = buildV4Graph(ast, stateVariables);
+  spinner.stop();
+  success(`Structural graph: ${graphResult.structuralGraph.nodes.length} nodes, ${graphResult.structuralGraph.edges.length} edges
+  State space: ${graphResult.stateSpace.stats.totalVariables} vars, ${graphResult.stateSpace.stats.totalValidConfigurations} valid configs
+  Transition system: ${graphResult.transitionSystem.stats.reachableNodes} reachable nodes, ${graphResult.transitionSystem.stats.totalTransitions} transitions`);
+  spinner.start("V4 Stage 3: Generating semantic projection (feature labels)...");
+  const featureAgent = loadAgent("feature-analyzer-agent-v4", ctx.config);
+  const projectionInput = {
+    structuralGraph: {
+      nodes: graphResult.structuralGraph.nodes.map((n) => ({
+        id: n.id,
+        routePath: n.routePath,
+        routeGroup: n.routeGroup,
+        components: n.components,
+        guards: n.guards,
+        forms: n.forms
+      })),
+      edges: graphResult.structuralGraph.edges.map((e) => ({
+        id: e.id,
+        fromNodeId: e.fromNodeId,
+        toNodeId: e.toNodeId,
+        type: e.type
+      })),
+      entryPoints: graphResult.structuralGraph.entryPoints
+    },
+    stateVariables: stateVariables.map((v) => ({
+      id: v.id,
+      name: v.name,
+      category: v.category,
+      domain: v.domain,
+      affectsRoutes: v.affectsRoutes,
+      extractionConfidence: v.extractionConfidence
+    })),
+    transitionSystemStats: graphResult.transitionSystem.stats,
+    ast: { routes: ast.routes, stats: ast.stats }
+  };
+  const featureResponse = await callLLM({
+    provider: ctx.provider,
+    model: ctx.model ?? featureAgent.config.model,
+    systemPrompt: featureAgent.systemPrompt,
+    userMessage: JSON.stringify(projectionInput),
+    maxTokens: featureAgent.config.maxTokens,
+    temperature: featureAgent.config.temperature,
+    jsonMode: true
+  });
+  spinner.stop();
+  const projection = JSON.parse(extractJSON(featureResponse.content));
+  const features = (projection.features ?? []).map((f) => ({
+    id: f.id,
+    name: f.name,
+    description: f.description ?? "",
+    subgraph: {
+      routeIds: f.subgraph?.routeIds ?? [],
+      transitionIds: f.subgraph?.transitionIds ?? [],
+      stateVariableIds: f.subgraph?.stateVariableIds ?? []
+    },
+    complexity: (f.subgraph?.routeIds?.length ?? 0) + (f.subgraph?.transitionIds?.length ?? 0),
+    criticalPaths: [],
+    routes: f.routes ?? [],
+    sourceFiles: f.sourceFiles ?? []
+  }));
+  const baseComponents = projection.components ?? [];
+  success(`Semantic projection: ${features.length} features`);
+  const v4Payload = {
+    schemaVersion: 4,
+    structuralGraph: graphResult.structuralGraph,
+    stateSpace: graphResult.stateSpace,
+    transitionSystem: graphResult.transitionSystem,
+    semanticProjection: {
+      labels: [],
+      features
+    },
+    components: baseComponents,
+    git: ast.git ? {
+      commitSha: ast.git.commitSha,
+      shortSha: ast.git.shortSha,
+      branch: ast.git.branch,
+      tags: ast.git.tags,
+      isDirty: ast.git.isDirty
+    } : undefined,
+    metadata: ast.git ? { git: ast.git } : undefined,
+    compat: projection.sections ? {
+      sections: projection.sections,
+      features: projection.features,
+      workflows: [],
+      scenarios: []
+    } : undefined
+  };
+  writeFile(outputPath, JSON.stringify(v4Payload, null, 2));
+  success(`V4 QA map written to ${outputPath}`);
+}
 
 // src/commands/auth.ts
 function registerAuth(program2) {
@@ -8301,8 +8408,15 @@ import { join as join7 } from "node:path";
 
 // src/scanner/push.ts
 async function pushToApi(payload, apiUrl, apiKey) {
-  const isV3 = payload.schemaVersion === 3;
-  const url = isV3 ? apiUrl.replace("/v2/push", "/v3/push") : apiUrl.replace("/v3/push", "/v2/push");
+  const schemaVersion = payload.schemaVersion;
+  let url;
+  if (schemaVersion === 4) {
+    url = apiUrl.replace(/\/v[23]\/push/, "/v4/push");
+  } else if (schemaVersion === 3) {
+    url = apiUrl.replace("/v2/push", "/v3/push");
+  } else {
+    url = apiUrl.replace("/v3/push", "/v2/push");
+  }
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -8336,7 +8450,9 @@ function registerPush(program2) {
       process.exit(1);
     }
     const raw = JSON.parse(readFile(inputPath));
-    const isV3 = raw.schemaVersion === 3;
+    const schemaVersion = raw.schemaVersion ?? 2;
+    const isV4 = schemaVersion === 4;
+    const isV3 = schemaVersion === 3;
     const payload = raw;
     if (opts?.commitSha) {
       payload.commitSha = opts.commitSha;
@@ -8354,9 +8470,18 @@ function registerPush(program2) {
         payload.commitSha = gitMeta.commitSha;
       }
     }
-    const sectionCount = isV3 ? payload.sections.length : 0;
-    info(`Pushing (V${isV3 ? 3 : 2}): ${sectionCount ? sectionCount + " sections, " : ""}${payload.features.length} features, ${payload.workflows.length} workflows, ${payload.scenarios.length} scenarios`);
-    const pushEndpoint = isV3 ? "/api/cli/push-v3" : "/api/cli/push";
+    if (isV4) {
+      const v4 = raw;
+      const nodeCount = v4.structuralGraph?.nodes?.length ?? 0;
+      const edgeCount = v4.structuralGraph?.edges?.length ?? 0;
+      const stateVarCount = v4.stateSpace?.variables?.length ?? 0;
+      const featureCount = v4.semanticProjection?.features?.length ?? 0;
+      info(`Pushing (V4): ${nodeCount} nodes, ${edgeCount} edges, ${stateVarCount} state vars, ${featureCount} features`);
+    } else {
+      const sectionCount = isV3 ? payload.sections.length : 0;
+      info(`Pushing (V${isV3 ? 3 : 2}): ${sectionCount ? sectionCount + " sections, " : ""}${payload.features.length} features, ${payload.workflows.length} workflows, ${payload.scenarios.length} scenarios`);
+    }
+    const pushEndpoint = isV4 ? "/api/cli/push-v4" : isV3 ? "/api/cli/push-v3" : "/api/cli/push";
     try {
       const { AuthClient } = await import("./index-fbvbnntc.js");
       const client = AuthClient.fromSession();
@@ -8367,7 +8492,11 @@ function registerPush(program2) {
         spinner2.stop();
         success("Push successful!");
         info(`  Version: ${result2.version} (schema v${result2.schemaVersion})`);
-        info(`  Auto-linked scenarios: ${result2.stats.autoLinkedScenarios}`);
+        if (result2.schemaVersion === 4) {
+          info(`  Nodes: ${result2.stats.structuralNodes ?? 0}, Transitions: ${result2.stats.transitions ?? 0}, Features: ${result2.stats.features ?? 0}`);
+        } else {
+          info(`  Auto-linked scenarios: ${result2.stats.autoLinkedScenarios}`);
+        }
         return;
       }
     } catch {}
@@ -8387,7 +8516,11 @@ function registerPush(program2) {
     spinner.stop();
     success("Push successful!");
     info(`  Version: ${result.version} (schema v${result.schemaVersion})`);
-    info(`  Auto-linked scenarios: ${result.stats.autoLinkedScenarios}`);
+    if (result.schemaVersion === 4) {
+      info(`  Nodes: ${result.stats.structuralNodes ?? 0}, Transitions: ${result.stats.transitions ?? 0}, Features: ${result.stats.features ?? 0}`);
+    } else {
+      info(`  Auto-linked scenarios: ${result.stats.autoLinkedScenarios}`);
+    }
   });
 }
 
@@ -12509,11 +12642,20 @@ function registerScan(program2) {
       info(`  Diff: first scan`);
     }
     writeFile(outputPath, JSON.stringify(ast, null, 2));
+    const filePaths = ast.files.map((f) => join8(scanConfig.scanDir, f.path));
+    const stateVars = extractStateVariables(filePaths, ast.routes, scanConfig.scanDir);
+    if (stateVars.length > 0) {
+      const stateVarsPath = outputPath.replace("ast-scan.json", "state-variables.json");
+      writeFile(stateVarsPath, JSON.stringify(stateVars, null, 2));
+    }
     success(`AST written to ${outputPath}`);
     info(`  Files: ${ast.stats.totalFiles} (${ast.stats.totalLines} lines)`);
     info(`  Routes: ${ast.routes.length}`);
     info(`  Components: ${ast.components.length}`);
     info(`  Hooks: ${ast.hooks.length}`);
+    if (stateVars.length > 0) {
+      info(`  State variables: ${stateVars.length} (${stateVars.filter((v) => v.extractionConfidence === "high").length} high confidence)`);
+    }
     if (ast.git) {
       info(`  Git: ${ast.git.branch}@${ast.git.shortSha}${ast.git.isDirty ? " (dirty)" : ""}`);
     }

package/dist/mcp.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import {
+  buildV4Graph,
+  extractStateVariables,
   runStage1,
   validateQAMap,
   validateQAMapV3
-} from "./cli-fc97msmj.js";
+} from "./cli-ychk5szm.js";
 import {
   $ZodObject,
   $ZodType,
@@ -14990,11 +14992,61 @@ async function scanCodebase(root) {
 
 // src/mcp.ts
 import { execSync } from "node:child_process";
+function validateQAMapV4(payload) {
+  const errors = [];
+  const warnings = [];
+  if (!payload || typeof payload !== "object") {
+    return { valid: false, errors: ["Payload must be a non-null object"], warnings };
+  }
+  const p = payload;
+  if (p.schemaVersion !== 4) {
+    errors.push("schemaVersion must be 4");
+  }
+  const sg = p.structuralGraph;
+  if (!sg || typeof sg !== "object") {
+    errors.push("structuralGraph is required");
+  } else {
+    if (!Array.isArray(sg.nodes))
+      errors.push("structuralGraph.nodes must be an array");
+    if (!Array.isArray(sg.edges))
+      errors.push("structuralGraph.edges must be an array");
+  }
+  const ss = p.stateSpace;
+  if (!ss || typeof ss !== "object") {
+    errors.push("stateSpace is required");
+  } else {
+    if (!Array.isArray(ss.variables))
+      errors.push("stateSpace.variables must be an array");
+    if (!Array.isArray(ss.constraints))
+      errors.push("stateSpace.constraints must be an array");
+    if (!Array.isArray(ss.configurations))
+      errors.push("stateSpace.configurations must be an array");
+  }
+  const ts = p.transitionSystem;
+  if (!ts || typeof ts !== "object") {
+    errors.push("transitionSystem is required");
+  } else {
+    if (!Array.isArray(ts.nodes))
+      errors.push("transitionSystem.nodes must be an array");
+    if (!Array.isArray(ts.transitions))
+      errors.push("transitionSystem.transitions must be an array");
+  }
+  const sp = p.semanticProjection;
+  if (sp && typeof sp === "object") {
+    if (!Array.isArray(sp.features))
+      warnings.push("semanticProjection.features should be an array");
+    if (!Array.isArray(sp.labels))
+      warnings.push("semanticProjection.labels should be an array");
+  } else {
+    warnings.push("semanticProjection is missing — AI labeling not yet applied");
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
 var SERVER_INSTRUCTIONS = `
 # Zefiro — Scanner & QA Map Guide
 
 You have access to Zefiro, an AI-powered codebase scanner and QA map generator.
-Supports two schema versions: V2 (flat/linear) and V3 (hierarchical/DAG). **Default to V3.**
+Supports three schema versions: V2 (flat/linear), V3 (hierarchical/DAG), and V4 (formal model). **Default to V3 for AI analysis, V4 for formal graph-based analysis.**
 
 ## Core Workflow
 
@@ -15010,7 +15062,9 @@ Supports two schema versions: V2 (flat/linear) and V3 (hierarchical/DAG). **Defa
 - \`zefiro_scan_codebase\` — scan test files, configs, fixtures, path aliases
 - \`zefiro_scan_ast\` — deep AST scan: routes, components, hooks, imports, navigation patterns
 - \`zefiro_scan_ast_detail\` — drill into a specific AST category (routes, components, hooks, dependencies, files, navigationPatterns)
-- \`zefiro_build_qa_map\` — validate + write QA map payload (V2 or V3, auto-detected)
+- \`zefiro_extract_state_variables\` — V4: extract state variables (auth, roles, flags, permissions) from scanned AST
+- \`zefiro_build_v4_graph\` — V4: build formal model (structural graph + state space + transition system) from AST + state variables
+- \`zefiro_build_qa_map\` — validate + write QA map payload (V2, V3, or V4 auto-detected)
 - \`zefiro_read_qa_map\` — read existing QA map
 
 ## Scanner V3 Enhancements
@@ -15208,7 +15262,7 @@ V2 payloads do NOT include a schemaVersion field. Flat features, linear workflow
 ### V2 ConditionalBranch: \`{ condition, outcome, type: "validation"|"permission"|"error"|"business-logic" }\`
 ### V2 Scenario: \`{ id, workflowId, featureId, name, description, category, preconditions: string[], steps: ScenarioStep[], expectedOutcome, componentIds: string[], workflowStepIds: string[], priority }\`
 `.trim();
-var server = new McpServer({ name: "zefiro", version: "0.4.0" }, { instructions: SERVER_INSTRUCTIONS });
+var server = new McpServer({ name: "zefiro", version: "0.6.1" }, { instructions: SERVER_INSTRUCTIONS });
 server.registerTool("zefiro_scan_codebase", {
   title: "Scan Codebase",
   description: "Scan a project directory for test files, configs, fixtures, path aliases, and sample test content.",
@@ -15272,16 +15326,17 @@ server.registerTool("zefiro_scan_ast_detail", {
 });
 server.registerTool("zefiro_build_qa_map", {
   title: "Build QA Map",
-  description: "Validate and optionally write a QA map payload (V2 or V3, auto-detected by schemaVersion field). Use dryRun: true to validate without writing.",
+  description: "Validate and optionally write a QA map payload (V2, V3, or V4, auto-detected by schemaVersion field). Use dryRun: true to validate without writing.",
   inputSchema: exports_external.object({
-    payload: exports_external.any().describe("QAMapV2Payload or QAMapV3Payload JSON object. V3 must include schemaVersion: 3."),
+    payload: exports_external.any().describe("QAMapV2Payload, QAMapV3Payload, or QAMapV4Payload JSON object. V3 must include schemaVersion: 3, V4 must include schemaVersion: 4."),
     output: exports_external.string().optional().describe(`Output file path (defaults to ${CONFIG_DIR}/qa-map.json)`),
     dryRun: exports_external.boolean().optional().describe("Validate only, do not write (default: false)")
   })
 }, async ({ payload, output, dryRun }) => {
   try {
+    const isV4 = payload && typeof payload === "object" && payload.schemaVersion === 4;
     const isV3 = payload && typeof payload === "object" && payload.schemaVersion === 3;
-    const validation = isV3 ? validateQAMapV3(payload) : validateQAMap(payload);
+    const validation = isV4 ? validateQAMapV4(payload) : isV3 ? validateQAMapV3(payload) : validateQAMap(payload);
     if (validation.valid && payload && typeof payload === "object") {
       try {
         const sha = execSync("git rev-parse HEAD", { encoding: "utf-8" }).trim();
@@ -15298,7 +15353,15 @@ server.registerTool("zefiro_build_qa_map", {
       written = true;
     }
     const p = payload;
-    const stats = validation.valid ? {
+    const stats = validation.valid ? isV4 ? {
+      structuralNodes: Array.isArray(p?.structuralGraph?.nodes) ? p.structuralGraph.nodes.length : 0,
+      structuralEdges: Array.isArray(p?.structuralGraph?.edges) ? p.structuralGraph.edges.length : 0,
+      stateVariables: Array.isArray(p?.stateSpace?.variables) ? p.stateSpace.variables.length : 0,
+      stateConfigurations: Array.isArray(p?.stateSpace?.configurations) ? p.stateSpace.configurations.length : 0,
+      transitionNodes: Array.isArray(p?.transitionSystem?.nodes) ? p.transitionSystem.nodes.length : 0,
+      transitions: Array.isArray(p?.transitionSystem?.transitions) ? p.transitionSystem.transitions.length : 0,
+      features: Array.isArray(p?.semanticProjection?.features) ? p.semanticProjection.features.length : 0
+    } : {
       sections: isV3 && Array.isArray(p?.sections) ? p.sections.length : undefined,
       features: Array.isArray(p?.features) ? p.features.length : 0,
       workflows: Array.isArray(p?.workflows) ? p.workflows.length : 0,
@@ -15308,13 +15371,96 @@ server.registerTool("zefiro_build_qa_map", {
     return {
       content: [{
         type: "text",
-        text: JSON.stringify({ valid: validation.valid, schemaVersion: isV3 ? 3 : 2, errors: validation.errors, warnings: validation.warnings, written, outputPath: written ? outputPath : null, stats }, null, 2)
+        text: JSON.stringify({ valid: validation.valid, schemaVersion: isV4 ? 4 : isV3 ? 3 : 2, errors: validation.errors, warnings: validation.warnings, written, outputPath: written ? outputPath : null, stats }, null, 2)
       }]
     };
   } catch (err) {
     return { content: [{ type: "text", text: `Error building QA map: ${err.message}` }], isError: true };
   }
 });
+server.registerTool("zefiro_extract_state_variables", {
+  title: "Extract State Variables (V4)",
+  description: "Extract state variables from the scanned codebase. Requires a prior zefiro_scan_ast call. " + "Returns state variables (auth guards, roles, feature flags, permissions, UI state, URL params) with confidence levels.",
+  inputSchema: exports_external.object({})
+}, async () => {
+  try {
+    const cwd = process.cwd();
+    const astPath = join2(cwd, CONFIG_DIR, "ast-scan.json");
+    if (!existsSync2(astPath)) {
+      return { content: [{ type: "text", text: "Error: No AST scan found. Run zefiro_scan_ast first." }], isError: true };
+    }
+    const ast = JSON.parse(readFileSync2(astPath, "utf-8"));
+    const scanDir = ast.files.length > 0 ? join2(cwd, ast.scanDir ?? "src") : join2(cwd, "src");
+    const filePaths = ast.files.map((f) => join2(scanDir, f.path));
+    const stateVars = extractStateVariables(filePaths, ast.routes, scanDir);
+    const stateVarsPath = join2(cwd, CONFIG_DIR, "state-variables.json");
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    mkdirSync(join2(cwd, CONFIG_DIR), { recursive: true });
+    writeFileSync(stateVarsPath, JSON.stringify(stateVars, null, 2));
+    const summary = {
+      total: stateVars.length,
+      byConfidence: {
+        high: stateVars.filter((v) => v.extractionConfidence === "high").length,
+        medium: stateVars.filter((v) => v.extractionConfidence === "medium").length,
+        low: stateVars.filter((v) => v.extractionConfidence === "low").length
+      },
+      byCategory: stateVars.reduce((acc, v) => {
+        const cat = v.id.split(":")[1]?.split("-")[0] ?? "unknown";
+        acc[cat] = (acc[cat] ?? 0) + 1;
+        return acc;
+      }, {}),
+      variables: stateVars,
+      savedTo: stateVarsPath
+    };
+    return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error extracting state variables: ${err.message}` }], isError: true };
+  }
+});
+server.registerTool("zefiro_build_v4_graph", {
+  title: "Build V4 Graph",
+  description: "Build the formal V4 model (structural graph + state space + transition system) from the AST scan and state variables. " + "Requires prior zefiro_scan_ast and zefiro_extract_state_variables calls. Returns graph statistics and saves the result.",
+  inputSchema: exports_external.object({})
+}, async () => {
+  try {
+    const cwd = process.cwd();
+    const astPath = join2(cwd, CONFIG_DIR, "ast-scan.json");
+    const stateVarsPath = join2(cwd, CONFIG_DIR, "state-variables.json");
+    if (!existsSync2(astPath)) {
+      return { content: [{ type: "text", text: "Error: No AST scan found. Run zefiro_scan_ast first." }], isError: true };
+    }
+    if (!existsSync2(stateVarsPath)) {
+      return { content: [{ type: "text", text: "Error: No state variables found. Run zefiro_extract_state_variables first." }], isError: true };
+    }
+    const ast = JSON.parse(readFileSync2(astPath, "utf-8"));
+    const stateVars = JSON.parse(readFileSync2(stateVarsPath, "utf-8"));
+    const result = buildV4Graph(ast, stateVars);
+    const graphPath = join2(cwd, CONFIG_DIR, "v4-graph.json");
+    const { mkdirSync, writeFileSync } = await import("node:fs");
+    mkdirSync(join2(cwd, CONFIG_DIR), { recursive: true });
+    writeFileSync(graphPath, JSON.stringify(result, null, 2));
+    const summary = {
+      structuralGraph: {
+        nodes: result.structuralGraph.nodes.length,
+        edges: result.structuralGraph.edges.length
+      },
+      stateSpace: {
+        variables: result.stateSpace.variables.length,
+        constraints: result.stateSpace.constraints.length,
+        configurations: result.stateSpace.configurations.length
+      },
+      transitionSystem: {
+        nodes: result.transitionSystem.nodes.length,
+        transitions: result.transitionSystem.transitions.length,
+        entryPoints: result.transitionSystem.nodes.filter((n) => n.isEntryPoint).length
+      },
+      savedTo: graphPath
+    };
+    return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+  } catch (err) {
+    return { content: [{ type: "text", text: `Error building V4 graph: ${err.message}` }], isError: true };
+  }
+});
 server.registerTool("zefiro_read_qa_map", {
   title: "Read QA Map",
   description: "Read an existing QA map file.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zefiro",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "bin": {
     "zefiro": "./dist/cli.js",