@webpresso/agent-kit 0.21.0

package/dist/esm/blueprint/db/ingester.js

@@ -0,0 +1,307 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { Database } from '#db/sqlite.js';
+import { glob } from 'glob';
+import { parseBlueprintForDb } from './parser/blueprint-db-parser.js';
+import { parseTechDebtForDb } from './parser/tech-debt-db-parser.js';
+import { resolvesCrossRepo } from '#cross-repo/resolver.js';
+import { resolveBlueprintRoot } from '#utils/blueprint-root.js';
+import { resolveTechDebtRoot } from '#utils/tech-debt-root.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function deriveSlugFromBlueprintPath(filePath) {
+    // blueprints/<status>/<slug>/_overview.md  →  slug is the grandparent dir name
+    return path.basename(path.dirname(filePath));
+}
+function deriveSlugFromTechDebtPath(filePath) {
+    // tech-debt/<status>/h-NNN-slug.md  →  slug is the basename without extension
+    return path.basename(filePath, '.md');
+}
+function existingBlueprintHash(db, slug) {
+    const row = db
+        .prepare('SELECT content_hash FROM blueprints WHERE slug = ?')
+        .get(slug);
+    return row?.content_hash ?? null;
+}
+function existingTechDebtHash(db, slug) {
+    const row = db
+        .prepare('SELECT content_hash FROM tech_debt_items WHERE slug = ?')
+        .get(slug);
+    return row?.content_hash ?? null;
+}
+// ---------------------------------------------------------------------------
+// Cross-org redaction logic
+// ---------------------------------------------------------------------------
+/**
+ * Returns true when the cross-org dependency should be allowed (not redacted).
+ * Delegates to `resolvesCrossRepo` which enforces the both-sides allowlist rule.
+ */
+function isAllowedCrossOrg(db, sourceOrg, targetOrg) {
+    const rows = db
+        .prepare('SELECT source_org, permitted_org FROM correlate_allowlist')
+        .all();
+    return resolvesCrossRepo(sourceOrg, targetOrg, rows);
+}
+// ---------------------------------------------------------------------------
+// Blueprint ingester
+// ---------------------------------------------------------------------------
+function upsertBlueprint(db, filePath, _cwd) {
+    const content = readFileSync(filePath, 'utf8');
+    const slug = deriveSlugFromBlueprintPath(filePath);
+    const parsed = parseBlueprintForDb(content, filePath, slug);
+    const now = Date.now();
+    const upsertBp = db.prepare(`INSERT INTO blueprints
+       (slug, title, status, complexity, owner, created, last_updated, completed_at,
+        progress_pct, progress_text, file_path, byte_size, content_hash, ingested_at,
+        organization, visibility)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(slug) DO UPDATE SET
+       title        = excluded.title,
+       status       = excluded.status,
+       complexity   = excluded.complexity,
+       owner        = excluded.owner,
+       created      = excluded.created,
+       last_updated = excluded.last_updated,
+       completed_at = excluded.completed_at,
+       progress_pct = excluded.progress_pct,
+       progress_text = excluded.progress_text,
+       file_path    = excluded.file_path,
+       byte_size    = excluded.byte_size,
+       content_hash = excluded.content_hash,
+       ingested_at  = excluded.ingested_at,
+       organization = excluded.organization,
+       visibility   = excluded.visibility`);
+    const deleteRelated = (table, col) => {
+        db.prepare(`DELETE FROM ${table} WHERE ${col} = ?`).run(slug);
+    };
+    const insertTag = db.prepare('INSERT OR IGNORE INTO tags (slug) VALUES (?)');
+    const insertBlueprintTag = db.prepare('INSERT OR IGNORE INTO blueprint_tags (blueprint_slug, tag_slug) VALUES (?, ?)');
+    const insertDep = db.prepare(`INSERT OR IGNORE INTO blueprint_dependencies
+       (blueprint_slug, depends_on_slug, is_resolved) VALUES (?, ?, ?)`);
+    const insertCrossRepoDep = db.prepare(`INSERT OR REPLACE INTO cross_repo_dependencies
+       (blueprint_slug, target_repo, target_slug, target_slug_hash, resolved_status,
+        is_cross_org, is_redacted)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`);
+    const insertTask = db.prepare(`INSERT INTO tasks
+       (blueprint_slug, task_id, wave, title, status, description,
+        steps_tdd, acceptance_json, byte_size)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const insertTaskDep = db.prepare('INSERT OR IGNORE INTO task_dependencies (task_id, depends_on_task_id) VALUES (?, ?)');
+    const insertTaskFile = db.prepare('INSERT INTO task_files (task_id, file_path, op) VALUES (?, ?, ?)');
+    const insertRisk = db.prepare(`INSERT INTO risks (blueprint_slug, risk_id, severity, description, mitigation)
+     VALUES (?, ?, ?, ?, ?)`);
+    const insertEdge = db.prepare(`INSERT INTO edge_cases (blueprint_slug, edge_id, severity, description, mitigation)
+     VALUES (?, ?, ?, ?, ?)`);
+    db.transaction(() => {
+        upsertBp.run(parsed.slug, parsed.title, parsed.status, parsed.complexity, parsed.owner, parsed.created, parsed.lastUpdated, parsed.completedAt, null, // progress_pct
+        null, // progress_text
+        parsed.filePath, parsed.byteSize, parsed.contentHash, now, parsed.organization, parsed.visibility);
+        // Clear and reinsert all related data
+        deleteRelated('blueprint_tags', 'blueprint_slug');
+        deleteRelated('blueprint_dependencies', 'blueprint_slug');
+        deleteRelated('cross_repo_dependencies', 'blueprint_slug');
+        deleteRelated('tasks', 'blueprint_slug');
+        deleteRelated('risks', 'blueprint_slug');
+        deleteRelated('edge_cases', 'blueprint_slug');
+        for (const tag of parsed.tags) {
+            insertTag.run(tag);
+            insertBlueprintTag.run(slug, tag);
+        }
+        for (const depSlug of parsed.dependsOn) {
+            insertDep.run(slug, depSlug, 0);
+        }
+        for (const crossDep of parsed.crossRepoDependsOn) {
+            const targetOrg = crossDep.repo.split('/')[0] ?? 'unknown';
+            const isCrossOrg = targetOrg !== parsed.organization ? 1 : 0;
+            const shouldRedact = isCrossOrg === 1 && !isAllowedCrossOrg(db, parsed.organization, targetOrg);
+            let targetSlug = crossDep.slug;
+            let targetSlugHash = null;
+            if (shouldRedact && crossDep.slug !== null) {
+                targetSlugHash = createHash('sha256').update(crossDep.slug).digest('hex');
+                targetSlug = null;
+            }
+            insertCrossRepoDep.run(slug, crossDep.repo, targetSlug, targetSlugHash, crossDep.requireStatus, isCrossOrg, shouldRedact ? 1 : 0);
+        }
+        // Build a task_id → DB row id map for dependency resolution
+        const taskDbIdMap = new Map();
+        for (const task of parsed.tasks) {
+            const info = insertTask.run(slug, task.taskId, task.wave, task.title, task.status, task.description, null, // steps_tdd
+            task.acceptanceCriteria.length > 0 ? JSON.stringify(task.acceptanceCriteria) : null, null);
+            const rowId = Number(info.lastInsertRowid);
+            taskDbIdMap.set(task.taskId, rowId);
+            for (const f of task.files) {
+                insertTaskFile.run(rowId, f.filePath, f.op);
+            }
+        }
+        // Insert task dependencies now that all tasks are stored
+        for (const task of parsed.tasks) {
+            const taskRowId = taskDbIdMap.get(task.taskId);
+            if (taskRowId === undefined)
+                continue;
+            for (const depId of task.dependsOnTaskIds) {
+                const depRowId = taskDbIdMap.get(depId);
+                if (depRowId === undefined)
+                    continue;
+                insertTaskDep.run(taskRowId, depRowId);
+            }
+        }
+        for (const risk of parsed.risks) {
+            insertRisk.run(slug, risk.riskId, risk.severity, risk.description, risk.mitigation);
+        }
+        for (const edge of parsed.edgeCases) {
+            insertEdge.run(slug, edge.edgeId, edge.severity, edge.description, edge.mitigation);
+        }
+    })();
+}
+function upsertTechDebt(db, filePath, _cwd) {
+    const content = readFileSync(filePath, 'utf8');
+    const slug = deriveSlugFromTechDebtPath(filePath);
+    const parsed = parseTechDebtForDb(content, filePath, slug);
+    const upsertItem = db.prepare(`INSERT INTO tech_debt_items
+       (slug, status, severity, category, review_cadence, last_reviewed, created,
+        next_review, base_priority, file_path, byte_size, content_hash,
+        organization, visibility)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(slug) DO UPDATE SET
+       status         = excluded.status,
+       severity       = excluded.severity,
+       category       = excluded.category,
+       review_cadence = excluded.review_cadence,
+       last_reviewed  = excluded.last_reviewed,
+       created        = excluded.created,
+       next_review    = excluded.next_review,
+       base_priority  = excluded.base_priority,
+       file_path      = excluded.file_path,
+       byte_size      = excluded.byte_size,
+       content_hash   = excluded.content_hash,
+       organization   = excluded.organization,
+       visibility     = excluded.visibility`);
+    const deleteLinked = db.prepare('DELETE FROM tech_debt_linked_blueprints WHERE techdebt_slug = ?');
+    const insertLinked = db.prepare('INSERT OR IGNORE INTO tech_debt_linked_blueprints (techdebt_slug, blueprint_slug) VALUES (?, ?)');
+    db.transaction(() => {
+        upsertItem.run(parsed.slug, parsed.status, parsed.severity, parsed.category, parsed.reviewCadence, parsed.lastReviewed, parsed.created, parsed.nextReview, parsed.basePriority, parsed.filePath, parsed.byteSize, parsed.contentHash, parsed.organization, parsed.visibility);
+        deleteLinked.run(slug);
+        for (const bp of parsed.linkedBlueprints) {
+            insertLinked.run(slug, bp);
+        }
+    })();
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export async function ingestBlueprints(opts) {
+    const { db, cwd, dryRun = false } = opts;
+    const start = Date.now();
+    const errors = [];
+    let ingested = 0;
+    const blueprintRoot = resolveBlueprintRoot(cwd);
+    const pattern = path.join(blueprintRoot, '**', '_overview.md').replace(/\\/g, '/');
+    const files = await glob(pattern, { absolute: true, nodir: true });
+    for (const filePath of files) {
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            const slug = deriveSlugFromBlueprintPath(filePath);
+            const newHash = createHash('sha256').update(content).digest('hex');
+            if (!dryRun) {
+                const existing = existingBlueprintHash(db, slug);
+                if (existing === newHash)
+                    continue;
+                upsertBlueprint(db, filePath, cwd);
+            }
+            ingested++;
+        }
+        catch (err) {
+            const msg = `[ingester] Blueprint failed: ${filePath}: ${String(err)}`;
+            process.stderr.write(msg + '\n');
+            errors.push(msg);
+        }
+    }
+    return {
+        blueprintsIngested: ingested,
+        techDebtIngested: 0,
+        durationMs: Date.now() - start,
+        errors,
+    };
+}
+export async function ingestTechDebt(opts) {
+    const { db, cwd, dryRun = false } = opts;
+    const start = Date.now();
+    const errors = [];
+    let ingested = 0;
+    const techDebtRoot = resolveTechDebtRoot(cwd);
+    const pattern = path.join(techDebtRoot, '**', 'h-*.md').replace(/\\/g, '/');
+    const files = await glob(pattern, { absolute: true, nodir: true });
+    for (const filePath of files) {
+        try {
+            const content = readFileSync(filePath, 'utf8');
+            const slug = deriveSlugFromTechDebtPath(filePath);
+            const newHash = createHash('sha256').update(content).digest('hex');
+            if (!dryRun) {
+                const existing = existingTechDebtHash(db, slug);
+                if (existing === newHash)
+                    continue;
+                upsertTechDebt(db, filePath, cwd);
+            }
+            ingested++;
+        }
+        catch (err) {
+            const msg = `[ingester] TechDebt failed: ${filePath}: ${String(err)}`;
+            process.stderr.write(msg + '\n');
+            errors.push(msg);
+        }
+    }
+    return {
+        blueprintsIngested: 0,
+        techDebtIngested: ingested,
+        durationMs: Date.now() - start,
+        errors,
+    };
+}
+export async function ingestAll(opts) {
+    const start = Date.now();
+    const [bp, td] = await Promise.all([ingestBlueprints(opts), ingestTechDebt(opts)]);
+    return {
+        blueprintsIngested: bp.blueprintsIngested,
+        techDebtIngested: td.techDebtIngested,
+        durationMs: Date.now() - start,
+        errors: [...bp.errors, ...td.errors],
+    };
+}
+export function ingestRunnerEvent(input) {
+    const { db, executionHandle, sequence, event, runnerVersion } = input;
+    if (runnerVersion === '') {
+        throw new Error('runnerVersion must not be empty');
+    }
+    let message = null;
+    let exitCode = null;
+    let filePath = null;
+    switch (event.type) {
+        case 'progress':
+            message = event.message;
+            break;
+        case 'stdout':
+        case 'stderr':
+            message = event.line;
+            break;
+        case 'completed':
+            exitCode = event.exitCode;
+            break;
+        case 'failed':
+            exitCode = 0;
+            message = event.error;
+            break;
+        case 'artifact':
+            filePath = event.path;
+            break;
+        case 'started':
+        case 'cancelled':
+            // no extra columns
+            break;
+    }
+    db.prepare(`INSERT INTO runner_events
+       (execution_handle, sequence, kind, ts, message, exit_code, file_path)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(executionHandle, sequence, event.type, event.ts, message, exitCode, filePath);
+}
+//# sourceMappingURL=ingester.js.map

package/dist/esm/blueprint/db/legacy-migration.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Legacy DB deprecation + migration (F12 / R10 / E12, Task 1.1).
+ *
+ * Pre-worktree-scoping, the projection DB lived at
+ * `<cwd>/.agent/.blueprints.db`. Task 1.1 moves it under the worktree-scoped
+ * state-root path. For git repos that still have the legacy file (and any
+ * sibling `-wal` / `-shm` files from a crashed write), do the following on
+ * first access:
+ *
+ *  1. Log a one-line deprecation pointing at the new path.
+ *  2. If the destination does not exist, rename the legacy files to the new
+ *     location. Sibling WAL/SHM are moved alongside the main DB.
+ *  3. If the destination already exists, leave both untouched and surface a
+ *     failure-style warning. Callers should not double-count.
+ *
+ * Memoized per-repo so repeated calls within a process touch disk once.
+ */
+export declare const LEGACY_DB_SIBLINGS: readonly ["-wal", "-shm"];
+export type MigrationOutcome = 'migrated' | 'destination-exists' | 'no-legacy' | 'not-git';
+export interface MigrationResult {
+    readonly outcome: MigrationOutcome;
+    readonly legacyPath: string;
+    readonly destinationPath: string | null;
+    readonly movedSiblings: readonly string[];
+    readonly warning: string | null;
+}
+interface Logger {
+    warn(msg: string): void;
+}
+/**
+ * Detect and (if safe) migrate a legacy `.agent/.blueprints.db` for `cwd`.
+ *
+ * Idempotent and memoized per `cwd`. Outside a git repo the function is a
+ * no-op (returns `outcome: 'not-git'`) because the legacy path *is* the
+ * canonical path in that case.
+ */
+export declare function migrateLegacyAgentDb(cwd: string, logger?: Logger): MigrationResult;
+/** Test-only helper. */
+export declare function _clearMigrationMemoForTests(): void;
+export {};
+//# sourceMappingURL=legacy-migration.d.ts.map

package/dist/esm/blueprint/db/legacy-migration.js

@@ -0,0 +1,122 @@
+/**
+ * Legacy DB deprecation + migration (F12 / R10 / E12, Task 1.1).
+ *
+ * Pre-worktree-scoping, the projection DB lived at
+ * `<cwd>/.agent/.blueprints.db`. Task 1.1 moves it under the worktree-scoped
+ * state-root path. For git repos that still have the legacy file (and any
+ * sibling `-wal` / `-shm` files from a crashed write), do the following on
+ * first access:
+ *
+ *  1. Log a one-line deprecation pointing at the new path.
+ *  2. If the destination does not exist, rename the legacy files to the new
+ *     location. Sibling WAL/SHM are moved alongside the main DB.
+ *  3. If the destination already exists, leave both untouched and surface a
+ *     failure-style warning. Callers should not double-count.
+ *
+ * Memoized per-repo so repeated calls within a process touch disk once.
+ */
+import { existsSync, mkdirSync, renameSync } from 'node:fs';
+import path from 'node:path';
+import { LEGACY_AGENT_DIR, LEGACY_DB_FILENAME } from './paths.js';
+import { getSurfacePath, NotInGitRepoError } from '#paths/state-root.js';
+export const LEGACY_DB_SIBLINGS = ['-wal', '-shm'];
+const defaultLogger = {
+    warn(msg) {
+        process.stderr.write(`${msg}\n`);
+    },
+};
+const memo = new Map();
+function legacyDbPath(cwd) {
+    return path.join(cwd, LEGACY_AGENT_DIR, LEGACY_DB_FILENAME);
+}
+function moveOne(from, to) {
+    if (!existsSync(from))
+        return false;
+    renameSync(from, to);
+    return true;
+}
+function tryResolveDestination(cwd) {
+    // Call getSurfacePath directly (not resolveBlueprintProjectionDbPath) so
+    // we can distinguish "git repo, real worktree-scoped destination" from
+    // "non-git repo, legacy path IS canonical". The latter must not be treated
+    // as a migration target.
+    try {
+        return getSurfacePath('blueprints/blueprints.db', 'worktree', cwd);
+    }
+    catch (err) {
+        if (err instanceof NotInGitRepoError)
+            return null;
+        throw err;
+    }
+}
+/**
+ * Detect and (if safe) migrate a legacy `.agent/.blueprints.db` for `cwd`.
+ *
+ * Idempotent and memoized per `cwd`. Outside a git repo the function is a
+ * no-op (returns `outcome: 'not-git'`) because the legacy path *is* the
+ * canonical path in that case.
+ */
+export function migrateLegacyAgentDb(cwd, logger = defaultLogger) {
+    const cached = memo.get(cwd);
+    if (cached !== undefined)
+        return cached;
+    const legacy = legacyDbPath(cwd);
+    const result = computeMigration(cwd, legacy, logger);
+    memo.set(cwd, result);
+    return result;
+}
+function computeMigration(cwd, legacy, logger) {
+    if (!existsSync(legacy)) {
+        return {
+            outcome: 'no-legacy',
+            legacyPath: legacy,
+            destinationPath: null,
+            movedSiblings: [],
+            warning: null,
+        };
+    }
+    const destination = tryResolveDestination(cwd);
+    if (destination === null) {
+        // Non-git: legacy path IS canonical; nothing to migrate.
+        return {
+            outcome: 'not-git',
+            legacyPath: legacy,
+            destinationPath: null,
+            movedSiblings: [],
+            warning: null,
+        };
+    }
+    if (existsSync(destination)) {
+        const warning = `[blueprint] WARNING: legacy DB ${legacy} found but worktree DB already exists at ${destination}; leaving both untouched. Delete the legacy file once you have verified the new DB is current.`;
+        logger.warn(warning);
+        return {
+            outcome: 'destination-exists',
+            legacyPath: legacy,
+            destinationPath: destination,
+            movedSiblings: [],
+            warning,
+        };
+    }
+    logger.warn(`[blueprint] deprecated: ${legacy} → ${destination} (migrating; legacy .agent/.blueprints.db will be removed)`);
+    // Ensure the destination directory exists before renames.
+    mkdirSync(path.dirname(destination), { recursive: true });
+    moveOne(legacy, destination);
+    const movedSiblings = [];
+    for (const suffix of LEGACY_DB_SIBLINGS) {
+        const moved = moveOne(`${legacy}${suffix}`, `${destination}${suffix}`);
+        if (moved)
+            movedSiblings.push(suffix);
+    }
+    return {
+        outcome: 'migrated',
+        legacyPath: legacy,
+        destinationPath: destination,
+        movedSiblings,
+        warning: null,
+    };
+}
+/** Test-only helper. */
+export function _clearMigrationMemoForTests() {
+    memo.clear();
+}
+//# sourceMappingURL=legacy-migration.js.map

package/dist/esm/blueprint/db/migrations/run.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from '#db/sqlite.js';
+export declare function runMigrations(db: Database): void;
+//# sourceMappingURL=run.d.ts.map

package/dist/esm/blueprint/db/migrations/run.js

@@ -0,0 +1,53 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MIGRATIONS_DIR = __dirname;
+function ensureSchemaVersionTable(db) {
+    db.exec('CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY, applied_at TEXT)');
+}
+function getAppliedVersions(db) {
+    const rows = db.prepare('SELECT version FROM schema_version').all();
+    return new Set(rows.map((r) => r.version));
+}
+function parseMigrationVersion(filename) {
+    const match = /^(\d+)_/.exec(filename);
+    if (!match || match[1] === undefined)
+        return null;
+    return parseInt(match[1], 10);
+}
+export function runMigrations(db) {
+    ensureSchemaVersionTable(db);
+    const files = readdirSync(MIGRATIONS_DIR)
+        .filter((f) => f.endsWith('.sql'))
+        .sort();
+    for (const file of files) {
+        const version = parseMigrationVersion(file);
+        if (version === null)
+            continue;
+        const sql = readFileSync(path.join(MIGRATIONS_DIR, file), 'utf8');
+        db.exec('BEGIN IMMEDIATE');
+        try {
+            const applied = getAppliedVersions(db);
+            if (applied.has(version)) {
+                db.exec('COMMIT');
+                continue;
+            }
+            db.exec(sql);
+            db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(version, new Date().toISOString());
+            db.exec('COMMIT');
+        }
+        catch (error) {
+            // Only ROLLBACK if a transaction is actually active. If BEGIN IMMEDIATE
+            // itself failed (e.g. SQLITE_BUSY), there is no open transaction and a
+            // ROLLBACK here would throw a secondary "cannot rollback" error that
+            // masks the original SQLITE_BUSY, preventing openDb's retry loop from
+            // recognising the error as retryable.
+            if (db.inTransaction) {
+                db.exec('ROLLBACK');
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=run.js.map

package/dist/esm/blueprint/db/parser/blueprint-db-parser.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Blueprint DB Parser
+ *
+ * Extracts structured data from blueprint `_overview.md` files for DB projection.
+ * This is SEPARATE from `src/blueprint/core/parser.ts` which serves the CLI/runtime layer.
+ *
+ * Design: fault-tolerant — malformed YAML or missing sections log to stderr and return
+ * partial data rather than throwing. Callers should check required fields before ingesting.
+ */
+export interface CrossRepoDependency {
+    repo: string;
+    slug: string | null;
+    requireStatus: string | null;
+}
+export interface ParsedTaskFile {
+    filePath: string;
+    op: 'create' | 'modify' | 'delete';
+}
+export interface ParsedTask {
+    taskId: string;
+    wave: string | null;
+    title: string;
+    status: 'todo' | 'in-progress' | 'blocked' | 'done' | 'dropped';
+    description: string | null;
+    acceptanceCriteria: string[];
+    dependsOnTaskIds: string[];
+    files: ParsedTaskFile[];
+}
+export interface ParsedRisk {
+    riskId: string;
+    severity: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    description: string;
+    mitigation: string;
+}
+export interface ParsedEdgeCase {
+    edgeId: string;
+    severity: string;
+    description: string;
+    mitigation: string;
+}
+export interface ParsedBlueprintForDb {
+    slug: string;
+    filePath: string;
+    title: string;
+    status: string;
+    complexity: string | null;
+    owner: string | null;
+    created: string | null;
+    lastUpdated: string | null;
+    completedAt: string | null;
+    tags: string[];
+    dependsOn: string[];
+    crossRepoDependsOn: CrossRepoDependency[];
+    organization: string;
+    visibility: 'public' | 'private';
+    tasks: ParsedTask[];
+    risks: ParsedRisk[];
+    edgeCases: ParsedEdgeCase[];
+    byteSize: number;
+    contentHash: string;
+}
+/**
+ * Parse a blueprint `_overview.md` for DB projection.
+ *
+ * Fault-tolerant: malformed YAML or missing sections log to stderr and return
+ * partial data; this function never throws.
+ */
+export declare function parseBlueprintForDb(content: string, filePath: string, slug: string): ParsedBlueprintForDb;
+//# sourceMappingURL=blueprint-db-parser.d.ts.map