@webpresso/agent-kit 0.21.0

package/dist/esm/blueprint/export/spec-kit/constitution.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedBlueprintForDb } from '#db/parser/blueprint-db-parser';
+/**
+ * Emit constitution.md — Repo-level principles from VISION.md + CLAUDE.md.
+ * Pure function, <40 LOC.
+ */
+export declare function emitConstitution(parsed: ParsedBlueprintForDb, repoRoot: string): string;
+//# sourceMappingURL=constitution.d.ts.map

package/dist/esm/blueprint/export/spec-kit/constitution.js

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Emit constitution.md — Repo-level principles from VISION.md + CLAUDE.md.
+ * Pure function, <40 LOC.
+ */
+export function emitConstitution(parsed, repoRoot) {
+    const visionSection = readFirstSection(path.join(repoRoot, 'VISION.md'));
+    const claudeSection = readFirstBulletListOrSection(path.join(repoRoot, 'CLAUDE.md'));
+    const sections = ['# Repository Constitution', ''];
+    if (visionSection) {
+        sections.push(visionSection, '');
+    }
+    else {
+        sections.push(`## Vision\n\n${parsed.title}`, '');
+    }
+    sections.push('## Key Principles', '');
+    if (claudeSection) {
+        sections.push(claudeSection);
+    }
+    else {
+        sections.push('_See CLAUDE.md for project conventions._');
+    }
+    return sections.join('\n');
+}
+function readFirstSection(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const lines = content.split('\n');
+        // Skip frontmatter
+        let start = 0;
+        if (lines[0] === '---') {
+            const end = lines.indexOf('---', 1);
+            start = end > 0 ? end + 1 : 0;
+        }
+        const body = lines.slice(start).join('\n').trimStart();
+        // Return up to the second ## heading or first 20 lines
+        const match = body.match(/^(#{1,2} .+(?:\n(?!#{1,2} ).+)*)/);
+        const fallback = body.split('\n').slice(0, 20).join('\n').trim();
+        return match?.[1]?.trim() ?? (fallback.length > 0 ? fallback : null);
+    }
+    catch {
+        return null;
+    }
+}
+function readFirstBulletListOrSection(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        // Find first ## heading and return that section (up to next ##)
+        const match = content.match(/^## .+\n([\s\S]*?)(?=\n## |\n# |$)/m);
+        if (match)
+            return match[0].trim();
+        // Fallback: first bullet list block
+        const bullets = content.match(/(?:^- .+\n)+/m);
+        return bullets ? bullets[0].trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=constitution.js.map

package/dist/esm/blueprint/export/spec-kit/index.d.ts

@@ -0,0 +1,13 @@
+import type { ParsedBlueprintForDb } from '#db/parser/blueprint-db-parser';
+export interface SpecKitBundle {
+    readonly spec: string;
+    readonly plan: string;
+    readonly tasks: string;
+    readonly constitution: string;
+}
+/**
+ * Convert a parsed blueprint to spec-kit's 4-file structure.
+ * Each file is a non-empty string; no content is duplicated across files.
+ */
+export declare function blueprintToSpecKit(parsed: ParsedBlueprintForDb, repoRoot: string): SpecKitBundle;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/blueprint/export/spec-kit/index.js

@@ -0,0 +1,17 @@
+import { emitConstitution } from './constitution.js';
+import { emitPlan } from './plan.js';
+import { emitSpec } from './spec.js';
+import { emitTasks } from './tasks.js';
+/**
+ * Convert a parsed blueprint to spec-kit's 4-file structure.
+ * Each file is a non-empty string; no content is duplicated across files.
+ */
+export function blueprintToSpecKit(parsed, repoRoot) {
+    return {
+        spec: emitSpec(parsed),
+        plan: emitPlan(parsed),
+        tasks: emitTasks(parsed),
+        constitution: emitConstitution(parsed, repoRoot),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/blueprint/export/spec-kit/plan.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedBlueprintForDb } from '#db/parser/blueprint-db-parser';
+/**
+ * Emit plan.md — Implementation Plan referencing spec.md, grouped by wave.
+ * Pure function, <40 LOC.
+ */
+export declare function emitPlan(parsed: ParsedBlueprintForDb): string;
+//# sourceMappingURL=plan.d.ts.map

package/dist/esm/blueprint/export/spec-kit/plan.js

@@ -0,0 +1,43 @@
+import { titleLine } from './_field-map.js';
+/**
+ * Emit plan.md — Implementation Plan referencing spec.md, grouped by wave.
+ * Pure function, <40 LOC.
+ */
+export function emitPlan(parsed) {
+    const sections = [
+        titleLine(parsed, 'Implementation Plan'),
+        '',
+        '> See [spec.md](spec.md) for full specification.',
+        '',
+        '## Architecture',
+        '',
+        parsed.complexity ? `Complexity: **${parsed.complexity}**` : '_No architecture notes._',
+        '',
+        '## Waves',
+        '',
+    ];
+    if (parsed.tasks.length === 0) {
+        sections.push('_No tasks defined._');
+        return sections.join('\n');
+    }
+    const byWave = groupByWave(parsed.tasks);
+    for (const [wave, tasks] of byWave) {
+        sections.push(`### ${wave}`, '');
+        for (const task of tasks) {
+            sections.push(`- **${task.taskId}**: ${task.title}`);
+        }
+        sections.push('');
+    }
+    return sections.join('\n').trimEnd() + '\n';
+}
+function groupByWave(tasks) {
+    const map = new Map();
+    for (const task of tasks) {
+        const wave = task.wave ?? 'Wave 1';
+        const bucket = map.get(wave) ?? [];
+        bucket.push(task);
+        map.set(wave, bucket);
+    }
+    return map;
+}
+//# sourceMappingURL=plan.js.map

package/dist/esm/blueprint/export/spec-kit/spec.d.ts

@@ -0,0 +1,7 @@
+import type { ParsedBlueprintForDb } from '#db/parser/blueprint-db-parser';
+/**
+ * Emit spec.md — Feature Specification with User Scenarios, Requirements, Review Checklist.
+ * Pure function, <40 LOC.
+ */
+export declare function emitSpec(parsed: ParsedBlueprintForDb): string;
+//# sourceMappingURL=spec.d.ts.map

package/dist/esm/blueprint/export/spec-kit/spec.js

@@ -0,0 +1,35 @@
+import { overviewSection, REVIEW_CHECKLIST, titleLine } from './_field-map.js';
+/**
+ * Emit spec.md — Feature Specification with User Scenarios, Requirements, Review Checklist.
+ * Pure function, <40 LOC.
+ */
+export function emitSpec(parsed) {
+    const sections = [titleLine(parsed, 'Specification'), ''];
+    sections.push(overviewSection(parsed), '');
+    sections.push('## User Scenarios', '');
+    if (parsed.tasks.length === 0) {
+        sections.push('_No tasks defined._');
+    }
+    else {
+        for (const task of parsed.tasks) {
+            const criterion = task.acceptanceCriteria[0] ?? task.title;
+            sections.push(`- A developer can ${criterion.replace(/^[-*]\s*/, '').toLowerCase()}`);
+        }
+    }
+    sections.push('');
+    sections.push('## Requirements', '');
+    if (parsed.risks.length === 0) {
+        sections.push('_No risks documented._');
+    }
+    else {
+        sections.push('The system must handle:');
+        sections.push('');
+        for (const risk of parsed.risks) {
+            sections.push(`- **${risk.severity}**: ${risk.description}`);
+        }
+    }
+    sections.push('');
+    sections.push(REVIEW_CHECKLIST);
+    return sections.join('\n');
+}
+//# sourceMappingURL=spec.js.map

package/dist/esm/blueprint/export/spec-kit/tasks.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedBlueprintForDb } from '#db/parser/blueprint-db-parser';
+export declare function emitTasks(parsed: ParsedBlueprintForDb): string;
+//# sourceMappingURL=tasks.d.ts.map

package/dist/esm/blueprint/export/spec-kit/tasks.js

@@ -0,0 +1,32 @@
+import { taskIdLabel, titleLine } from './_field-map.js';
+export function emitTasks(parsed) {
+    const sections = [titleLine(parsed, 'Tasks'), ''];
+    if (parsed.tasks.length === 0) {
+        sections.push('_No tasks defined._');
+        return sections.join('\n');
+    }
+    const byWave = parsed.tasks.reduce((m, t) => {
+        const w = t.wave ?? 'Wave 1';
+        m.set(w, [...(m.get(w) ?? []), t]);
+        return m;
+    }, new Map());
+    let i = 0;
+    for (const [wave, tasks] of byWave) {
+        const parallel = tasks.length > 1;
+        sections.push(`### ${wave}`, '');
+        for (const task of tasks) {
+            const p = parallel ? ' [P]' : '';
+            const ac = task.acceptanceCriteria[0] ?? '';
+            const files = task.files.map((f) => f.filePath).join(', ');
+            sections.push(`- [ ] ${taskIdLabel(i)}: ${task.title}${p}`);
+            if (ac)
+                sections.push(`  - Acceptance: ${ac.replace(/^[-*]\s*/, '')}`);
+            if (files)
+                sections.push(`  - Files: ${files}`);
+            i++;
+        }
+        sections.push('');
+    }
+    return sections.join('\n').trimEnd() + '\n';
+}
+//# sourceMappingURL=tasks.js.map

package/dist/esm/blueprint/freshness.d.ts

@@ -0,0 +1,78 @@
+/**
+ * HEAD-pinned projection freshness (F11 / E11 / R9).
+ *
+ * The blueprint markdown directory is git-tracked. A `git checkout other-branch`
+ * flips on-disk files without touching the SQLite projection, so cached MCP
+ * reads can silently return rows for the wrong commit. This module pins HEAD
+ * at ingest time and refuses cached reads when HEAD has moved.
+ *
+ * Storage: a JSON sidecar at `<dbPath>.meta.json`. The sidecar is intentionally
+ * decoupled from the SQLite schema so this task does not touch migrations or
+ * collide with Task 1.1's path policy. The sidecar is rebuilt by the ingester
+ * and may be safely deleted — `checkFreshness` will return
+ * `next_action: 'reingest_project'`.
+ *
+ * Non-goals here:
+ *   - No long-lived cache. Each call re-reads the sidecar and re-runs
+ *     `git rev-parse HEAD`.
+ *   - No watcher / no background invalidation.
+ *   - No platform-canonical sync.
+ *
+ * Consumers: `assembleBlueprintContext` (this task) and Task 2.2's MCP
+ * handlers (`wp_blueprint_list`, `_get`, `_context`).
+ */
+import { type NextAction } from './next-action.js';
+/**
+ * The minimal `BlueprintProjectRef` slice this module needs. Task 1.2 owns
+ * the full `BlueprintProjectRef`; we depend only on the fields that drive
+ * freshness so the helper stays usable without the full resolver.
+ */
+export interface BlueprintProjectLike {
+    readonly worktree_path: string;
+    readonly db_path: string;
+}
+export interface ProjectionMetadata {
+    /**
+     * `git rev-parse HEAD` captured at ingest time, or `null` when the worktree
+     * was not a git repo.
+     */
+    readonly head_at_ingest: string | null;
+    /** Epoch milliseconds at which the projection was last written. */
+    readonly ingested_at: number;
+}
+export type FreshnessResult = {
+    readonly ok: true;
+    readonly head: string | null;
+    readonly ingestedAt: number;
+} | {
+    readonly ok: false;
+    readonly next_action: NextAction;
+};
+export interface RecordProjectionMetadataInput {
+    readonly dbPath: string;
+    readonly cwd: string;
+    readonly ingestedAt: number;
+}
+/** Run `git rev-parse HEAD` in cwd; return null when not a git repo / no commits. */
+export declare function readCurrentHead(cwd: string): string | null;
+/** Read the sidecar metadata for a projection DB. Returns null on miss/parse-failure. */
+export declare function readProjectionMetadata(dbPath: string): ProjectionMetadata | null;
+/**
+ * Write the sidecar metadata. Caller (the ingester) supplies the cwd that was
+ * just ingested so we capture the right HEAD.
+ */
+export declare function recordProjectionMetadata(input: RecordProjectionMetadataInput): ProjectionMetadata;
+/**
+ * Decide whether the projection DB is fresh for the given worktree.
+ *
+ * Order of checks:
+ *   1. DB file missing → `rebuild_db`.
+ *   2. Sidecar missing → `reingest_project`.
+ *   3. HEAD recorded ≠ HEAD now → `reingest_project`.
+ *   4. Otherwise fresh.
+ *
+ * `null === null` is treated as fresh: a non-git worktree had no HEAD at
+ * ingest and still has none.
+ */
+export declare function checkFreshness(project: BlueprintProjectLike): FreshnessResult;
+//# sourceMappingURL=freshness.d.ts.map

package/dist/esm/blueprint/freshness.js

@@ -0,0 +1,127 @@
+/**
+ * HEAD-pinned projection freshness (F11 / E11 / R9).
+ *
+ * The blueprint markdown directory is git-tracked. A `git checkout other-branch`
+ * flips on-disk files without touching the SQLite projection, so cached MCP
+ * reads can silently return rows for the wrong commit. This module pins HEAD
+ * at ingest time and refuses cached reads when HEAD has moved.
+ *
+ * Storage: a JSON sidecar at `<dbPath>.meta.json`. The sidecar is intentionally
+ * decoupled from the SQLite schema so this task does not touch migrations or
+ * collide with Task 1.1's path policy. The sidecar is rebuilt by the ingester
+ * and may be safely deleted — `checkFreshness` will return
+ * `next_action: 'reingest_project'`.
+ *
+ * Non-goals here:
+ *   - No long-lived cache. Each call re-reads the sidecar and re-runs
+ *     `git rev-parse HEAD`.
+ *   - No watcher / no background invalidation.
+ *   - No platform-canonical sync.
+ *
+ * Consumers: `assembleBlueprintContext` (this task) and Task 2.2's MCP
+ * handlers (`wp_blueprint_list`, `_get`, `_context`).
+ */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { makeNextAction } from './next-action.js';
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+function sidecarPath(dbPath) {
+    return `${dbPath}.meta.json`;
+}
+/** Run `git rev-parse HEAD` in cwd; return null when not a git repo / no commits. */
+export function readCurrentHead(cwd) {
+    try {
+        const sha = execFileSync('git', ['rev-parse', 'HEAD'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            timeout: 5_000,
+        }).trim();
+        return sha.length > 0 ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProjectionMetadata(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const obj = value;
+    const headOk = obj.head_at_ingest === null || typeof obj.head_at_ingest === 'string';
+    const tsOk = typeof obj.ingested_at === 'number' && Number.isFinite(obj.ingested_at);
+    return headOk && tsOk;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Read the sidecar metadata for a projection DB. Returns null on miss/parse-failure. */
+export function readProjectionMetadata(dbPath) {
+    const file = sidecarPath(dbPath);
+    if (!existsSync(file))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    return isProjectionMetadata(parsed) ? parsed : null;
+}
+/**
+ * Write the sidecar metadata. Caller (the ingester) supplies the cwd that was
+ * just ingested so we capture the right HEAD.
+ */
+export function recordProjectionMetadata(input) {
+    const metadata = {
+        head_at_ingest: readCurrentHead(input.cwd),
+        ingested_at: input.ingestedAt,
+    };
+    writeFileSync(sidecarPath(input.dbPath), JSON.stringify(metadata, null, 2) + '\n', 'utf8');
+    return metadata;
+}
+/**
+ * Decide whether the projection DB is fresh for the given worktree.
+ *
+ * Order of checks:
+ *   1. DB file missing → `rebuild_db`.
+ *   2. Sidecar missing → `reingest_project`.
+ *   3. HEAD recorded ≠ HEAD now → `reingest_project`.
+ *   4. Otherwise fresh.
+ *
+ * `null === null` is treated as fresh: a non-git worktree had no HEAD at
+ * ingest and still has none.
+ */
+export function checkFreshness(project) {
+    if (!existsSync(project.db_path)) {
+        return {
+            ok: false,
+            next_action: makeNextAction('rebuild_db', `Projection DB missing at ${project.db_path}; run ingest to rebuild.`),
+        };
+    }
+    const metadata = readProjectionMetadata(project.db_path);
+    if (metadata === null) {
+        return {
+            ok: false,
+            next_action: makeNextAction('reingest_project', `Projection metadata missing for ${project.db_path}; re-ingest the project.`),
+        };
+    }
+    const current = readCurrentHead(project.worktree_path);
+    if (metadata.head_at_ingest !== current) {
+        return {
+            ok: false,
+            next_action: makeNextAction('reingest_project', `HEAD changed since ingest (was ${metadata.head_at_ingest ?? 'none'}, now ${current ?? 'none'}); re-ingest the project.`),
+        };
+    }
+    return { ok: true, head: current, ingestedAt: metadata.ingested_at };
+}
+//# sourceMappingURL=freshness.js.map

package/dist/esm/blueprint/graph/index.d.ts

@@ -0,0 +1,5 @@
+export { graphEdgeSchema, graphEdgeTypeSchema, graphLayoutSchema, graphNodeSchema, graphNodeTypeSchema, normalizedGraphSchema, type GraphEdge, type GraphEdgeType, type GraphLayout, type GraphNode, type GraphNodeType, type NormalizedGraph, } from './schema.js';
+export { parseMermaidToGraph } from './mermaid-parser.js';
+export { serializeGraphToMermaid } from './mermaid-serializer.js';
+export { taskGraphToNormalizedGraph } from './task-graph-adapter.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/blueprint/graph/index.js

@@ -0,0 +1,5 @@
+export { graphEdgeSchema, graphEdgeTypeSchema, graphLayoutSchema, graphNodeSchema, graphNodeTypeSchema, normalizedGraphSchema, } from './schema.js';
+export { parseMermaidToGraph } from './mermaid-parser.js';
+export { serializeGraphToMermaid } from './mermaid-serializer.js';
+export { taskGraphToNormalizedGraph } from './task-graph-adapter.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/blueprint/graph/mermaid-parser.d.ts

@@ -0,0 +1,3 @@
+import { type NormalizedGraph } from '#graph/schema';
+export declare function parseMermaidToGraph(mermaid: string): NormalizedGraph;
+//# sourceMappingURL=mermaid-parser.d.ts.map

package/dist/esm/blueprint/graph/mermaid-parser.js

@@ -0,0 +1,93 @@
+import { normalizedGraphSchema, } from '#graph/schema';
+const DIRECTION_LINE = /^graph\s+(TD|LR|BT|RL)$/;
+const EDGE_WITH_LABEL = /^([A-Za-z0-9_-]+)(?:\[([^\]]+)\])?\s*--\|([^|]+)\|\s*([A-Za-z0-9_-]+)(?:\[([^\]]+)\])?$/;
+const EDGE_SIMPLE = /^([A-Za-z0-9_-]+)(?:\[([^\]]+)\])?\s*-->\s*([A-Za-z0-9_-]+)(?:\[([^\]]+)\])?$/;
+const NODE_ONLY = /^([A-Za-z0-9_-]+)\[([^\]]+)\]$/;
+function upsertNode(nodes, id, label) {
+    const existing = nodes.get(id);
+    if (existing) {
+        if (label && existing.label === id) {
+            nodes.set(id, { ...existing, label });
+        }
+        return;
+    }
+    nodes.set(id, {
+        id,
+        type: 'task',
+        label: label ?? id,
+    });
+}
+function parseEdge(line, nodes, edges) {
+    const labeled = line.match(EDGE_WITH_LABEL);
+    if (labeled) {
+        const source = labeled[1] ?? '';
+        const sourceLabel = labeled[2];
+        const edgeLabel = (labeled[3] ?? '').trim();
+        const target = labeled[4] ?? '';
+        const targetLabel = labeled[5];
+        upsertNode(nodes, source, sourceLabel);
+        upsertNode(nodes, target, targetLabel);
+        edges.push({
+            source,
+            target,
+            type: 'depends_on',
+            label: edgeLabel,
+        });
+        return true;
+    }
+    const simple = line.match(EDGE_SIMPLE);
+    if (!simple) {
+        return false;
+    }
+    const source = simple[1] ?? '';
+    const sourceLabel = simple[2];
+    const target = simple[3] ?? '';
+    const targetLabel = simple[4];
+    upsertNode(nodes, source, sourceLabel);
+    upsertNode(nodes, target, targetLabel);
+    edges.push({
+        source,
+        target,
+        type: 'depends_on',
+    });
+    return true;
+}
+export function parseMermaidToGraph(mermaid) {
+    const lines = mermaid
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith('%%'))
+        .map((line) => (line.endsWith(';') ? line.slice(0, -1).trim() : line));
+    if (!lines.length) {
+        throw new Error('Mermaid input is empty');
+    }
+    const directionMatch = lines[0]?.match(DIRECTION_LINE);
+    if (!directionMatch?.[1]) {
+        throw new Error('Mermaid must start with "graph <direction>"');
+    }
+    const direction = directionMatch[1];
+    const nodes = new Map();
+    const edges = [];
+    for (const line of lines.slice(1)) {
+        if (line === '' || line.startsWith('subgraph') || line === 'end') {
+            continue;
+        }
+        if (parseEdge(line, nodes, edges)) {
+            continue;
+        }
+        const nodeOnly = line.match(NODE_ONLY);
+        if (nodeOnly) {
+            const id = nodeOnly[1] ?? '';
+            const label = nodeOnly[2] ?? id;
+            upsertNode(nodes, id, label);
+            continue;
+        }
+        throw new Error(`Unsupported Mermaid line: ${line}`);
+    }
+    return normalizedGraphSchema.parse({
+        nodes: [...nodes.values()],
+        edges,
+        layout: { direction },
+    });
+}
+//# sourceMappingURL=mermaid-parser.js.map

package/dist/esm/blueprint/graph/mermaid-serializer.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedGraph } from '#graph/schema';
+export declare function serializeGraphToMermaid(graph: NormalizedGraph): string;
+//# sourceMappingURL=mermaid-serializer.d.ts.map

package/dist/esm/blueprint/graph/mermaid-serializer.js

@@ -0,0 +1,20 @@
+function escapeLabel(label) {
+    return label.replace(/\[/g, '(').replace(/\]/g, ')');
+}
+export function serializeGraphToMermaid(graph) {
+    const direction = graph.layout?.direction ?? 'TD';
+    const lines = [`graph ${direction}`];
+    for (const node of graph.nodes) {
+        lines.push(`  ${node.id}[${escapeLabel(node.label)}]`);
+    }
+    for (const edge of graph.edges) {
+        if (edge.label) {
+            lines.push(`  ${edge.source} --|${escapeLabel(edge.label)}| ${edge.target}`);
+        }
+        else {
+            lines.push(`  ${edge.source} --> ${edge.target}`);
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+//# sourceMappingURL=mermaid-serializer.js.map

package/dist/esm/blueprint/graph/schema.d.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+export declare const graphNodeTypeSchema: z.ZodEnum<{
+    blueprint: "blueprint";
+    decision: "decision";
+    task: "task";
+    external: "external";
+    milestone: "milestone";
+    tech_debt: "tech_debt";
+}>;
+export declare const graphEdgeTypeSchema: z.ZodEnum<{
+    depends_on: "depends_on";
+    blocks: "blocks";
+    relates_to: "relates_to";
+}>;
+export declare const graphNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        blueprint: "blueprint";
+        decision: "decision";
+        task: "task";
+        external: "external";
+        milestone: "milestone";
+        tech_debt: "tech_debt";
+    }>;
+    label: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const graphEdgeSchema: z.ZodObject<{
+    source: z.ZodString;
+    target: z.ZodString;
+    type: z.ZodEnum<{
+        depends_on: "depends_on";
+        blocks: "blocks";
+        relates_to: "relates_to";
+    }>;
+    label: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const graphLayoutSchema: z.ZodObject<{
+    direction: z.ZodDefault<z.ZodEnum<{
+        TD: "TD";
+        LR: "LR";
+        BT: "BT";
+        RL: "RL";
+    }>>;
+    rankdir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const normalizedGraphSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            blueprint: "blueprint";
+            decision: "decision";
+            task: "task";
+            external: "external";
+            milestone: "milestone";
+            tech_debt: "tech_debt";
+        }>;
+        label: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        type: z.ZodEnum<{
+            depends_on: "depends_on";
+            blocks: "blocks";
+            relates_to: "relates_to";
+        }>;
+        label: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    layout: z.ZodOptional<z.ZodObject<{
+        direction: z.ZodDefault<z.ZodEnum<{
+            TD: "TD";
+            LR: "LR";
+            BT: "BT";
+            RL: "RL";
+        }>>;
+        rankdir: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type GraphNodeType = z.infer<typeof graphNodeTypeSchema>;
+export type GraphEdgeType = z.infer<typeof graphEdgeTypeSchema>;
+export type GraphNode = z.infer<typeof graphNodeSchema>;
+export type GraphEdge = z.infer<typeof graphEdgeSchema>;
+export type GraphLayout = z.infer<typeof graphLayoutSchema>;
+export type NormalizedGraph = z.infer<typeof normalizedGraphSchema>;
+//# sourceMappingURL=schema.d.ts.map