@orquentra/codebuddy 0.0.0-stage → 2.4.1

package/dist/index.d.ts

@@ -0,0 +1,2527 @@
+import { a as CodeBuddyConfig, M as MemoryRepository, b as MemoryFileStore, C as CodeBuddy, N as NamespaceSummary, A as AgentWriteBreakdown, L as ListedFact, c as ModelProvider, d as ContextPolicy, e as PlanInput, P as PlannedContext, f as ProviderDiagnosticsHook, E as EmbeddingRequest, g as EmbeddingResponse, T as TextGenerationRequest, h as TextGenerationResponse } from './codebuddy-D2xJ6hFk.js';
+export { i as CodeBuddyDependencies, j as CodeBuddyStatus, k as ConflictMode, l as EmbeddingSpace, m as EmbeddingWorker, F as FACT_CATEGORIES, n as FactCategory, o as FactFile, p as FactFileWrite, q as ForgetResult, I as INCIDENT_SEVERITIES, r as IncidentFactFile, s as IncidentSeverity, t as MemoryWriteType, u as PlannedMessage, v as PlannerStats, Q as QueryEmbedding, R as RecallInput, w as RecallResult, x as RememberBatchItem, y as RememberInput, z as RememberResult, S as ShareInput, B as ShareResult, D as SkipReason, G as SummaryFile, H as SummaryFileWrite, J as TraceSpan, K as Tracer, U as UnshareInput, O as UnshareResult, W as WorkerConfig, V as WorkerState, X as createTracer, Y as isLangSmithTracingEnabled } from './codebuddy-D2xJ6hFk.js';
+import { z } from 'zod';
+import * as drizzle_orm_postgres_js from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { HfInference } from '@huggingface/inference';
+
+/**
+ * Plan policy controls how strongly CodeBuddy nudges agents toward writing
+ * a plan before substantive work:
+ *   - off:      plans are never suggested or required.
+ *   - suggest:  agents are reminded to plan, but small tasks stay lightweight (default).
+ *   - required: agents should refuse substantive changes without an active plan.
+ */
+declare const PLAN_POLICIES: readonly ["off", "suggest", "required"];
+type PlanPolicy = (typeof PLAN_POLICIES)[number];
+type ConfigPermissionReport = {
+    path: string;
+    exists: boolean;
+    mode: string | null;
+    ok: boolean;
+    warning?: string;
+};
+type ProjectScaffoldReport = {
+    codebuddyDir: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        warning?: string;
+    };
+    memoryFactsDir: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        warning?: string;
+    };
+    memorySummariesDir: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        warning?: string;
+    };
+    plansDir: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        warning?: string;
+    };
+    gitignore: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        warning?: string;
+    };
+    policies: {
+        path: string;
+        exists: boolean;
+        ok: boolean;
+        warning?: string;
+    };
+};
+declare function configPath(cwd?: string): string;
+declare function initProjectScaffold(cwd?: string): Promise<{
+    codebuddyDir: string;
+    gitignorePath: string;
+    policyPath: string;
+}>;
+declare function initConfigFile(cwd?: string): Promise<{
+    path: string;
+    created: boolean;
+}>;
+/**
+ * `requireDatabase: false` (the MCP server) returns an empty `postgresUrl`
+ * instead of throwing, so file-based tools still run without PostgreSQL;
+ * `createRuntime` rejects the empty URL with the same message.
+ */
+declare function loadRuntimeConfig(cwd?: string, options?: {
+    requireDatabase?: boolean;
+}): Promise<CodeBuddyConfig>;
+declare function checkConfigPermissions(cwd?: string): Promise<ConfigPermissionReport>;
+declare function checkProjectScaffold(cwd?: string): Promise<ProjectScaffoldReport>;
+/** Read the plan policy, honoring CODEBUDDY_PLAN_POLICY then the config file. */
+declare function loadPlanPolicy(cwd?: string): Promise<PlanPolicy>;
+/** Persist the plan policy into `.codebuddy/config.json`, creating it if needed. */
+declare function setPlanPolicy(policy: PlanPolicy, cwd?: string): Promise<void>;
+declare function redactSecrets(value: unknown): unknown;
+
+type MigrationConflict = {
+    kind: "fact" | "summary";
+    id: string;
+    databaseChecksum: string;
+    fileChecksum: string;
+};
+type MigrationFailure = {
+    kind: "fact" | "summary";
+    id: string;
+    error: string;
+};
+type MigrationPreview = {
+    namespace: string;
+    dryRun: boolean;
+    facts: {
+        found: number;
+        existing: number;
+        toWrite: number;
+        conflicts: number;
+        written: number;
+    };
+    summaries: {
+        found: number;
+        existing: number;
+        toWrite: number;
+        conflicts: number;
+        written: number;
+    };
+    conflicts: MigrationConflict[];
+    failures: MigrationFailure[];
+};
+declare function migrateMemoryToFiles(input: {
+    repository: MemoryRepository;
+    store: MemoryFileStore;
+    namespace: string;
+    write: boolean;
+}): Promise<MigrationPreview>;
+
+type RuntimeHandle = {
+    memory: CodeBuddy;
+    repository: MemoryRepository;
+    close(): Promise<void>;
+};
+type CreateRuntimeOptions = {
+    /**
+     * When true (default for `serve`), enable pgvector and apply any pending
+     * SQL migrations before the SDK initialises. Safe to run repeatedly —
+     * Drizzle skips migrations it has already applied.
+     */
+    autoBootstrap?: boolean;
+    repositoryRoot?: string;
+};
+declare function createRuntime(config?: CodeBuddyConfig, options?: CreateRuntimeOptions): Promise<RuntimeHandle>;
+declare function encodeFactCursor(fact: {
+    createdAt: Date;
+    id: string;
+}): string;
+declare function decodeFactCursor(cursor: string): {
+    createdAt: Date;
+    id: string;
+};
+declare function listFactsPage(memory: CodeBuddy, repository: MemoryRepository, input: {
+    subject?: string;
+    limit?: number;
+    cursor?: string;
+}): Promise<{
+    nextCursor?: string;
+    facts: ListedFact[];
+}>;
+declare function inspectNamespace(repository: MemoryRepository, namespace?: string): Promise<{
+    namespaces: NamespaceSummary[];
+    agents: AgentWriteBreakdown[];
+    namespace?: never;
+    exists?: never;
+    facts?: never;
+} | {
+    namespace: string;
+    exists: boolean;
+    facts: ListedFact[];
+    agents: AgentWriteBreakdown[];
+    namespaces?: never;
+}>;
+type DoctorReport = {
+    db: {
+        ok: boolean;
+        error?: string;
+        canConnect?: boolean;
+        postgresUrlSource?: string;
+    };
+    pgvector: {
+        ok: boolean;
+        error?: string;
+    };
+    vectors: {
+        count: number;
+        index: string | null;
+        needsTuning: boolean;
+    };
+    models: {
+        id: string;
+        reachable: boolean;
+        status: "unknown" | "warm" | "cold" | "gated" | "failed";
+        error?: string;
+    }[];
+    usage: {
+        last60s: number;
+        lastHour: number;
+        last24h: number;
+        estimatedDailyCapRemaining: number;
+        warning80Percent: boolean;
+    };
+    scaffold: Awaited<ReturnType<typeof checkProjectScaffold>>;
+    config: Awaited<ReturnType<typeof checkConfigPermissions>>;
+    namespace: {
+        expectedDefault: string;
+        configured: string | null;
+        runtime: string | null;
+        ok: boolean;
+        warning?: string;
+    };
+};
+declare function runDoctor(options?: {
+    config?: CodeBuddyConfig;
+    repository?: MemoryRepository;
+    provider?: ModelProvider;
+    skipModelCheck?: boolean;
+}): Promise<DoctorReport>;
+
+/**
+ * Plans are durable Markdown artifacts under `.codebuddy/plans/`. Git is
+ * the version history; PostgreSQL (when present) is a derived index, never
+ * the source of truth. This store owns the on-disk representation:
+ * schema, round-trip serialization, atomic writes, and the locks that keep
+ * concurrent CLI/MCP clients from corrupting a plan or approving two active
+ * plans in one namespace.
+ */
+declare const PLAN_STATUSES: readonly ["draft", "approved", "executing", "complete", "abandoned"];
+type PlanStatus = (typeof PLAN_STATUSES)[number];
+/** A plan is "active" while approved or executing — at most one per namespace. */
+declare const ACTIVE_PLAN_STATUSES: readonly PlanStatus[];
+declare const plannedFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    action: z.ZodEnum<{
+        delete: "delete";
+        create: "create";
+        edit: "edit";
+    }>;
+    notes: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const plannedTestSchema: z.ZodObject<{
+    path: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+declare const planFrontMatterSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodString;
+    namespace: z.ZodString;
+    type: z.ZodLiteral<"plan">;
+    title: z.ZodString;
+    status: z.ZodEnum<{
+        draft: "draft";
+        approved: "approved";
+        executing: "executing";
+        complete: "complete";
+        abandoned: "abandoned";
+    }>;
+    brief: z.ZodString;
+    filesToTouch: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        action: z.ZodEnum<{
+            delete: "delete";
+            create: "create";
+            edit: "edit";
+        }>;
+        notes: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    testsToAdd: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        description: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    outOfScope: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    createdAt: z.ZodPreprocess<z.ZodString, unknown>;
+    createdByAgent: z.ZodNullable<z.ZodString>;
+    approvedAt: z.ZodNullable<z.ZodPreprocess<z.ZodNullable<z.ZodString>, unknown>>;
+    executingAt: z.ZodNullable<z.ZodPreprocess<z.ZodNullable<z.ZodString>, unknown>>;
+    completedAt: z.ZodNullable<z.ZodPreprocess<z.ZodNullable<z.ZodString>, unknown>>;
+    abandonedAt: z.ZodNullable<z.ZodPreprocess<z.ZodNullable<z.ZodString>, unknown>>;
+    commitSha: z.ZodNullable<z.ZodString>;
+    abandonReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type PlannedFile = z.infer<typeof plannedFileSchema>;
+type PlannedTest = z.infer<typeof plannedTestSchema>;
+type PlanFrontMatter = z.infer<typeof planFrontMatterSchema>;
+/** A fully materialized plan: front matter + Markdown body + on-disk path. */
+type PlanSpec = PlanFrontMatter & {
+    body: string;
+    path: string;
+};
+/** Shape accepted by `writePlan` — path/schemaVersion/type are managed here. */
+type PlanWrite = Omit<PlanFrontMatter, "schemaVersion" | "type"> & {
+    body: string;
+};
+type PlanLockOptions = {
+    /** Max time to wait for the lock before failing. */
+    timeoutMs?: number;
+    /** A lock older than this is considered abandoned and stolen. */
+    staleMs?: number;
+    /** Poll interval while waiting. */
+    pollMs?: number;
+};
+declare class PlanLockError extends Error {
+    constructor(resource: string);
+}
+declare class PlanValidationError extends Error {
+    constructor(path: string, issues: string[]);
+}
+declare class PlanFileStore {
+    readonly repositoryRoot: string;
+    readonly plansDirectory: string;
+    readonly locksDirectory: string;
+    constructor(repositoryRoot?: string);
+    writePlan(input: PlanWrite): Promise<string>;
+    readPlan(pathOrId: string): Promise<PlanSpec>;
+    listPlans(): Promise<PlanSpec[]>;
+    deletePlan(id: string): Promise<void>;
+    /**
+     * The single approved-or-executing plan in `namespace`, or null. If the
+     * filesystem somehow holds more than one (a hand edit, a crash mid-
+     * transition), the earliest-created wins and the situation is the
+     * caller's to reconcile.
+     */
+    findActivePlan(namespace: string): Promise<PlanSpec | null>;
+    /** Serialize amendments to a single plan. */
+    withPlanLock<T>(id: string, fn: () => Promise<T>, options?: PlanLockOptions): Promise<T>;
+    /**
+     * Serialize lifecycle transitions across an entire namespace so two
+     * clients cannot both promote a plan to active. Hold this around the
+     * read-active-then-write window.
+     */
+    withNamespaceLock<T>(namespace: string, fn: () => Promise<T>, options?: PlanLockOptions): Promise<T>;
+    private withLock;
+    private tryStealStaleLock;
+    private planPath;
+    private assertPlanId;
+    private safePath;
+    private prepareDirectory;
+}
+
+declare class PlanTransitionError extends Error {
+    constructor(from: PlanStatus, to: PlanStatus);
+}
+declare class PlanNotFoundError extends Error {
+    constructor(id: string);
+}
+declare class ActivePlanExistsError extends Error {
+    readonly activePlanId: string;
+    constructor(namespace: string, activePlanId: string);
+}
+type CreatePlanInput = {
+    namespace: string;
+    title: string;
+    brief: string;
+    body?: string;
+    filesToTouch?: PlannedFile[];
+    testsToAdd?: PlannedTest[];
+    outOfScope?: string[];
+    risks?: string[];
+    createdByAgent?: string | null;
+    now?: string;
+};
+type AmendPlanPatch = {
+    title?: string;
+    brief?: string;
+    body?: string;
+    filesToTouch?: PlannedFile[];
+    testsToAdd?: PlannedTest[];
+    outOfScope?: string[];
+    risks?: string[];
+};
+type CompleteOptions = {
+    commitSha?: string;
+    notes?: string;
+};
+type AbandonOptions = {
+    reason?: string;
+};
+declare class PlanLifecycle {
+    private readonly store;
+    constructor(store: PlanFileStore);
+    create(input: CreatePlanInput): Promise<PlanSpec>;
+    approve(id: string, now?: string): Promise<PlanSpec>;
+    start(id: string, now?: string): Promise<PlanSpec>;
+    complete(id: string, options?: CompleteOptions, now?: string): Promise<PlanSpec>;
+    abandon(id: string, options?: AbandonOptions, now?: string): Promise<PlanSpec>;
+    amend(id: string, patch: AmendPlanPatch): Promise<PlanSpec>;
+    current(namespace: string): Promise<PlanSpec | null>;
+    private assertTransition;
+    private require;
+    /** Rewrite the plan file with a partial set of changed fields. */
+    private rewrite;
+}
+
+declare const VECTOR_DIMENSIONS = 384;
+declare const HNSW_M = 16;
+declare const HNSW_EF_CONSTRUCTION = 64;
+declare const memoryTypeEnum: drizzle_orm_pg_core.PgEnum<["interaction", "fact", "summary"]>;
+declare const interactionRoleEnum: drizzle_orm_pg_core.PgEnum<["user", "assistant", "system"]>;
+declare const embeddingOwnerTypeEnum: drizzle_orm_pg_core.PgEnum<["interaction", "fact", "summary"]>;
+declare const embeddingStatusEnum: drizzle_orm_pg_core.PgEnum<["pending", "processing", "ready", "failed"]>;
+declare const shareModeEnum: drizzle_orm_pg_core.PgEnum<["reference", "snapshot"]>;
+declare const modelCallTypeEnum: drizzle_orm_pg_core.PgEnum<["embedding", "llm"]>;
+declare const modelCallStatusEnum: drizzle_orm_pg_core.PgEnum<["success", "failed", "timeout", "rate_limited", "gated", "fallback"]>;
+declare const auditActionEnum: drizzle_orm_pg_core.PgEnum<["remember", "remember_batch", "share", "forget", "config"]>;
+declare const namespaces: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "namespaces";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "namespaces";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: drizzle_orm_pg_core.PgColumn<{
+            name: "name";
+            tableName: "namespaces";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "namespaces";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "namespaces";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const interactions: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "interactions";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sessionId: drizzle_orm_pg_core.PgColumn<{
+            name: "session_id";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: drizzle_orm_pg_core.PgColumn<{
+            name: "role";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "user" | "assistant" | "system";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["user", "assistant", "system"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        content: drizzle_orm_pg_core.PgColumn<{
+            name: "content";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentHash: drizzle_orm_pg_core.PgColumn<{
+            name: "content_hash";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tokenCount: drizzle_orm_pg_core.PgColumn<{
+            name: "token_count";
+            tableName: "interactions";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdByAgent: drizzle_orm_pg_core.PgColumn<{
+            name: "created_by_agent";
+            tableName: "interactions";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "interactions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const sessionSummaries: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "session_summaries";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sessionId: drizzle_orm_pg_core.PgColumn<{
+            name: "session_id";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        content: drizzle_orm_pg_core.PgColumn<{
+            name: "content";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: drizzle_orm_pg_core.PgColumn<{
+            name: "version";
+            tableName: "session_summaries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tokenCount: drizzle_orm_pg_core.PgColumn<{
+            name: "token_count";
+            tableName: "session_summaries";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdByAgent: drizzle_orm_pg_core.PgColumn<{
+            name: "created_by_agent";
+            tableName: "session_summaries";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fileBacked: drizzle_orm_pg_core.PgColumn<{
+            name: "file_backed";
+            tableName: "session_summaries";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "session_summaries";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const facts: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "facts";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        subject: drizzle_orm_pg_core.PgColumn<{
+            name: "subject";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        predicate: drizzle_orm_pg_core.PgColumn<{
+            name: "predicate";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        object: drizzle_orm_pg_core.PgColumn<{
+            name: "object";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        propositionKey: drizzle_orm_pg_core.PgColumn<{
+            name: "proposition_key";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        content: drizzle_orm_pg_core.PgColumn<{
+            name: "content";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        contentHash: drizzle_orm_pg_core.PgColumn<{
+            name: "content_hash";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        confidence: drizzle_orm_pg_core.PgColumn<{
+            name: "confidence";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgNumeric";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceInteractionId: drizzle_orm_pg_core.PgColumn<{
+            name: "source_interaction_id";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceDeleted: drizzle_orm_pg_core.PgColumn<{
+            name: "source_deleted";
+            tableName: "facts";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        supersededBy: drizzle_orm_pg_core.PgColumn<{
+            name: "superseded_by";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fileBacked: drizzle_orm_pg_core.PgColumn<{
+            name: "file_backed";
+            tableName: "facts";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        embeddingModel: drizzle_orm_pg_core.PgColumn<{
+            name: "embedding_model";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdByAgent: drizzle_orm_pg_core.PgColumn<{
+            name: "created_by_agent";
+            tableName: "facts";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "facts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "facts";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const embeddings: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "embeddings";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerType: drizzle_orm_pg_core.PgColumn<{
+            name: "owner_type";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "interaction" | "fact" | "summary";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["interaction", "fact", "summary"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerId: drizzle_orm_pg_core.PgColumn<{
+            name: "owner_id";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        vector: drizzle_orm_pg_core.PgColumn<{
+            name: "vector";
+            tableName: "embeddings";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+        }>;
+        embeddingModel: drizzle_orm_pg_core.PgColumn<{
+            name: "embedding_model";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        embeddingSpace: drizzle_orm_pg_core.PgColumn<{
+            name: "embedding_space";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "pending" | "processing" | "ready" | "failed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "processing", "ready", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: drizzle_orm_pg_core.PgColumn<{
+            name: "attempts";
+            tableName: "embeddings";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastError: drizzle_orm_pg_core.PgColumn<{
+            name: "last_error";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        leaseUntil: drizzle_orm_pg_core.PgColumn<{
+            name: "lease_until";
+            tableName: "embeddings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        leaseToken: drizzle_orm_pg_core.PgColumn<{
+            name: "lease_token";
+            tableName: "embeddings";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "embeddings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: drizzle_orm_pg_core.PgColumn<{
+            name: "updated_at";
+            tableName: "embeddings";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const shares: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "shares";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromNamespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "from_namespace_id";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        toNamespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "to_namespace_id";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceFactId: drizzle_orm_pg_core.PgColumn<{
+            name: "source_fact_id";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        snapshotFactId: drizzle_orm_pg_core.PgColumn<{
+            name: "snapshot_fact_id";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mode: drizzle_orm_pg_core.PgColumn<{
+            name: "mode";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "reference" | "snapshot";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["reference", "snapshot"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tombstoned: drizzle_orm_pg_core.PgColumn<{
+            name: "tombstoned";
+            tableName: "shares";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdByAgent: drizzle_orm_pg_core.PgColumn<{
+            name: "created_by_agent";
+            tableName: "shares";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "shares";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const checkpoints: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "checkpoints";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        threadId: drizzle_orm_pg_core.PgColumn<{
+            name: "thread_id";
+            tableName: "checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        checkpointId: drizzle_orm_pg_core.PgColumn<{
+            name: "checkpoint_id";
+            tableName: "checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parentId: drizzle_orm_pg_core.PgColumn<{
+            name: "parent_id";
+            tableName: "checkpoints";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        channelValues: drizzle_orm_pg_core.PgColumn<{
+            name: "channel_values";
+            tableName: "checkpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "checkpoints";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "checkpoints";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const modelCalls: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "model_calls";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "model_calls";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "model_calls";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        model: drizzle_orm_pg_core.PgColumn<{
+            name: "model";
+            tableName: "model_calls";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: drizzle_orm_pg_core.PgColumn<{
+            name: "type";
+            tableName: "model_calls";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "embedding" | "llm";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["embedding", "llm"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        latencyMs: drizzle_orm_pg_core.PgColumn<{
+            name: "latency_ms";
+            tableName: "model_calls";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tokens: drizzle_orm_pg_core.PgColumn<{
+            name: "tokens";
+            tableName: "model_calls";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: drizzle_orm_pg_core.PgColumn<{
+            name: "status";
+            tableName: "model_calls";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "fallback" | "failed" | "success" | "timeout" | "rate_limited" | "gated";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["success", "failed", "timeout", "rate_limited", "gated", "fallback"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: drizzle_orm_pg_core.PgColumn<{
+            name: "error";
+            tableName: "model_calls";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "model_calls";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "model_calls";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+declare const auditLog: drizzle_orm_pg_core.PgTableWithColumns<{
+    name: "audit_log";
+    schema: undefined;
+    columns: {
+        id: drizzle_orm_pg_core.PgColumn<{
+            name: "id";
+            tableName: "audit_log";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        namespaceId: drizzle_orm_pg_core.PgColumn<{
+            name: "namespace_id";
+            tableName: "audit_log";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        action: drizzle_orm_pg_core.PgColumn<{
+            name: "action";
+            tableName: "audit_log";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "config" | "remember" | "remember_batch" | "share" | "forget";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["remember", "remember_batch", "share", "forget", "config"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityType: drizzle_orm_pg_core.PgColumn<{
+            name: "entity_type";
+            tableName: "audit_log";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        entityId: drizzle_orm_pg_core.PgColumn<{
+            name: "entity_id";
+            tableName: "audit_log";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdByAgent: drizzle_orm_pg_core.PgColumn<{
+            name: "created_by_agent";
+            tableName: "audit_log";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        metadata: drizzle_orm_pg_core.PgColumn<{
+            name: "metadata";
+            tableName: "audit_log";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: drizzle_orm_pg_core.PgColumn<{
+            name: "created_at";
+            tableName: "audit_log";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+
+declare const schema_HNSW_EF_CONSTRUCTION: typeof HNSW_EF_CONSTRUCTION;
+declare const schema_HNSW_M: typeof HNSW_M;
+declare const schema_VECTOR_DIMENSIONS: typeof VECTOR_DIMENSIONS;
+declare const schema_auditActionEnum: typeof auditActionEnum;
+declare const schema_auditLog: typeof auditLog;
+declare const schema_checkpoints: typeof checkpoints;
+declare const schema_embeddingOwnerTypeEnum: typeof embeddingOwnerTypeEnum;
+declare const schema_embeddingStatusEnum: typeof embeddingStatusEnum;
+declare const schema_embeddings: typeof embeddings;
+declare const schema_facts: typeof facts;
+declare const schema_interactionRoleEnum: typeof interactionRoleEnum;
+declare const schema_interactions: typeof interactions;
+declare const schema_memoryTypeEnum: typeof memoryTypeEnum;
+declare const schema_modelCallStatusEnum: typeof modelCallStatusEnum;
+declare const schema_modelCallTypeEnum: typeof modelCallTypeEnum;
+declare const schema_modelCalls: typeof modelCalls;
+declare const schema_namespaces: typeof namespaces;
+declare const schema_sessionSummaries: typeof sessionSummaries;
+declare const schema_shareModeEnum: typeof shareModeEnum;
+declare const schema_shares: typeof shares;
+declare namespace schema {
+  export { schema_HNSW_EF_CONSTRUCTION as HNSW_EF_CONSTRUCTION, schema_HNSW_M as HNSW_M, schema_VECTOR_DIMENSIONS as VECTOR_DIMENSIONS, schema_auditActionEnum as auditActionEnum, schema_auditLog as auditLog, schema_checkpoints as checkpoints, schema_embeddingOwnerTypeEnum as embeddingOwnerTypeEnum, schema_embeddingStatusEnum as embeddingStatusEnum, schema_embeddings as embeddings, schema_facts as facts, schema_interactionRoleEnum as interactionRoleEnum, schema_interactions as interactions, schema_memoryTypeEnum as memoryTypeEnum, schema_modelCallStatusEnum as modelCallStatusEnum, schema_modelCallTypeEnum as modelCallTypeEnum, schema_modelCalls as modelCalls, schema_namespaces as namespaces, schema_sessionSummaries as sessionSummaries, schema_shareModeEnum as shareModeEnum, schema_shares as shares };
+}
+
+type DatabaseClientConfig = {
+    postgresUrl: string;
+    maxConnections?: number;
+};
+type DatabaseClient = ReturnType<typeof createDatabaseClient>;
+declare function createDatabaseClient(config: DatabaseClientConfig): {
+    sql: postgres.Sql<{}>;
+    db: drizzle_orm_postgres_js.PostgresJsDatabase<typeof schema> & {
+        $client: postgres.Sql<{}>;
+    };
+    close(): Promise<void>;
+};
+
+declare function createPostgresRepository(client: DatabaseClient): MemoryRepository;
+
+type ModuleNode = {
+    path: string;
+    language: "ts" | "js";
+    imports: string[];
+};
+type ModuleEdge = {
+    from: string;
+    to: string;
+    kind: "import" | "dynamic_import";
+    /**
+     * Names the dependant uses from the dependency, when the source graph knows
+     * them. The regex import map does not, so this is absent there.
+     */
+    symbols?: string[];
+};
+type ArchitectureMap = {
+    modules: ModuleNode[];
+    edges: ModuleEdge[];
+    /** The sources combined for this request; absent on raw cached/imported maps. */
+    source?: "imports" | "graphify+imports";
+};
+type MapQuery = {
+    from?: string;
+    to?: string;
+    limit?: number;
+};
+
+declare function buildArchitectureMap(repositoryRoot?: string): Promise<ArchitectureMap>;
+declare function queryMap(map: ArchitectureMap, query: MapQuery): ModuleEdge[];
+declare function neighbours(map: ArchitectureMap, modulePath: string, direction?: "in" | "out" | "both"): {
+    modules: ModuleNode[];
+    edges: ModuleEdge[];
+};
+
+type StartMcpServerOptions = {
+    config?: CodeBuddyConfig;
+};
+declare function startMcpServer(options?: StartMcpServerOptions): Promise<void>;
+
+type DatabaseServices = {
+    memory: CodeBuddy;
+    repository: MemoryRepository;
+};
+type DatabaseStatus = {
+    available: boolean;
+    state: "idle" | "connecting" | "ready" | "unavailable";
+    error?: string;
+    retryInMs?: number;
+};
+type LazyDatabase = {
+    /** Resolve the runtime, connecting (or retrying after the cooldown) on demand. */
+    get(): Promise<DatabaseServices>;
+    status(): DatabaseStatus;
+    close(): Promise<void>;
+};
+
+declare const mcpToolInputSchemas: {
+    readonly remember: z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        type: z.ZodOptional<z.ZodEnum<{
+            interaction: "interaction";
+            fact: "fact";
+            summary: "summary";
+        }>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly remember_batch: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            sessionId: z.ZodOptional<z.ZodString>;
+            content: z.ZodString;
+            type: z.ZodOptional<z.ZodEnum<{
+                interaction: "interaction";
+                fact: "fact";
+                summary: "summary";
+            }>>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            agentId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    readonly recall: z.ZodObject<{
+        sessionId: z.ZodString;
+        query: z.ZodString;
+        budget: z.ZodOptional<z.ZodNumber>;
+        callerModel: z.ZodOptional<z.ZodString>;
+        conflictMode: z.ZodOptional<z.ZodEnum<{
+            all: "all";
+            latest: "latest";
+            highest_confidence: "highest_confidence";
+        }>>;
+    }, z.core.$strip>;
+    readonly list_facts: z.ZodObject<{
+        subject: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly list_namespaces: z.ZodObject<{}, z.core.$strip>;
+    readonly forget: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+    readonly share: z.ZodObject<{
+        from: z.ZodOptional<z.ZodString>;
+        to_namespace: z.ZodString;
+        factIds: z.ZodArray<z.ZodString>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            reference: "reference";
+            snapshot: "snapshot";
+        }>>;
+        to_project_root: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly unshare: z.ZodObject<{
+        to_namespace: z.ZodString;
+        factIds: z.ZodArray<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly plan_current: z.ZodObject<{}, z.core.$strip>;
+    readonly plan_create: z.ZodObject<{
+        title: z.ZodString;
+        brief: z.ZodString;
+        body: z.ZodOptional<z.ZodString>;
+        filesToTouch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            action: z.ZodEnum<{
+                delete: "delete";
+                create: "create";
+                edit: "edit";
+            }>;
+            notes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        testsToAdd: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        outOfScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        risks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        agentId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly plan_amend: z.ZodObject<{
+        id: z.ZodString;
+        patch: z.ZodObject<{
+            title: z.ZodOptional<z.ZodString>;
+            brief: z.ZodOptional<z.ZodString>;
+            body: z.ZodOptional<z.ZodString>;
+            filesToTouch: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                action: z.ZodEnum<{
+                    delete: "delete";
+                    create: "create";
+                    edit: "edit";
+                }>;
+                notes: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            testsToAdd: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            outOfScope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            risks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    readonly plan_status: z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            approved: "approved";
+            executing: "executing";
+            complete: "complete";
+            abandoned: "abandoned";
+        }>;
+        commitSha: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly risk_assess: z.ZodObject<{
+        planId: z.ZodOptional<z.ZodString>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        evidence: z.ZodOptional<z.ZodEnum<{
+            source: "source";
+            overview: "overview";
+        }>>;
+        useGit: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly map_query: z.ZodObject<{
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly map_neighbours: z.ZodObject<{
+        module: z.ZodString;
+        direction: z.ZodDefault<z.ZodEnum<{
+            in: "in";
+            out: "out";
+            both: "both";
+        }>>;
+    }, z.core.$strip>;
+    readonly context_bootstrap: z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ack: z.ZodOptional<z.ZodString>;
+        full: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    readonly context_before_edit: z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ack: z.ZodOptional<z.ZodString>;
+        full: z.ZodOptional<z.ZodBoolean>;
+        task: z.ZodOptional<z.ZodString>;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        planId: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodEnum<{
+            source: "source";
+            overview: "overview";
+        }>>;
+        useGit: z.ZodOptional<z.ZodBoolean>;
+        tokenBudget: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly context_pack: z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ack: z.ZodOptional<z.ZodString>;
+        full: z.ZodOptional<z.ZodBoolean>;
+        task: z.ZodString;
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        planId: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodEnum<{
+            source: "source";
+            overview: "overview";
+        }>>;
+        useGit: z.ZodOptional<z.ZodBoolean>;
+        tokenBudget: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly context_after_turn: z.ZodObject<{
+        summary: z.ZodString;
+        changedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        planId: z.ZodOptional<z.ZodString>;
+        taskType: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        verification: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        commitSha: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly code_suggestions: z.ZodObject<{
+        paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        planId: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodOptional<z.ZodEnum<{
+            source: "source";
+            overview: "overview";
+        }>>;
+        useGit: z.ZodOptional<z.ZodBoolean>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    readonly health: z.ZodObject<{}, z.core.$strip>;
+};
+/**
+ * Client tool profiles (#45). `full` (default) lists every tool; `core` lists
+ * only the automatic context workflow, so a client pays a fraction of the
+ * tool-schema tokens per session. Set `CODEBUDDY_TOOL_PROFILE=core` in the
+ * client's MCP server environment.
+ */
+type ToolProfile = "core" | "full";
+type RegisterCodeBuddyToolsOptions = {
+    memory: CodeBuddy;
+    repository: MemoryRepository;
+} | {
+    /** File-based tools read only namespace/projectRoot/tokenBudget from this. */
+    config: Pick<CodeBuddyConfig, "namespace"> & {
+        projectRoot?: string | undefined;
+        tokenBudget?: number | undefined;
+    };
+    /** Optional PostgreSQL services; database tools degrade while it is unavailable. */
+    database: Pick<LazyDatabase, "get" | "status">;
+};
+declare function registerCodeBuddyTools(server: McpServer, options: RegisterCodeBuddyToolsOptions, profile?: ToolProfile): void;
+
+/**
+ * Exact cl100k token count. A context request tokenizes nearly the same JSON
+ * several times (stats, stages, budget fixed point, delivery), so BPE results
+ * are memoized per pre-tokenized piece; the sum equals `encode(text).length`.
+ */
+declare function countTokens(text: string): number;
+type BudgetClampResult = {
+    budget: number;
+    clamped: boolean;
+    reason?: string;
+};
+declare function clampBudgetForCallerModel(requestedBudget: number, callerModel: string | undefined): BudgetClampResult;
+
+type DefaultPolicyOptions = {
+    recencyFloorSize?: number;
+    embeddingCandidateLimit?: number;
+    minVectorScore?: number;
+};
+declare class DefaultPolicy implements ContextPolicy {
+    private readonly recencyFloorSize;
+    private readonly embeddingCandidateLimit;
+    private readonly minVectorScore;
+    constructor(options?: DefaultPolicyOptions);
+    plan(input: PlanInput): Promise<PlannedContext>;
+    private hydrateScored;
+    private applyRecencyFloor;
+    private buildFallbackCandidates;
+    /**
+     * Resolve rival assertions of the same explicit proposition key. Facts without
+     * a key are treated as multi-valued and never grouped, so identical or
+     * different surface text alone never merges or splits claims.
+     */
+    private applyConflictMode;
+}
+
+type ModelRole = "primary" | "fallback" | "last_resort";
+type ModelKind = "embedding" | "llm";
+type ModelDefinition = {
+    id: string;
+    role: ModelRole;
+    kind: ModelKind;
+    dimensions?: number;
+    /** Actual deployment revision metadata; this does not pin Hugging Face requests. */
+    revision?: string;
+    schema?: string;
+    contextWindow?: number;
+    dailyCallBudget?: number;
+    supportsBatch?: boolean;
+};
+
+type ResilienceOptions = {
+    retries: number;
+    concurrency: number;
+    rateLimitPerMinute: number;
+    timeoutMs: number;
+    warmCacheTtlMs: number;
+    coldStartBufferMs: number;
+    jitterMs: number;
+    minRetryTimeoutMs: number;
+    maxRetryTimeoutMs: number;
+};
+
+type HuggingFaceProviderOptions = {
+    apiKey?: string;
+    client?: Pick<HfInference, "featureExtraction" | "textGeneration">;
+    embeddingModels?: ModelDefinition[];
+    llmModels?: ModelDefinition[];
+    resilience?: Partial<ResilienceOptions>;
+    onDiagnostic?: ProviderDiagnosticsHook;
+};
+declare class HuggingFaceProvider implements ModelProvider {
+    private readonly client;
+    private readonly embeddingModels;
+    private readonly llmModels;
+    private readonly resilience;
+    private readonly onDiagnostic;
+    constructor(options?: HuggingFaceProviderOptions);
+    embed(request: EmbeddingRequest): Promise<EmbeddingResponse>;
+    generateText(request: TextGenerationRequest): Promise<TextGenerationResponse>;
+}
+
+/**
+ * Risk model (Proposal 03.1). A risk assessment is a deterministic,
+ * evidence-backed ranking of the files in a pending change set. Every score
+ * traces to one or more signals, and every signal cites its evidence — a risk
+ * that cannot be explained is noise, not risk. No LLM judgement enters here.
+ */
+type RiskCategory = "blast_radius" | "churn" | "incident" | "type_failure" | "policy";
+type Evidence = {
+    kind: "dependent_module";
+    path: string;
+    depth: number;
+} | {
+    kind: "git_commit";
+    sha: string;
+    message: string;
+    ts: string;
+} | {
+    kind: "memory_fact";
+    factId: string;
+    content: string;
+    createdAt: string;
+} | {
+    kind: "ci_failure";
+    runId: string;
+    conclusion: string;
+    ts: string;
+} | {
+    kind: "policy_rule";
+    ruleId: string;
+    pattern: string;
+};
+/** One signal's verdict on one path. */
+type SignalContribution = {
+    path: string;
+    /** 0–100 within this signal's own scale. */
+    weight: number;
+    reason: string;
+    evidence: Evidence[];
+};
+type AssessmentInput = {
+    /** Repo-relative paths in the change set. */
+    paths: string[];
+    /** Repository root, for signals that read the filesystem or git. */
+    repositoryRoot: string;
+    namespace: string;
+};
+type Signal = {
+    id: string;
+    category: RiskCategory;
+    /** Disabled signals are skipped entirely. */
+    enabled: boolean;
+    /** Relative importance when folding contributions into a score. */
+    coefficient: number;
+    assess(input: AssessmentInput): Promise<SignalContribution[]>;
+};
+type RiskItem = {
+    path: string;
+    /** 0–100 aggregate. */
+    score: number;
+    /** The category of the signal that contributed the most weight. */
+    category: RiskCategory;
+    /** The dominant signal's reason, for a one-line summary. */
+    reason: string;
+    /** Ids of every signal that contributed to this path. */
+    contributingSignals: string[];
+    evidence: Evidence[];
+};
+type SignalStat = {
+    id: string;
+    category: RiskCategory;
+    contributions: number;
+    totalWeight: number;
+};
+type AssessmentStats = {
+    pathsConsidered: number;
+    itemsProduced: number;
+    signalsRun: number;
+    perSignal: SignalStat[];
+};
+type Assessment = {
+    items: RiskItem[];
+    stats: AssessmentStats;
+};
+
+type AssessorOptions = {
+    /** Items scoring below this are dropped from the result. Default 0. */
+    minScore?: number;
+};
+/**
+ * Runs every enabled signal in parallel and folds their per-path
+ * contributions into a single ranked list. Scoring is deterministic: the
+ * same inputs and the same cache state always produce the same output, with
+ * stable tie-breaking.
+ */
+declare class RiskAssessor {
+    private readonly signals;
+    private readonly minScore;
+    constructor(signals: Signal[], options?: AssessorOptions);
+    assess(input: AssessmentInput): Promise<Assessment>;
+    /** Fold all contributions for one path into a single RiskItem. */
+    private fold;
+}
+
+type RiskAssessRequest = {
+    repositoryRoot?: string;
+    namespace: string;
+    paths?: string[];
+    planId?: string;
+    useGit?: boolean;
+    limit?: number;
+    signals?: Signal[];
+};
+declare function assessRisk(input: RiskAssessRequest): Promise<Assessment>;
+declare function resolveRiskPaths(input: {
+    repositoryRoot: string;
+    paths?: string[];
+    planId?: string;
+    useGit?: boolean;
+}): Promise<string[]>;
+
+type ChurnSignalOptions = {
+    repositoryRoot: string;
+    enabled?: boolean;
+    coefficient?: number;
+    since?: string;
+};
+declare function createChurnSignal(options: ChurnSignalOptions): Signal;
+
+type IncidentSignalOptions = {
+    store: MemoryFileStore;
+    enabled?: boolean;
+    coefficient?: number;
+    includeResolved?: boolean;
+};
+/**
+ * Historical incident signal (Proposal 03.2/03.5 foundation). It reads
+ * structured incident metadata from Markdown facts and produces one
+ * evidence-backed contribution per affected path.
+ */
+declare function createIncidentSignal(options: IncidentSignalOptions): Signal;
+
+declare const policyRuleSchema: z.ZodObject<{
+    id: z.ZodString;
+    pattern: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    weight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const policyFileSchema: z.ZodObject<{
+    rules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        pattern: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+        weight: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type PolicyRule = z.infer<typeof policyRuleSchema>;
+type PolicyFile = z.infer<typeof policyFileSchema>;
+type PolicySignalOptions = {
+    repositoryRoot: string;
+    enabled?: boolean;
+    coefficient?: number;
+    policyPath?: string;
+};
+declare function createPolicySignal(options: PolicySignalOptions): Signal;
+declare function readPolicyFile(path: string): Promise<PolicyFile>;
+
+export { ACTIVE_PLAN_STATUSES, type AbandonOptions, ActivePlanExistsError, type AmendPlanPatch, type ArchitectureMap, type Assessment, type AssessmentInput, type AssessmentStats, type AssessorOptions, type BudgetClampResult, type ChurnSignalOptions, CodeBuddy, CodeBuddyConfig, type CompleteOptions, ContextPolicy, type CreatePlanInput, DefaultPolicy, type DefaultPolicyOptions, EmbeddingRequest, EmbeddingResponse, type Evidence, HuggingFaceProvider, type HuggingFaceProviderOptions, type IncidentSignalOptions, type MapQuery, MemoryFileStore, MemoryRepository, type MigrationPreview, ModelProvider, type ModuleEdge, type ModuleNode, PLAN_POLICIES, PLAN_STATUSES, PlanFileStore, type PlanFrontMatter, PlanInput, PlanLifecycle, PlanLockError, type PlanLockOptions, PlanNotFoundError, type PlanPolicy, type PlanSpec, type PlanStatus, PlanTransitionError, PlanValidationError, type PlanWrite, PlannedContext, type PlannedFile, type PlannedTest, type PolicyFile, type PolicyRule, type PolicySignalOptions, type RiskAssessRequest, RiskAssessor, type RiskCategory, type RiskItem, type Signal, type SignalContribution, type SignalStat, assessRisk, buildArchitectureMap, checkConfigPermissions, clampBudgetForCallerModel, configPath, countTokens, createChurnSignal, createIncidentSignal, createPolicySignal, createPostgresRepository, createRuntime, decodeFactCursor, encodeFactCursor, initConfigFile, initProjectScaffold, inspectNamespace, listFactsPage, loadPlanPolicy, loadRuntimeConfig, mcpToolInputSchemas, migrateMemoryToFiles, neighbours, queryMap, readPolicyFile, redactSecrets, registerCodeBuddyTools, resolveRiskPaths, runDoctor, setPlanPolicy, startMcpServer };