@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/create_work_order.js

@@ -5,16 +5,33 @@
 // - spec-high 엔진 필수
 // - 엔진 없으면 GitHub 릴리즈에서 자동 다운로드 시도
 // - 다운로드 실패 시 명확한 에러 메시지 반환
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { parse as parseYaml } from "yaml";
-import { runEngine, invalidateEngineCache } from "../../engine.js";
-import { safeJsonParse } from "../../cli.js";
-import { resolveRunId, resolveProjectId, getRunContext, readRunState, invalidateStateCache } from "./context.js";
-import { generateWorkOrderText } from "./pm_language.js";
-import { ClinicBridgeFileSchema } from "../../generated/clinic_bridge_file.js";
-import { writeCurrentWorkOrderState, generateWorkOrderId } from "./state-store.js";
-import { emitEvent } from "../../events/emitter.js";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { runEngine, invalidateEngineCache } from '../../engine.js';
+import { safeJsonParse } from '../../cli.js';
+import { resolveRunId, resolveProjectId, getRunContext, readRunState, invalidateStateCache, } from './context.js';
+import { generateWorkOrderText } from './pm_language.js';
+import { ClinicBridgeFileSchema } from '../../generated/clinic_bridge_file.js';
+import { writeCurrentWorkOrderState, generateWorkOrderId } from './state-store.js';
+import { computeAndPersistStage } from './stage-computer.js';
+import { emitEvent } from '../../events/emitter.js';
+import { SSOT_PATHS } from './phase.js';
+import { logger } from '../../../shared/logger.js';
+function emitPlanArtifactIfPresent(basePath, runId) {
+    const planPath = path.join(basePath, SSOT_PATHS.plan(runId));
+    if (!fs.existsSync(planPath))
+        return;
+    emitEvent({
+        runId,
+        type: 'artifact.plan_updated',
+        reason: 'spec_high_plan_direct_emit',
+        paths: [planPath],
+        component: 'create_work_order',
+        actor: 'engine',
+        workspaceRoot: basePath,
+    });
+}
 /**
  * vibe_pm.create_work_order - Issue work order for implementation (MVP)
  *
@@ -28,8 +45,8 @@ import { emitEvent } from "../../events/emitter.js";
  *   - Auto-downloads from GitHub releases if not installed
  *   - Throws error if download fails (with installation instructions)
  */
-export async function createWorkOrder(input) {
-    const basePath = process.cwd();
+export async function createWorkOrder(input, workspaceRoot = process.cwd()) {
+    const basePath = workspaceRoot;
     // Resolve run_id
     const { run_id } = resolveRunId(input.project_id, basePath);
     const project_id = resolveProjectId(run_id, basePath);
@@ -39,18 +56,18 @@ export async function createWorkOrder(input) {
     // Step 1: Generate SSOT
     // runEngine() will auto-download engine from GitHub if not installed
     try {
-        const ssotResult = await runEngine("spec-high", ["--root", "engines/spec_high", "ssot-generate", run_id], { timeoutMs: 120_000 });
+        const ssotResult = await runEngine('spec-high', ['--root', 'engines/spec_high', 'ssot-generate', run_id], { timeoutMs: 120_000 });
         if (ssotResult.code !== 0) {
             throw new Error(`ssot-generate 실패: ${ssotResult.stderr}`);
         }
         // Phase 16: Direct emit hook for ssot-generate (replaces watcher dependency)
         emitEvent({
             runId: run_id,
-            type: "artifact.ssot_generated",
-            reason: "ssot_generate",
-            paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "ssot")],
-            component: "create_work_order",
-            actor: "engine",
+            type: 'artifact.ssot_generated',
+            reason: 'ssot_generate',
+            paths: [path.join(basePath, 'engines', 'spec_high', 'runs', run_id, 'ssot')],
+            component: 'create_work_order',
+            actor: 'engine',
             workspaceRoot: basePath,
         });
     }
@@ -64,18 +81,19 @@ export async function createWorkOrder(input) {
     }
     // Step 2: Generate atomic specs
     try {
-        const atomicResult = await runEngine("spec-high", ["--root", "engines/spec_high", "atomic-generate", run_id], { timeoutMs: 120_000 });
+        const atomicResult = await runEngine('spec-high', ['--root', 'engines/spec_high', 'atomic-generate', run_id], { timeoutMs: 120_000 });
         if (atomicResult.code !== 0) {
             throw new Error(`atomic-generate 실패: ${atomicResult.stderr}`);
         }
         emitEvent({
             runId: run_id,
-            type: "artifact.spec_generated",
-            reason: "atomic_generate",
-            paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "atomic_specs.json")],
-            component: "create_work_order",
+            type: 'artifact.spec_generated',
+            reason: 'atomic_generate',
+            paths: [path.join(basePath, 'engines', 'spec_high', 'runs', run_id, 'atomic_specs.json')],
+            component: 'create_work_order',
             workspaceRoot: basePath,
         });
+        emitPlanArtifactIfPresent(basePath, run_id);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -84,18 +102,21 @@ export async function createWorkOrder(input) {
     // Step 3: Generate clinic bridge
     let bridgeResult;
     try {
-        bridgeResult = await runEngine("spec-high", ["--root", "engines/spec_high", "clinic-bridge", run_id, "--write", "--format", "yaml"], { timeoutMs: 120_000 });
+        bridgeResult = await runEngine('spec-high', ['--root', 'engines/spec_high', 'clinic-bridge', run_id, '--write', '--format', 'yaml'], { timeoutMs: 120_000 });
         if (bridgeResult.code !== 0) {
             throw new Error(`clinic-bridge 실패: ${bridgeResult.stderr}`);
         }
         emitEvent({
             runId: run_id,
-            type: "artifact.work_order_updated",
-            reason: "clinic_bridge_written",
-            paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "handoff", "clinic_bridge.yaml")],
-            component: "create_work_order",
+            type: 'artifact.work_order_updated',
+            reason: 'clinic_bridge_written',
+            paths: [
+                path.join(basePath, 'engines', 'spec_high', 'runs', run_id, 'handoff', 'clinic_bridge.yaml'),
+            ],
+            component: 'create_work_order',
             workspaceRoot: basePath,
         });
+        emitPlanArtifactIfPresent(basePath, run_id);
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -103,25 +124,25 @@ export async function createWorkOrder(input) {
     }
     // Step 4: Generate intent documents (optional, non-critical)
     try {
-        const intentResult = await runEngine("spec-high", ["--root", "engines/spec_high", "intent-generate", run_id, "--write", "--force"], { timeoutMs: 60_000 });
+        const intentResult = await runEngine('spec-high', ['--root', 'engines/spec_high', 'intent-generate', run_id, '--write', '--force'], { timeoutMs: 60_000 });
         if (intentResult.code !== 0) {
-            intentWarning = "의도 문서 생성 중 문제가 발생했습니다 (작업 지시서는 정상 생성됨)";
+            intentWarning = '의도 문서 생성 중 문제가 발생했습니다 (작업 지시서는 정상 생성됨)';
         }
         else {
             // Phase 16: Direct emit hook for intent-generate (replaces watcher dependency)
             emitEvent({
                 runId: run_id,
-                type: "artifact.intent_generated",
-                reason: "intent_generate",
-                paths: [path.join(basePath, "engines", "spec_high", "runs", run_id, "intent")],
-                component: "create_work_order",
-                actor: "engine",
+                type: 'artifact.intent_generated',
+                reason: 'intent_generate',
+                paths: [path.join(basePath, 'engines', 'spec_high', 'runs', run_id, 'intent')],
+                component: 'create_work_order',
+                actor: 'engine',
                 workspaceRoot: basePath,
             });
         }
     }
     catch {
-        intentWarning = "의도 문서 생성을 건너뛰었습니다 (작업 지시서는 정상 생성됨)";
+        intentWarning = '의도 문서 생성을 건너뛰었습니다 (작업 지시서는 정상 생성됨)';
     }
     // Invalidate caches after state mutation
     invalidateEngineCache(new RegExp(run_id));
@@ -133,17 +154,15 @@ export async function createWorkOrder(input) {
         bridgePath = bridgeParsed.value.bridge_path;
     }
     // Read and parse bridge file
-    const fullBridgePath = path.isAbsolute(bridgePath)
-        ? bridgePath
-        : path.join(basePath, bridgePath);
+    const fullBridgePath = path.isAbsolute(bridgePath) ? bridgePath : path.join(basePath, bridgePath);
     let bridgeData = {};
     try {
         if (fs.existsSync(fullBridgePath)) {
-            const content = fs.readFileSync(fullBridgePath, "utf-8");
-            bridgeData = fullBridgePath.endsWith(".json") ? JSON.parse(content) : parseYaml(content);
+            const content = fs.readFileSync(fullBridgePath, 'utf-8');
+            bridgeData = fullBridgePath.endsWith('.json') ? JSON.parse(content) : parseYaml(content);
             const validated = ClinicBridgeFileSchema.safeParse(bridgeData);
             if (!validated.success) {
-                console.error("[create_work_order] Bridge file validation failed, using defaults");
+                logger.error('[create_work_order] Bridge file validation failed, using defaults');
                 bridgeData = {};
             }
             else {
@@ -152,15 +171,16 @@ export async function createWorkOrder(input) {
         }
     }
     catch (e) {
-        console.error(`[create_work_order] Failed to read bridge file: ${e}`);
+        logger.error(`[create_work_order] Failed to read bridge file: ${e}`);
         bridgeData = {};
     }
     // Extract data from bridge
     const projectName = project_id;
-    const mode = runState?.mode ?? "balanced";
-    const headline = "프로젝트 구현";
-    const dg = bridgeData?.decision_guard;
-    const legacyScope = bridgeData?.scope;
+    const mode = runState?.mode ?? 'balanced';
+    const headline = '프로젝트 구현';
+    const bd = bridgeData;
+    const dg = bd.decision_guard;
+    const legacyScope = bd.scope;
     const scopeInclude = Array.isArray(dg?.allow_paths)
         ? dg.allow_paths
         : Array.isArray(legacyScope?.include)
@@ -173,18 +193,18 @@ export async function createWorkOrder(input) {
             : [];
     const doNotTouch = Array.isArray(dg?.read_only_paths)
         ? dg.read_only_paths
-        : Array.isArray(bridgeData?.do_not_touch)
-            ? bridgeData.do_not_touch
+        : Array.isArray(bd.do_not_touch)
+            ? bd.do_not_touch
             : [];
-    const verifyCriteria = Array.isArray(bridgeData?.verification?.required)
-        ? bridgeData.verification.required
-            .map((c) => (typeof c?.cmd === "string" ? c.cmd.trim() : ""))
+    const verifyCriteria = Array.isArray(bd.verification?.required)
+        ? bd.verification.required
+            .map((c) => (typeof c?.cmd === 'string' ? c.cmd.trim() : ''))
             .filter(Boolean)
-        : Array.isArray(bridgeData?.verify_criteria)
-            ? bridgeData.verify_criteria.filter((s) => typeof s === "string" && s.trim())
+        : Array.isArray(bd.verify_criteria)
+            ? bd.verify_criteria.filter((s) => typeof s === 'string' && s.trim())
             : [];
     // Add SSOT compliance verification criterion
-    verifyCriteria.push("변경 사항이 기존 SSOT 문서(docs/ssot/*.md)와 충돌하지 않는지 확인");
+    verifyCriteria.push('변경 사항이 기존 SSOT 문서(docs/ssot/*.md)와 충돌하지 않는지 확인');
     // Generate paste_to_agent text
     let pasteToAgent = generateWorkOrderText({
         projectName,
@@ -193,7 +213,7 @@ export async function createWorkOrder(input) {
         includes: scopeInclude,
         excludes: scopeExclude,
         doNotTouch,
-        verifyCriteria
+        verifyCriteria,
     });
     if (input.additional_instructions && input.additional_instructions.trim()) {
         pasteToAgent += `\n\n[추가 지시]\n- ${input.additional_instructions.trim()}\n`;
@@ -203,18 +223,18 @@ export async function createWorkOrder(input) {
         headline,
         scope: {
             include: scopeInclude,
-            exclude: scopeExclude
+            exclude: scopeExclude,
         },
         do_not_touch: doNotTouch,
         verify_criteria: verifyCriteria,
-        paste_to_agent: pasteToAgent
+        paste_to_agent: pasteToAgent,
     };
     // PR-H3: Persist repo-local SSOT work order file with work_order_id
     // Path: .vibe/state/current_work_order.json
     try {
         const workOrderId = generateWorkOrderId(run_id);
-        await writeCurrentWorkOrderState(basePath, {
-            version: "v1",
+        const persisted = await writeCurrentWorkOrderState(basePath, {
+            version: 'v1',
             work_order_id: workOrderId,
             run_id,
             created_at: new Date().toISOString(),
@@ -223,30 +243,61 @@ export async function createWorkOrder(input) {
             do_not_touch: doNotTouch,
             verify_criteria: verifyCriteria,
         });
+        if (persisted) {
+            const workOrderStatePath = path.join(basePath, '.vibe', 'state', 'current_work_order.json');
+            emitEvent({
+                runId: run_id,
+                type: 'artifact.work_order_state_written',
+                reason: 'current_work_order_saved',
+                paths: [workOrderStatePath],
+                component: 'create_work_order',
+                actor: 'system',
+                workspaceRoot: basePath,
+                note: `work_order_id=${workOrderId}`,
+            });
+            emitEvent({
+                runId: run_id,
+                type: 'signal.work_order_created',
+                reason: 'work_order_ready',
+                paths: [workOrderStatePath],
+                component: 'create_work_order',
+                actor: 'system',
+                workspaceRoot: basePath,
+                metadata: {
+                    work_order_id: workOrderId,
+                    verify_criteria_count: verifyCriteria.length,
+                    include_count: scopeInclude.length,
+                },
+            });
+        }
     }
     catch (e) {
         // FAIL-SAFE: do not block the tool if persistence fails
-        console.error("[state] failed to write current_work_order.json:", e);
+        logger.error({ err: e }, '[state] failed to write current_work_order.json');
+    }
+    try {
+        await computeAndPersistStage(basePath);
     }
+    catch { /* fail-safe */ }
     return {
         project_id,
         run_id,
         work_order: workOrder,
         paths: {
             bridge_path: bridgePath,
-            intent_dir: `engines/spec_high/runs/${run_id}/intent`
+            intent_dir: `engines/spec_high/runs/${run_id}/intent`,
         },
         // MVP: Dummy modules (full implementation uses SSOT versioning)
         modules: {
-            research: { version: "v1", fingerprint: "mvp", path: "docs/ssot/modules/research" },
-            skills: { version: "v1", fingerprint: "mvp", path: "docs/ssot/modules/skills" },
-            planning: { version: "v1", fingerprint: "mvp", path: "docs/ssot/modules/planning" }
+            research: { version: 'v1', fingerprint: 'mvp', path: 'docs/ssot/modules/research' },
+            skills: { version: 'v1', fingerprint: 'mvp', path: 'docs/ssot/modules/skills' },
+            planning: { version: 'v1', fingerprint: 'mvp', path: 'docs/ssot/modules/planning' },
         },
         next_action: {
-            tool: "vibe_pm.inspect_code",
-            reason: "구현 후 검수를 요청하세요",
-            when: "after_implementation"
+            tool: 'vibe_pm.inspect_code',
+            reason: '구현 후 검수를 요청하세요',
+            when: 'after_implementation',
         },
-        ...(intentWarning ? { warnings: [intentWarning] } : {})
+        ...(intentWarning ? { warnings: [intentWarning] } : {}),
     };
 }

package/build/mcp/tools/vibe_pm/dashboard.js

@@ -58,12 +58,12 @@ export async function dashboard(input, basePath = process.cwd()) {
                 recentDecisions: history.length,
             };
         }
-        // Filter data based on include options
+        // Filter data based on include options (defaults match schema defaults)
         const filteredData = {
             ...dashData,
-            workers: input.include_workers ? dashData.workers : [],
-            recentTasks: input.include_tasks ? dashData.recentTasks : [],
-            timeSeries: input.include_timeseries ? dashData.timeSeries : {
+            workers: (input.include_workers ?? true) ? dashData.workers : [],
+            recentTasks: (input.include_tasks ?? true) ? dashData.recentTasks : [],
+            timeSeries: (input.include_timeseries ?? false) ? dashData.timeSeries : {
                 throughput: [],
                 utilization: [],
                 queueDepth: [],

package/build/mcp/tools/vibe_pm/decision-history.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const DecisionHistoryInputSchema: z.ZodObject<{
+    action: z.ZodEnum<["query", "compact"]>;
+    run_id: z.ZodOptional<z.ZodString>;
+    event_type: z.ZodOptional<z.ZodEnum<["submit_decision", "inspect_verdict", "stage_transition"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    retention_days: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    action: "query" | "compact";
+    run_id?: string | undefined;
+    limit?: number | undefined;
+    event_type?: "submit_decision" | "inspect_verdict" | "stage_transition" | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    retention_days?: number | undefined;
+}, {
+    action: "query" | "compact";
+    run_id?: string | undefined;
+    limit?: number | undefined;
+    event_type?: "submit_decision" | "inspect_verdict" | "stage_transition" | undefined;
+    since?: string | undefined;
+    until?: string | undefined;
+    retention_days?: number | undefined;
+}>;
+export type DecisionHistoryInput = z.infer<typeof DecisionHistoryInputSchema>;
+export declare function decisionHistory(input: DecisionHistoryInput & {
+    workspace_path?: string;
+}): Promise<Record<string, unknown>>;

package/build/mcp/tools/vibe_pm/decision-history.js

@@ -0,0 +1,58 @@
+// Decision History MCP Tool
+// Query and compact the decision_log.v1.jsonl append-only event log.
+import { z } from 'zod';
+import { queryDecisionLog, compactDecisionLog, } from '../../../decision-log-reader.js';
+// ============================================================
+// Input Schema
+// ============================================================
+export const DecisionHistoryInputSchema = z.object({
+    action: z.enum(['query', 'compact']).describe('Action: query events or compact old entries'),
+    // Query filters (only used when action=query)
+    run_id: z.string().optional().describe('Filter by run_id'),
+    event_type: z
+        .enum(['submit_decision', 'inspect_verdict', 'stage_transition'])
+        .optional()
+        .describe('Filter by event type'),
+    since: z.string().optional().describe('ISO date — only events after this timestamp'),
+    until: z.string().optional().describe('ISO date — only events before this timestamp'),
+    limit: z.number().int().positive().optional().describe('Max events to return (default: 100)'),
+    // Compact params (only used when action=compact)
+    retention_days: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Days to retain (default: 30). Older entries move to archive.'),
+});
+// ============================================================
+// Handler
+// ============================================================
+export async function decisionHistory(input) {
+    const workspaceRoot = input.workspace_path ?? process.cwd();
+    if (input.action === 'query') {
+        const filters = {
+            runId: input.run_id,
+            eventType: input.event_type,
+            since: input.since,
+            until: input.until,
+            limit: input.limit ?? 100,
+        };
+        const events = queryDecisionLog(workspaceRoot, filters);
+        return {
+            action: 'query',
+            count: events.length,
+            events,
+            filters_applied: Object.fromEntries(Object.entries(filters).filter(([, v]) => v !== undefined)),
+        };
+    }
+    // action === 'compact'
+    const retentionDays = input.retention_days ?? 30;
+    const result = compactDecisionLog(workspaceRoot, retentionDays);
+    return {
+        action: 'compact',
+        retention_days: retentionDays,
+        kept: result.kept,
+        archived: result.archived,
+        archive_path: result.archivePath,
+    };
+}

package/build/mcp/tools/vibe_pm/diagrams/annotations.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeMap } from '../mapping/types.js';
+import type { DiagramBitNetAnnotations, DiagramModel } from './types.js';
+export declare function buildBitNetAnnotations(args: {
+    changeMap: ChangeMap;
+    model: DiagramModel;
+}): DiagramBitNetAnnotations;

package/build/mcp/tools/vibe_pm/diagrams/annotations.js

@@ -0,0 +1,102 @@
+function toNodeId(domain, layer, owner) {
+    const safeDomain = domain.replace(/[^a-zA-Z0-9_]/g, '_');
+    const safeLayer = layer.replace(/[^a-zA-Z0-9_]/g, '_');
+    const safeOwner = owner.replace(/[^a-zA-Z0-9_]/g, '_');
+    return `${safeDomain}.${safeLayer}.${safeOwner}`;
+}
+function severityForViolation(v) {
+    return v.severity === 'BLOCK' ? 'HIGH' : 'MEDIUM';
+}
+function toScore(severity) {
+    if (severity === 'HIGH')
+        return 5;
+    if (severity === 'MEDIUM')
+        return 2;
+    return 1;
+}
+function pushAnnotation(list, counts, row) {
+    const index = list.length + 1;
+    const id = `RISK-${String(index).padStart(3, '0')}`;
+    const score = toScore(row.severity);
+    list.push({ id, score, ...row });
+    if (row.severity === 'HIGH')
+        counts.high += 1;
+    else if (row.severity === 'MEDIUM')
+        counts.medium += 1;
+    else
+        counts.low += 1;
+}
+export function buildBitNetAnnotations(args) {
+    const fileToNode = new Map();
+    for (const item of args.changeMap.mapped) {
+        if (!fileToNode.has(item.file)) {
+            fileToNode.set(item.file, toNodeId(item.domain_id, item.layer, item.owner_id));
+        }
+    }
+    const annotations = [];
+    const counts = { high: 0, medium: 0, low: 0 };
+    for (const violation of args.changeMap.violations) {
+        const severity = severityForViolation(violation);
+        const nodeId = fileToNode.get(violation.file);
+        pushAnnotation(annotations, counts, {
+            type: 'violation',
+            severity,
+            title: `Violation: ${violation.code}`,
+            description: violation.detail,
+            targets: nodeId
+                ? [{ kind: 'node', node_id: nodeId, label: nodeId.split('.').slice(-1)[0] ?? nodeId }]
+                : [{ kind: 'file', label: violation.file }],
+            tags: [violation.code],
+        });
+    }
+    const crossDomainEdges = args.model.edges.filter(edge => edge.stereotype === 'CROSS_DOMAIN');
+    if (crossDomainEdges.length > 0) {
+        pushAnnotation(annotations, counts, {
+            type: 'cross_domain',
+            severity: crossDomainEdges.length > 2 ? 'HIGH' : 'MEDIUM',
+            title: `Cross-domain dependencies (${crossDomainEdges.length})`,
+            description: 'Change set crosses bounded domains and needs extra review.',
+            targets: crossDomainEdges.slice(0, 5).map(edge => ({
+                kind: 'edge',
+                label: `${edge.from_node_id} -> ${edge.to_node_id}`,
+            })),
+            tags: ['CROSS_DOMAIN'],
+        });
+    }
+    if (args.changeMap.unmapped.length > 0) {
+        pushAnnotation(annotations, counts, {
+            type: 'unmapped',
+            severity: args.changeMap.unmapped.length >= 3 ? 'MEDIUM' : 'LOW',
+            title: `Unmapped files (${args.changeMap.unmapped.length})`,
+            description: 'Some changed files are not mapped to a stable owner node.',
+            targets: args.changeMap.unmapped.slice(0, 5).map(item => ({
+                kind: 'file',
+                label: item.file,
+            })),
+            tags: ['UNMAPPED'],
+        });
+    }
+    const lowConfidenceNodes = args.model.nodes.filter(node => node.confidence > 0 && node.confidence < 0.6);
+    if (lowConfidenceNodes.length > 0) {
+        pushAnnotation(annotations, counts, {
+            type: 'confidence',
+            severity: 'LOW',
+            title: `Low-confidence nodes (${lowConfidenceNodes.length})`,
+            description: 'Mapping confidence is low for a subset of touched nodes.',
+            targets: lowConfidenceNodes.slice(0, 5).map(node => ({
+                kind: 'node',
+                node_id: node.node_id,
+                label: node.label,
+            })),
+            tags: ['LOW_CONFIDENCE'],
+        });
+    }
+    const riskScore = counts.high * 5 + counts.medium * 2 + counts.low;
+    return {
+        summary: {
+            risk_score: riskScore,
+            risk_counts: counts,
+        },
+        annotations,
+    };
+}