create-principles-disciple 1.94.0 → 1.96.0

package/plugin/dist/service/subagent-workflow/workflow-store.js

@@ -78,8 +78,12 @@ export class WorkflowStore {
                 this.db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
                 console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion}: added duration_ms column`);
             }
-            catch {
-                void 0;
+            catch (err) {
+                // rc-9: surface failure reason instead of silent void 0
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes('duplicate column name')) {
+                    console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion} failed: ${message}`);
+                }
             }
         }
     }
@@ -207,3 +211,88 @@ export class WorkflowStore {
         return rows.map(r => r.duration_ms);
     }
 }
+/**
+ * Initialize subagent_workflows.db schema at the given workspace directory.
+ *
+ * Opens the DB in write mode, applies the full schema (tables + indexes + migrations),
+ * then closes the DB. Used by `pd runtime init` for unified DB initialization.
+ *
+ * Idempotent: safe to call on an existing DB; all CREATE statements use IF NOT EXISTS.
+ *
+ * @returns list of created/verified table names and any warnings
+ */
+export function initWorkflowSchema(workspaceDir) {
+    const resolvedDir = path.resolve(workspaceDir);
+    const stateDir = path.join(resolvedDir, '.state');
+    const dbPath = path.join(stateDir, 'subagent_workflows.db');
+    const warnings = [];
+    const tables = ['schema_version', 'subagent_workflows', 'subagent_workflow_events'];
+    fs.mkdirSync(stateDir, { recursive: true });
+    const db = new Database(dbPath);
+    try {
+        db.pragma('journal_mode = WAL');
+        db.pragma('foreign_keys = ON');
+        db.pragma('synchronous = NORMAL');
+        db.pragma(`busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS}`);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS subagent_workflows (
+                workflow_id TEXT PRIMARY KEY,
+                workflow_type TEXT NOT NULL,
+                transport TEXT NOT NULL,
+                parent_session_id TEXT NOT NULL,
+                child_session_key TEXT NOT NULL,
+                run_id TEXT,
+                state TEXT NOT NULL DEFAULT 'pending',
+                cleanup_state TEXT NOT NULL DEFAULT 'none',
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                last_observed_at INTEGER,
+                duration_ms INTEGER,
+                metadata_json TEXT NOT NULL DEFAULT '{}'
+            );
+            CREATE TABLE IF NOT EXISTS subagent_workflow_events (
+                workflow_id TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                from_state TEXT,
+                to_state TEXT NOT NULL,
+                reason TEXT NOT NULL,
+                payload_json TEXT NOT NULL DEFAULT '{}',
+                created_at INTEGER NOT NULL,
+                FOREIGN KEY (workflow_id) REFERENCES subagent_workflows(workflow_id) ON DELETE CASCADE
+            );
+            CREATE INDEX IF NOT EXISTS idx_workflows_parent_session ON subagent_workflows(parent_session_id);
+            CREATE INDEX IF NOT EXISTS idx_workflows_child_session ON subagent_workflows(child_session_key);
+            CREATE INDEX IF NOT EXISTS idx_workflows_state ON subagent_workflows(state);
+            CREATE INDEX IF NOT EXISTS idx_workflows_type ON subagent_workflows(workflow_type);
+            CREATE INDEX IF NOT EXISTS idx_events_workflow ON subagent_workflow_events(workflow_id);
+        `);
+        // Run migrations to bring schema up to SCHEMA_VERSION
+        const row = db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+        const currentVersion = row?.version ?? 0;
+        if (currentVersion === 0) {
+            db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        }
+        else if (currentVersion < SCHEMA_VERSION) {
+            // Inline migration logic (mirrors WorkflowStore.runMigrations)
+            if (currentVersion < 2 && SCHEMA_VERSION >= 2) {
+                try {
+                    db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes('duplicate column name')) {
+                        warnings.push(`migration v${currentVersion}→v${SCHEMA_VERSION} duration_ms failed: ${message}`);
+                    }
+                }
+            }
+            db.prepare('UPDATE schema_version SET version = ?').run(SCHEMA_VERSION);
+        }
+        return { tables, warnings };
+    }
+    finally {
+        db.close();
+    }
+}

package/plugin/dist/types/event-types.d.ts

@@ -1,2 +1,2 @@
-export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
+export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
 export { createEmptyDailyStats, } from '@principles/core/runtime-v2';

package/plugin/package.json

@@ -3,9 +3,13 @@
   "version": "1.74.1",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
-  "main": "./dist/bundle.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/bundle.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -47,7 +51,6 @@
     "lint": "eslint \"src/**/*.ts\"",
     "bootstrap-rules": "node scripts/bootstrap-rules.mjs",
     "compile-principles": "node scripts/compile-principles.mjs",
-    "validate-live-path": "tsx scripts/validate-live-path.ts",
     "sync-plugin": "node scripts/sync-plugin.mjs"
   },
   "devDependencies": {

package/plugin/scripts/acceptance-test.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * Nocturnal Pipeline — End-to-End Acceptance Test
+ * PD Pipeline — End-to-End Acceptance Test
  *
- * Verifies that all components of the Nocturnal reflection pipeline
+ * Verifies that all components of the PD reflection pipeline
  * work correctly in a real environment (not unit tests).
  *
  * Usage:
@@ -71,7 +71,7 @@ function main() {
     process.exit(1);
   }
 
-  console.log('\n🧪 Nocturnal Pipeline Acceptance Test');
+  console.log('\n🧪 PD Pipeline Acceptance Test');
   console.log('═'.repeat(55));
   console.log(`Workspace: ${workspaceDir}`);
   console.log(`Database:  ${dbPath}\n`);

package/plugin/dist/core/evolution-migration.d.ts

@@ -1,5 +0,0 @@
-export interface MigrationResult {
-    importedEvents: number;
-    streamPath: string;
-}
-export declare function migrateLegacyEvolutionData(workspaceDir: string): MigrationResult;

package/plugin/dist/core/evolution-migration.js

@@ -1,65 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { stableContentHash } from './evolution-reducer.js';
-import { SystemLogger } from './system-logger.js';
-function appendEvent(streamPath, event) {
-    fs.appendFileSync(streamPath, `${JSON.stringify(event)}\n`, 'utf8');
-}
-function loadImportedHashes(streamPath, workspaceDir) {
-    if (!fs.existsSync(streamPath))
-        return new Set();
-    const raw = fs.readFileSync(streamPath, 'utf8').trim();
-    if (!raw)
-        return new Set();
-    const hashes = new Set();
-    for (const line of raw.split('\n')) {
-        try {
-            const event = JSON.parse(line);
-            if (event.type !== 'legacy_import')
-                continue;
-            const hash = event.data.contentHash;
-            if (typeof hash === 'string')
-                hashes.add(hash);
-        }
-        catch (e) {
-            SystemLogger.log(workspaceDir, 'MIGRATION_WARN', `skip malformed line: ${String(e)}`);
-        }
-    }
-    return hashes;
-}
-export function migrateLegacyEvolutionData(workspaceDir) {
-    const streamPath = path.join(workspaceDir, 'memory', 'evolution.jsonl');
-    fs.mkdirSync(path.dirname(streamPath), { recursive: true });
-    const candidates = [
-        path.join(workspaceDir, 'memory', 'ISSUE_LOG.md'),
-        path.join(workspaceDir, 'memory', 'DECISIONS.md'),
-        path.join(workspaceDir, '.principles', 'PRINCIPLES.md'),
-    ];
-    const existingHashes = loadImportedHashes(streamPath, workspaceDir);
-    let importedEvents = 0;
-    for (const sourceFile of candidates) {
-        if (!fs.existsSync(sourceFile)) {
-            continue;
-        }
-        const content = fs.readFileSync(sourceFile, 'utf8').trim();
-        if (!content) {
-            continue;
-        }
-        const contentHash = stableContentHash(`${sourceFile}:${content}`);
-        if (existingHashes.has(contentHash)) {
-            continue;
-        }
-        appendEvent(streamPath, {
-            ts: new Date().toISOString(),
-            type: 'legacy_import',
-            data: {
-                sourceFile: path.relative(workspaceDir, sourceFile),
-                content,
-                contentHash,
-            },
-        });
-        importedEvents += 1;
-        existingHashes.add(contentHash);
-    }
-    return { importedEvents, streamPath };
-}

package/plugin/dist/core/principle-tree-ledger-adapter.d.ts

@@ -1,32 +0,0 @@
-import type { LedgerAdapter, LedgerPrincipleEntry } from '@principles/core/runtime-v2';
-/**
- * PrincipleTreeLedgerAdapter — bridges 11-field LedgerPrincipleEntry to 18+ field LedgerPrinciple.
- *
- * This adapter maintains an in-memory idempotency map. Create once and reuse
- * across calls within the same process lifetime. Do not create a new instance
- * per intake call.
- */
-export declare class PrincipleTreeLedgerAdapter implements LedgerAdapter {
-    #private;
-    constructor(opts: {
-        stateDir: string;
-    });
-    /**
-     * Write a probation entry to the ledger.
-     *
-     * Idempotency: if the same candidateId was already written, returns the
-     * existing entry without writing again.
-     *
-     * @throws CandidateIntakeError with code LEDGER_WRITE_FAILED on write failure.
-     */
-    writeProbationEntry(entry: LedgerPrincipleEntry): LedgerPrincipleEntry;
-    /**
-     * Check if a ledger entry already exists for a given candidate.
-     *
-     * Queries both the in-memory Map (fast path for same-process repeat calls)
-     * and the ledger file (for cross-process idempotency across CLI invocations).
-     *
-     * @returns The existing LedgerPrincipleEntry if found, null otherwise.
-     */
-    existsForCandidate(candidateId: string): LedgerPrincipleEntry | null;
-}

package/plugin/dist/core/principle-tree-ledger-adapter.js

@@ -1,125 +0,0 @@
-import { CandidateIntakeError, INTAKE_ERROR_CODES } from '@principles/core/runtime-v2';
-import { addPrincipleToLedger, loadLedger } from './principle-tree-ledger.js';
-const VALID_EVALUABILITIES = ['deterministic', 'weak_heuristic', 'manual_only'];
-/**
- * PrincipleTreeLedgerAdapter — bridges 11-field LedgerPrincipleEntry to 18+ field LedgerPrinciple.
- *
- * This adapter maintains an in-memory idempotency map. Create once and reuse
- * across calls within the same process lifetime. Do not create a new instance
- * per intake call.
- */
-export class PrincipleTreeLedgerAdapter {
-    #stateDir;
-    #entryMap = new Map();
-    constructor(opts) {
-        this.#stateDir = opts.stateDir;
-    }
-    /**
-     * Write a probation entry to the ledger.
-     *
-     * Idempotency: if the same candidateId was already written, returns the
-     * existing entry without writing again.
-     *
-     * @throws CandidateIntakeError with code LEDGER_WRITE_FAILED on write failure.
-     */
-    writeProbationEntry(entry) {
-        const candidateId = this.#extractCandidateId(entry.sourceRef);
-        const existing = this.#entryMap.get(candidateId);
-        if (existing)
-            return existing;
-        const ledgerPrinciple = this.#expandToLedgerPrinciple(entry, candidateId);
-        try {
-            addPrincipleToLedger(this.#stateDir, ledgerPrinciple);
-        }
-        catch (err) {
-            throw new CandidateIntakeError(INTAKE_ERROR_CODES.LEDGER_WRITE_FAILED, `Failed to write principle ${entry.id} to ledger: ${String(err)}`, { cause: err });
-        }
-        this.#entryMap.set(candidateId, entry);
-        return entry;
-    }
-    /**
-     * Check if a ledger entry already exists for a given candidate.
-     *
-     * Queries both the in-memory Map (fast path for same-process repeat calls)
-     * and the ledger file (for cross-process idempotency across CLI invocations).
-     *
-     * @returns The existing LedgerPrincipleEntry if found, null otherwise.
-     */
-    existsForCandidate(candidateId) {
-        // Fast path: check in-memory Map (covers same-process repeat calls)
-        const cached = this.#entryMap.get(candidateId);
-        if (cached)
-            return cached;
-        // Cross-process path: check ledger file by derivedFromPainIds
-        const ledger = loadLedger(this.#stateDir);
-        const found = Object.values(ledger.tree.principles).find((p) => p.derivedFromPainIds.includes(candidateId));
-        if (!found)
-            return null;
-        // Reconstruct LedgerPrincipleEntry from LedgerPrinciple fields
-        // Note: sourceRef, artifactRef, taskRef are not stored in LedgerPrinciple,
-        // so we cannot fully reconstruct the original LedgerPrincipleEntry.
-        // Return minimal entry sufficient for idempotency signaling.
-        return {
-            id: found.id,
-            title: '',
-            status: 'probation',
-            sourceRef: `candidate://${candidateId}`,
-            artifactRef: '',
-            taskRef: '',
-            text: found.text,
-            triggerPattern: found.triggerPattern,
-            action: found.action,
-            evaluability: 'weak_heuristic',
-            createdAt: found.createdAt,
-        };
-    }
-    /**
-     * Extract candidateId from sourceRef by stripping the 'candidate://' prefix.
-     *
-     * @internal
-     */
-    #extractCandidateId(sourceRef) {
-        if (sourceRef.startsWith('candidate://')) {
-            return sourceRef.slice('candidate://'.length);
-        }
-        return sourceRef;
-    }
-    /**
-     * Expand an 11-field LedgerPrincipleEntry to an 18+ field LedgerPrinciple.
-     *
-     * Applies the field expansion table from CONTEXT.md:
-     * - status: 'probation' → 'candidate'
-     * - triggerPattern/action: pass through (empty string if absent)
-     * - All defaults applied per CONTEXT.md expansion table
-     * - sourceRef/artifactRef/taskRef are NOT written to LedgerPrinciple (not stored)
-     * - title is NOT written to LedgerPrinciple — intentionally excluded; title
-     *   is available in LedgerPrincipleEntry but LedgerPrinciple has no title field
-     *
-     * @internal
-     */
-    #expandToLedgerPrinciple(entry, candidateId) {
-        if (!VALID_EVALUABILITIES.includes(entry.evaluability)) {
-            throw new CandidateIntakeError(INTAKE_ERROR_CODES.INPUT_INVALID, `Invalid evaluability value: ${entry.evaluability}. Must be one of: ${VALID_EVALUABILITIES.join(', ')}`);
-        }
-        const result = {
-            id: entry.id,
-            version: 1,
-            text: entry.text,
-            triggerPattern: entry.triggerPattern ?? '',
-            action: entry.action ?? '',
-            status: 'candidate',
-            evaluability: entry.evaluability,
-            priority: 'P1',
-            scope: 'general',
-            valueScore: 0,
-            adherenceRate: 0,
-            painPreventedCount: 0,
-            derivedFromPainIds: [candidateId],
-            ruleIds: [],
-            conflictsWithPrincipleIds: [],
-            createdAt: entry.createdAt,
-            updatedAt: entry.createdAt,
-        };
-        return result;
-    }
-}

package/plugin/dist/core/risk-calculator.d.ts

@@ -1,22 +0,0 @@
-export type RiskLevel = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-export interface FileModification {
-    toolName: string;
-    params: Record<string, unknown>;
-}
-export declare function estimateLineChanges(modification: FileModification): number;
-export declare function assessRiskLevel(filePath: string, modification: FileModification, riskPaths: string[]): RiskLevel;
-/**
- * Get the total line count of a target file.
- * @param absoluteFilePath - Absolute path to the file
- * @returns File line count, or null if file doesn't exist or can't be read
- */
-export declare function getTargetFileLineCount(absoluteFilePath: string): number | null;
-/**
- * Calculate the effective line limit based on percentage of target file.
- * @param targetLineCount - Total lines in target file
- * @param percentage - Allowed percentage (0-100)
- * @param minLines - Absolute minimum threshold
- * @param maxLines - Optional upper bound to prevent misconfiguration
- * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
- */
-export declare function calculatePercentageThreshold(targetLineCount: number, percentage: number, minLines: number, maxLines?: number): number;

package/plugin/dist/core/risk-calculator.js

@@ -1,88 +0,0 @@
-/* global NodeJS */
-import * as fs from 'fs';
-import { isRisky } from '../utils/io.js';
-export function estimateLineChanges(modification) {
-    const { toolName, params } = modification;
-    if (toolName === 'write_file' || toolName === 'write') {
-        const content = params.content || '';
-        return content.split('\n').length;
-    }
-    if (toolName === 'replace' || toolName === 'edit') {
-        const newContent = params.new_string || params.newText || '';
-        return newContent.split('\n').length;
-    }
-    if (toolName === 'apply_patch' || toolName === 'patch') {
-        const patch = params.patch || '';
-        // Rough estimate for patch files
-        return patch.split('\n').filter((l) => l.startsWith('+') || l.startsWith('-')).length;
-    }
-    if (toolName === 'delete_file') {
-        // Deleting a file is considered a significant change, but we don't know the size. 
-        // We'll treat it as a medium-to-large size change.
-        return 50;
-    }
-    return 0;
-}
-export function assessRiskLevel(filePath, modification, riskPaths) {
-    const isRiskPath = isRisky(filePath, riskPaths);
-    const estimatedLines = estimateLineChanges(modification);
-    if (isRiskPath) {
-        if (estimatedLines > 100)
-            return 'CRITICAL';
-        return 'HIGH';
-    }
-    else {
-        if (estimatedLines > 100)
-            return 'HIGH';
-        if (estimatedLines > 10)
-            return 'MEDIUM';
-        return 'LOW';
-    }
-}
-/**
- * Get the total line count of a target file.
- * @param absoluteFilePath - Absolute path to the file
- * @returns File line count, or null if file doesn't exist or can't be read
- */
-export function getTargetFileLineCount(absoluteFilePath) {
-    try {
-        if (!fs.existsSync(absoluteFilePath)) {
-            return null; // File genuinely doesn't exist
-        }
-        const stats = fs.statSync(absoluteFilePath);
-        if (!stats.isFile()) {
-            return null; // Not a regular file (directory, device, etc.)
-        }
-        const content = fs.readFileSync(absoluteFilePath, 'utf-8');
-        return content.split('\n').length;
-    }
-    catch (e) {
-        // Log error before falling back to null - this is intentional for security gates
-        const error = e instanceof Error ? e : new Error(String(e));
-        const errorCode = e.code;
-        console.error(`[PD:RISK_CALC] Failed to read file for line count: ${absoluteFilePath}`, {
-            code: errorCode,
-            message: error.message,
-        });
-        return null;
-    }
-}
-/**
- * Calculate the effective line limit based on percentage of target file.
- * @param targetLineCount - Total lines in target file
- * @param percentage - Allowed percentage (0-100)
- * @param minLines - Absolute minimum threshold
- * @param maxLines - Optional upper bound to prevent misconfiguration
- * @returns Maximum allowed lines (at least minLines, at most maxLines if provided)
- */
-export function calculatePercentageThreshold(targetLineCount, percentage, minLines, maxLines) {
-    // Clamp percentage to valid range [0, 100]
-    const clampedPercentage = Math.max(0, Math.min(100, percentage));
-    const calculated = Math.round(targetLineCount * (clampedPercentage / 100));
-    let effectiveLimit = Math.max(calculated, minLines);
-    // Apply optional upper bound
-    if (maxLines !== undefined && maxLines > 0) {
-        effectiveLimit = Math.min(effectiveLimit, maxLines);
-    }
-    return effectiveLimit;
-}

package/plugin/dist/core/rule-host-helpers.d.ts

@@ -1,8 +0,0 @@
-/**
- * Rule Host Helpers — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-helpers.ts
- */
-export type { RuleHostHelpers } from '@principles/core/runtime-v2';
-export { createRuleHostHelpers } from '@principles/core/runtime-v2';

package/plugin/dist/core/rule-host-helpers.js

@@ -1,7 +0,0 @@
-/**
- * Rule Host Helpers — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-helpers.ts
- */
-export { createRuleHostHelpers } from '@principles/core/runtime-v2';

package/plugin/dist/core/rule-host-types.d.ts

@@ -1,7 +0,0 @@
-/**
- * Rule Host Types — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-contracts.ts
- */
-export type { RuleHostInput, RuleHostDecision, RuleHostMeta, RuleHostResult, LoadedImplementation, } from '@principles/core/runtime-v2';

package/plugin/dist/core/rule-host-types.js

@@ -1,7 +0,0 @@
-/**
- * Rule Host Types — Re-exported from @principles/core (PRI-42)
- *
- * Canonical definitions moved to:
- *   packages/principles-core/src/runtime-v2/internalization/rule-host-contracts.ts
- */
-export {};

package/plugin/dist/core/schema/db-types.d.ts

@@ -1,11 +0,0 @@
-/**
- * Shared type definitions for database operations.
- * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
- */
-/** Minimal interface for better-sqlite3 Database instances. */
-export interface Db {
-    exec(_sql: string): unknown;
-    get<T = unknown>(_sql: string, ..._params: unknown[]): T | undefined;
-    run(_sql: string, ..._params: unknown[]): unknown;
-    close(): void;
-}

package/plugin/dist/core/schema/db-types.js

@@ -1,5 +0,0 @@
-/**
- * Shared type definitions for database operations.
- * Kept separate to avoid circular dependencies between schema-definitions and migration-runner.
- */
-export {};

package/plugin/dist/core/schema/index.d.ts

@@ -1,17 +0,0 @@
-/**
- * Schema Management — Unified database schema definitions and migrations.
- *
- * Usage:
- *   // In a database class constructor:
- *   import { ensureDatabaseSchema } from './schema';
- *   ensureDatabaseSchema(db, 'trajectory.db');
- *
- * CLI:
- *   node scripts/db-migrate.mjs status
- *   node scripts/db-migrate.mjs run
- */
-export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
-export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
-export { ALL_MIGRATIONS } from './migrations/index.js';
-export type { Db } from './db-types.js';
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog, } from './migration-runner.js';

package/plugin/dist/core/schema/index.js

@@ -1,15 +0,0 @@
-/**
- * Schema Management — Unified database schema definitions and migrations.
- *
- * Usage:
- *   // In a database class constructor:
- *   import { ensureDatabaseSchema } from './schema';
- *   ensureDatabaseSchema(db, 'trajectory.db');
- *
- * CLI:
- *   node scripts/db-migrate.mjs status
- *   node scripts/db-migrate.mjs run
- */
-export { MigrationRunner, ensureDatabaseSchema } from './migration-runner.js';
-export { SCHEMAS, getCatalog, DB_TYPES } from './schema-definitions.js';
-export { ALL_MIGRATIONS } from './migrations/index.js';

package/plugin/dist/core/schema/migration-runner.d.ts

@@ -1,53 +0,0 @@
-/**
- * Migration Runner — Executes and tracks schema migrations.
- *
- * Each migration is versioned. The runner reads the current version from
- * the `schema_version` table and only executes migrations with higher IDs.
- *
- * Usage:
- *   const runner = new MigrationRunner(db);
- *   runner.run(allMigrations.filter(m => m.db === 'trajectory.db'));
- */
-import type { Migration } from './schema-definitions.js';
-import { type DbType } from './schema-definitions.js';
-import type { Db } from './db-types.js';
-export declare class MigrationRunner {
-    private readonly db;
-    constructor(db: Db);
-    /**
-     * Run all pending migrations for a given database type.
-     * @returns Array of migration names that were applied
-     */
-    runMigrations(migrations: Migration[], _dbType: DbType): string[];
-    /**
-     * Apply all schema definitions (tables, indexes, views, FTS) for a database.
-     * This is a convenience method that creates everything from the schema catalog.
-     * Used for initial setup when no migrations exist yet.
-     */
-    applySchemaCatalog(dbType: DbType): void;
-    /**
-     * Get the current migration version.
-     * Returns '000' if no version is set (fresh database).
-     */
-    getCurrentVersion(): string;
-    /**
-     * Get all available migration info for a database type.
-     */
-    getMigrationInfo(migrations: Migration[], dbType: DbType): {
-        id: string;
-        name: string;
-        applied: boolean;
-    }[];
-    /**
-     * Rollback the latest migration (if down migration is defined).
-     */
-    rollback(migrations: Migration[], dbType: DbType): string | null;
-    private ensureVersionTable;
-    private setVersion;
-}
-/**
- * Factory: create a MigrationRunner and apply schema catalog for a given database.
- * This is the main entry point for database classes.
- */
-export declare function ensureDatabaseSchema(db: Db, dbType: DbType): void;
-export type { Migration, DbType, TableDefinition, ViewDefinition, FtsDefinition, SchemaCatalog } from './schema-definitions.js';