@lapis-notes/ai 0.1.0

package/dist/conversations/transcript-store.js

@@ -0,0 +1,27 @@
+export function conversationStorageKey(location) {
+    return `${location.scopeDir}\u0000${location.conversationId}`;
+}
+export function cloneConversationSnapshot(snapshot) {
+    return structuredClone(snapshot);
+}
+export class ConversationWriteQueue {
+    pending = new Map();
+    async run(key, operation) {
+        const previous = this.pending.get(key) ?? Promise.resolve();
+        let release;
+        const gate = new Promise((resolve) => {
+            release = resolve;
+        });
+        const queued = previous.catch(() => undefined).then(() => gate);
+        this.pending.set(key, queued);
+        await previous.catch(() => undefined);
+        try {
+            return await operation();
+        }
+        finally {
+            release();
+            if (this.pending.get(key) === queued)
+                this.pending.delete(key);
+        }
+    }
+}

package/dist/conversations/types.d.ts

@@ -0,0 +1,224 @@
+import type { AgentUsage, AiThinkingLevel, ApprovalKind, ApprovalOption, ModelRef, UserInputQuestion } from "../core/types";
+export declare const CONVERSATION_SCHEMA_VERSION: 3;
+export declare const PREVIOUS_CONVERSATION_SCHEMA_VERSION: 2;
+export declare const LEGACY_CONVERSATION_SCHEMA_VERSION: 1;
+export type ConversationSchemaVersion = typeof LEGACY_CONVERSATION_SCHEMA_VERSION | typeof PREVIOUS_CONVERSATION_SCHEMA_VERSION | typeof CONVERSATION_SCHEMA_VERSION;
+export declare const CONVERSATION_ID_PATTERN: RegExp;
+export type ConversationLocation = {
+    scopeDir: string;
+    conversationId: string;
+};
+export type ConversationApprovalDecision = "allow-always" | "deny-always";
+export type ConversationApprovalGrant = {
+    name: string;
+    decision: ConversationApprovalDecision;
+};
+export type ConversationMetadata = {
+    schemaVersion: ConversationSchemaVersion;
+    id: string;
+    title?: string;
+    createdAt: string;
+    updatedAt: string;
+    launchContext?: {
+        notePath?: string;
+    };
+    workspace?: {
+        path: string;
+    };
+    activeAgentBindingId?: string;
+    approvalGrants?: ConversationApprovalGrant[];
+    pinned?: boolean;
+    status: "active" | "archived";
+};
+export type AgentBindingCreatedRecord = {
+    schemaVersion: ConversationSchemaVersion;
+    type: "binding.created";
+    id: string;
+    createdAt: string;
+    runtime: string;
+    agent?: string;
+    model?: ModelRef;
+    thinking?: AiThinkingLevel;
+    nativeSessionId?: string;
+    executionHostId?: string;
+    handoffThroughEntryId?: string;
+    replacesBindingId?: string;
+};
+export type AgentUsageRecord = {
+    schemaVersion: ConversationSchemaVersion;
+    type: "usage.updated";
+    id: string;
+    createdAt: string;
+    agentBindingId: string;
+    turnId?: string;
+    usage: AgentUsage;
+};
+export type HandoffProjectionMode = "full" | "delta" | "summary-tail";
+export type AgentBindingContextUpdatedRecord = {
+    schemaVersion: ConversationSchemaVersion;
+    type: "binding.context.updated";
+    id: string;
+    createdAt: string;
+    agentBindingId: string;
+    throughEntryId: string;
+    throughEntryHash: string;
+    cause: "native-turn" | "handoff";
+    handoffId?: string;
+    projectionMode?: HandoffProjectionMode;
+    omittedEntryCount?: number;
+};
+export type AgentBindingConfigUpdatedRecord = {
+    schemaVersion: ConversationSchemaVersion;
+    type: "binding.config.updated";
+    id: string;
+    createdAt: string;
+    agentBindingId: string;
+    model?: ModelRef;
+    thinking?: AiThinkingLevel;
+};
+export type HandoffSummaryCreatedRecord = {
+    schemaVersion: ConversationSchemaVersion;
+    type: "handoff.summary.created";
+    id: string;
+    createdAt: string;
+    conversationId: string;
+    fromEntryId: string;
+    throughEntryId: string;
+    sourceHash: string;
+    summary: string;
+    processor: {
+        runtime: string;
+        agent?: string;
+        model?: string;
+    };
+    estimatedTokens: number;
+};
+export type AgentBindingRecord = AgentBindingCreatedRecord | AgentUsageRecord | AgentBindingContextUpdatedRecord | AgentBindingConfigUpdatedRecord | HandoffSummaryCreatedRecord;
+export type RuntimeEventProvenance = {
+    sessionId: string;
+    runId: string;
+    sequence: number;
+};
+type TranscriptEntryBase = {
+    schemaVersion: ConversationSchemaVersion;
+    id: string;
+    createdAt: string;
+    parentId?: string;
+    agentBindingId?: string;
+    source?: RuntimeEventProvenance;
+    provenance?: {
+        originClass: "owner" | "agent" | "untrusted" | "system";
+        sourceKind: "user-message" | "assistant-message" | "runtime-output" | "owner-response" | "app-system";
+    };
+};
+export type TranscriptEntry = (TranscriptEntryBase & {
+    type: "message";
+    role: "user" | "assistant";
+    text: string;
+}) | (TranscriptEntryBase & {
+    type: "thinking.summary";
+    text: string;
+    kind?: "summary" | "plan";
+}) | (TranscriptEntryBase & {
+    type: "tool";
+    toolId: string;
+    name: string;
+    server?: string;
+    state: "completed" | "error" | "cancelled";
+    input?: string;
+    output?: string;
+    redacted?: boolean;
+    truncated?: boolean;
+}) | (TranscriptEntryBase & {
+    type: "approval.request";
+    requestId: string;
+    kind: ApprovalKind;
+    title: string;
+    tool?: {
+        name: string;
+        input?: string;
+    };
+    options: ApprovalOption[];
+    redacted?: boolean;
+    truncated?: boolean;
+}) | (TranscriptEntryBase & {
+    type: "approval.response";
+    requestId: string;
+    option: {
+        id: string;
+        label: string;
+    };
+}) | (TranscriptEntryBase & {
+    type: "question.request";
+    requestId: string;
+    title: string;
+    questions: UserInputQuestion[];
+}) | (TranscriptEntryBase & {
+    type: "question.response";
+    requestId: string;
+    status: "answered" | "cancelled";
+}) | (TranscriptEntryBase & {
+    type: "agent.switch";
+    fromBindingId?: string;
+    toBindingId: string;
+    handoffId?: string;
+    handoffMode?: HandoffProjectionMode;
+    handoffThroughEntryId?: string;
+    omittedEntryCount?: number;
+}) | (TranscriptEntryBase & {
+    type: "agent.config";
+    model?: ModelRef;
+    thinking?: AiThinkingLevel;
+}) | (TranscriptEntryBase & {
+    type: "system.notice";
+    text: string;
+    layout?: "report" | "inventory";
+    inventory?: {
+        kind: "skills" | "tools";
+        items: Array<{
+            name: string;
+            description?: string;
+            path?: string;
+            kind: "skill" | "tool";
+        }>;
+    };
+}) | (TranscriptEntryBase & {
+    type: "cancelled";
+    text?: string;
+    requestId?: string;
+    interactionType?: "approval" | "question";
+}) | (TranscriptEntryBase & {
+    type: "error";
+    message: string;
+    retryable?: boolean;
+}) | (TranscriptEntryBase & {
+    type: "command";
+    command: string;
+    origin: "app" | "extension" | "skill" | "native-agent";
+    arguments?: string;
+    status: "completed" | "failed" | "cancelled";
+}) | (TranscriptEntryBase & {
+    type: "skill-activation";
+    skillId: string;
+    skillName: string;
+    version: string;
+    origin: "user" | "model" | "app";
+    arguments?: string;
+});
+export type ConversationReadWarning = {
+    file: "agents.jsonl" | "transcript.jsonl";
+    line: number;
+    message: string;
+};
+export type ConversationSnapshot = {
+    location: ConversationLocation;
+    metadata: ConversationMetadata;
+    agents: AgentBindingRecord[];
+    transcript: TranscriptEntry[];
+    warnings: ConversationReadWarning[];
+};
+export declare class ConversationUnavailableError extends Error {
+    readonly location: ConversationLocation;
+    constructor(location: ConversationLocation, message: string, options?: ErrorOptions);
+}
+export {};

package/dist/conversations/types.js

@@ -0,0 +1,12 @@
+export const CONVERSATION_SCHEMA_VERSION = 3;
+export const PREVIOUS_CONVERSATION_SCHEMA_VERSION = 2;
+export const LEGACY_CONVERSATION_SCHEMA_VERSION = 1;
+export const CONVERSATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+export class ConversationUnavailableError extends Error {
+    location;
+    constructor(location, message, options) {
+        super(message, options);
+        this.location = location;
+        this.name = "ConversationUnavailableError";
+    }
+}

package/dist/conversations/validation.d.ts

@@ -0,0 +1,4 @@
+import { type AgentBindingRecord, type ConversationMetadata, type TranscriptEntry } from "./types";
+export declare function validateConversationMetadata(value: unknown): ConversationMetadata;
+export declare function validateAgentBindingRecord(value: unknown): AgentBindingRecord;
+export declare function validateTranscriptEntry(value: unknown): TranscriptEntry;

package/dist/conversations/validation.js

@@ -0,0 +1,383 @@
+import { MAX_CONVERSATION_APPROVAL_GRANTS, normalizeApprovalGrants, } from "./approval-grants";
+import { CONVERSATION_SCHEMA_VERSION, LEGACY_CONVERSATION_SCHEMA_VERSION, PREVIOUS_CONVERSATION_SCHEMA_VERSION, } from "./types";
+import { assertConversationId, normalizePortableVaultPath } from "./paths";
+function record(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    return value;
+}
+function requiredString(value, key, label) {
+    if (typeof value[key] !== "string" || !value[key]) {
+        throw new Error(`${label}.${key} must be a non-empty string`);
+    }
+    return value[key];
+}
+function assertSchemaVersion(value, label) {
+    if (value.schemaVersion !== CONVERSATION_SCHEMA_VERSION &&
+        value.schemaVersion !== PREVIOUS_CONVERSATION_SCHEMA_VERSION &&
+        value.schemaVersion !== LEGACY_CONVERSATION_SCHEMA_VERSION) {
+        throw new Error(`${label} uses an unsupported required schema version`);
+    }
+}
+function assertCurrentSchemaVersion(value, label) {
+    if (value.schemaVersion !== CONVERSATION_SCHEMA_VERSION) {
+        throw new Error(`${label} requires schema version 3`);
+    }
+}
+function assertModelRef(value, label) {
+    if (value == null)
+        return;
+    const model = record(value, label);
+    requiredString(model, "provider", label);
+    requiredString(model, "model", label);
+}
+function assertTimestamp(value, key, label) {
+    const timestamp = requiredString(value, key, label);
+    if (!Number.isFinite(Date.parse(timestamp))) {
+        throw new Error(`${label}.${key} must be an ISO timestamp`);
+    }
+}
+function assertOptionalString(value, key, label) {
+    if (value[key] != null && typeof value[key] !== "string") {
+        throw new Error(`${label}.${key} must be a string`);
+    }
+}
+function assertInventory(value, label) {
+    const inventory = record(value, `${label}.inventory`);
+    if (inventory.kind !== "skills" && inventory.kind !== "tools") {
+        throw new Error(`${label}.inventory.kind is invalid`);
+    }
+    if (!Array.isArray(inventory.items)) {
+        throw new Error(`${label}.inventory.items must be an array`);
+    }
+    for (const entry of inventory.items) {
+        const item = record(entry, `${label}.inventory.item`);
+        requiredString(item, "name", `${label}.inventory.item`);
+        if (item.kind !== "skill" && item.kind !== "tool") {
+            throw new Error(`${label}.inventory.item.kind is invalid`);
+        }
+        assertOptionalString(item, "description", `${label}.inventory.item`);
+        assertOptionalString(item, "path", `${label}.inventory.item`);
+    }
+}
+function assertPortableOptionalPath(value, label) {
+    if (value == null)
+        return;
+    if (typeof value !== "string")
+        throw new Error(`${label} must be a string`);
+    normalizePortableVaultPath(value, { allowRoot: true, label });
+}
+export function validateConversationMetadata(value) {
+    const data = record(value, "Conversation metadata");
+    assertSchemaVersion(data, "Conversation metadata");
+    assertConversationId(requiredString(data, "id", "Conversation metadata"));
+    assertTimestamp(data, "createdAt", "Conversation metadata");
+    assertTimestamp(data, "updatedAt", "Conversation metadata");
+    if (data.status !== "active" && data.status !== "archived") {
+        throw new Error("Conversation metadata.status is invalid");
+    }
+    if (data.title != null && typeof data.title !== "string") {
+        throw new Error("Conversation metadata.title must be a string");
+    }
+    if (typeof data.title === "string" &&
+        (/\r|\n/u.test(data.title) || [...data.title].length > 80)) {
+        throw new Error("Conversation metadata.title must be one line of at most 80 code points");
+    }
+    assertOptionalString(data, "activeAgentBindingId", "Conversation metadata");
+    if (data.launchContext != null) {
+        const launch = record(data.launchContext, "Conversation launchContext");
+        assertPortableOptionalPath(launch.notePath, "Conversation launchContext.notePath");
+    }
+    if (data.workspace != null) {
+        const workspace = record(data.workspace, "Conversation workspace");
+        requiredString(workspace, "path", "Conversation workspace");
+        assertPortableOptionalPath(workspace.path, "Conversation workspace.path");
+    }
+    if (data.approvalGrants != null) {
+        if (!Array.isArray(data.approvalGrants)) {
+            throw new Error("Conversation metadata.approvalGrants must be an array");
+        }
+        if (data.approvalGrants.length > MAX_CONVERSATION_APPROVAL_GRANTS) {
+            throw new Error("Conversation metadata.approvalGrants exceeds the stored limit");
+        }
+        const grants = normalizeApprovalGrants(data.approvalGrants);
+        if (grants.length > 0)
+            data.approvalGrants = grants;
+        else
+            delete data.approvalGrants;
+    }
+    if (data.pinned != null && typeof data.pinned !== "boolean") {
+        throw new Error("Conversation metadata.pinned must be a boolean");
+    }
+    if (data.pinned === false)
+        delete data.pinned;
+    return data;
+}
+export function validateAgentBindingRecord(value) {
+    const data = record(value, "Agent record");
+    assertSchemaVersion(data, "Agent record");
+    requiredString(data, "id", "Agent record");
+    assertTimestamp(data, "createdAt", "Agent record");
+    if (data.type === "binding.created") {
+        requiredString(data, "runtime", "Agent record");
+        for (const key of [
+            "agent",
+            "nativeSessionId",
+            "executionHostId",
+            "handoffThroughEntryId",
+            "replacesBindingId",
+        ]) {
+            assertOptionalString(data, key, "Agent record");
+        }
+    }
+    else if (data.type === "usage.updated") {
+        requiredString(data, "agentBindingId", "Agent record");
+        const usage = record(data.usage, "Agent record usage");
+        if (typeof usage.used !== "number" ||
+            typeof usage.limit !== "number" ||
+            !Number.isFinite(usage.used) ||
+            !Number.isFinite(usage.limit) ||
+            usage.used < 0 ||
+            usage.limit <= 0) {
+            throw new Error("Agent record usage is invalid");
+        }
+    }
+    else if (data.type === "binding.context.updated") {
+        assertCurrentSchemaVersion(data, "Agent context record");
+        requiredString(data, "agentBindingId", "Agent record");
+        requiredString(data, "throughEntryId", "Agent record");
+        const hash = requiredString(data, "throughEntryHash", "Agent record");
+        if (!/^[0-9a-f]{64}$/u.test(hash)) {
+            throw new Error("Agent record.throughEntryHash is invalid");
+        }
+        if (data.cause !== "native-turn" && data.cause !== "handoff") {
+            throw new Error("Agent record.cause is invalid");
+        }
+        assertOptionalString(data, "handoffId", "Agent record");
+        assertProjectionMode(data.projectionMode, "Agent record.projectionMode");
+        assertOptionalCount(data.omittedEntryCount, "Agent record.omittedEntryCount");
+    }
+    else if (data.type === "binding.config.updated") {
+        assertCurrentSchemaVersion(data, "Agent configuration record");
+        requiredString(data, "agentBindingId", "Agent record");
+        assertModelRef(data.model, "Agent record.model");
+        assertThinking(data.thinking, "Agent record.thinking");
+        if (data.model == null && data.thinking == null) {
+            throw new Error("Agent configuration record must change a field");
+        }
+    }
+    else if (data.type === "handoff.summary.created") {
+        assertCurrentSchemaVersion(data, "Handoff summary record");
+        requiredString(data, "conversationId", "Agent record");
+        requiredString(data, "fromEntryId", "Agent record");
+        requiredString(data, "throughEntryId", "Agent record");
+        const hash = requiredString(data, "sourceHash", "Agent record");
+        if (!/^[0-9a-f]{64}$/u.test(hash)) {
+            throw new Error("Agent record.sourceHash is invalid");
+        }
+        requiredString(data, "summary", "Agent record");
+        const processor = record(data.processor, "Agent record processor");
+        requiredString(processor, "runtime", "Agent record processor");
+        requiredString(processor, "agent", "Agent record processor");
+        requiredString(processor, "model", "Agent record processor");
+        if (!Number.isSafeInteger(data.estimatedTokens) ||
+            Number(data.estimatedTokens) <= 0) {
+            throw new Error("Agent record.estimatedTokens is invalid");
+        }
+    }
+    else {
+        throw new Error("Agent record type is unsupported");
+    }
+    return data;
+}
+export function validateTranscriptEntry(value) {
+    const data = record(value, "Transcript entry");
+    assertSchemaVersion(data, "Transcript entry");
+    requiredString(data, "id", "Transcript entry");
+    assertTimestamp(data, "createdAt", "Transcript entry");
+    const types = new Set([
+        "message",
+        "thinking.summary",
+        "tool",
+        "approval.request",
+        "approval.response",
+        "question.request",
+        "question.response",
+        "agent.switch",
+        "agent.config",
+        "system.notice",
+        "cancelled",
+        "error",
+        "command",
+        "skill-activation",
+    ]);
+    if (typeof data.type !== "string" || !types.has(data.type)) {
+        throw new Error("Transcript entry type is unsupported");
+    }
+    if (data.source != null) {
+        const source = record(data.source, "Transcript entry source");
+        requiredString(source, "sessionId", "Transcript entry source");
+        requiredString(source, "runId", "Transcript entry source");
+        if (!Number.isSafeInteger(source.sequence) || Number(source.sequence) < 0) {
+            throw new Error("Transcript entry source.sequence is invalid");
+        }
+    }
+    if (data.provenance != null) {
+        const provenance = record(data.provenance, "Transcript entry provenance");
+        if (!["owner", "agent", "untrusted", "system"].includes(String(provenance.originClass))) {
+            throw new Error("Transcript entry provenance.originClass is invalid");
+        }
+        if (![
+            "user-message",
+            "assistant-message",
+            "runtime-output",
+            "owner-response",
+            "app-system",
+        ].includes(String(provenance.sourceKind))) {
+            throw new Error("Transcript entry provenance.sourceKind is invalid");
+        }
+    }
+    switch (data.type) {
+        case "message":
+            if (data.role !== "user" && data.role !== "assistant") {
+                throw new Error("Transcript message role is invalid");
+            }
+            requiredString(data, "text", "Transcript message");
+            break;
+        case "thinking.summary":
+            requiredString(data, "text", "Transcript thinking summary");
+            if (data.kind != null &&
+                data.kind !== "summary" &&
+                data.kind !== "plan") {
+                throw new Error("Transcript thinking summary kind is invalid");
+            }
+            break;
+        case "tool":
+            requiredString(data, "toolId", "Transcript tool");
+            requiredString(data, "name", "Transcript tool");
+            if (data.state !== "completed" &&
+                data.state !== "error" &&
+                data.state !== "cancelled") {
+                throw new Error("Transcript tool state is invalid");
+            }
+            assertOptionalString(data, "input", "Transcript tool");
+            assertOptionalString(data, "output", "Transcript tool");
+            break;
+        case "approval.request":
+            requiredString(data, "requestId", "Transcript approval request");
+            requiredString(data, "title", "Transcript approval request");
+            if (!Array.isArray(data.options)) {
+                throw new Error("Transcript approval request options are invalid");
+            }
+            if ("metadata" in data) {
+                throw new Error("Transcript approval request must not retain metadata");
+            }
+            break;
+        case "approval.response":
+            requiredString(data, "requestId", "Transcript approval response");
+            if (!data.option || typeof data.option !== "object") {
+                throw new Error("Transcript approval response option is invalid");
+            }
+            break;
+        case "question.request":
+            requiredString(data, "requestId", "Transcript question request");
+            requiredString(data, "title", "Transcript question request");
+            if (!Array.isArray(data.questions) || "answers" in data) {
+                throw new Error("Transcript question request is invalid");
+            }
+            break;
+        case "question.response":
+            requiredString(data, "requestId", "Transcript question response");
+            if ((data.status !== "answered" && data.status !== "cancelled") ||
+                "answers" in data) {
+                throw new Error("Transcript question response is invalid");
+            }
+            break;
+        case "agent.switch":
+            requiredString(data, "toBindingId", "Transcript agent switch");
+            assertOptionalString(data, "handoffId", "Transcript agent switch");
+            assertOptionalString(data, "handoffThroughEntryId", "Transcript agent switch");
+            assertProjectionMode(data.handoffMode, "Transcript agent switch handoffMode");
+            assertOptionalCount(data.omittedEntryCount, "Transcript agent switch omittedEntryCount");
+            break;
+        case "agent.config":
+            assertCurrentSchemaVersion(data, "Transcript agent config");
+            assertModelRef(data.model, "Transcript agent config model");
+            assertThinking(data.thinking, "Transcript agent config thinking");
+            if (data.model == null && data.thinking == null) {
+                throw new Error("Transcript agent config must change a field");
+            }
+            break;
+        case "system.notice":
+            requiredString(data, "text", "Transcript system notice");
+            if (data.layout != null &&
+                data.layout !== "report" &&
+                data.layout !== "inventory") {
+                throw new Error("Transcript system notice layout is invalid");
+            }
+            if (data.layout === "inventory") {
+                assertInventory(data.inventory, "Transcript system notice");
+            }
+            break;
+        case "cancelled":
+            assertOptionalString(data, "text", "Transcript cancellation");
+            assertOptionalString(data, "requestId", "Transcript cancellation");
+            if (data.interactionType != null &&
+                data.interactionType !== "approval" &&
+                data.interactionType !== "question") {
+                throw new Error("Transcript cancellation interaction type is invalid");
+            }
+            break;
+        case "error":
+            requiredString(data, "message", "Transcript error");
+            break;
+        case "command":
+            requiredString(data, "command", "Transcript command");
+            if (data.origin !== "app" &&
+                data.origin !== "extension" &&
+                data.origin !== "skill" &&
+                data.origin !== "native-agent") {
+                throw new Error("Transcript command origin is invalid");
+            }
+            if (data.status !== "completed" &&
+                data.status !== "failed" &&
+                data.status !== "cancelled") {
+                throw new Error("Transcript command status is invalid");
+            }
+            break;
+        case "skill-activation":
+            requiredString(data, "skillId", "Transcript skill activation");
+            requiredString(data, "skillName", "Transcript skill activation");
+            requiredString(data, "version", "Transcript skill activation");
+            if (data.origin !== "user" &&
+                data.origin !== "model" &&
+                data.origin !== "app") {
+                throw new Error("Transcript skill activation origin is invalid");
+            }
+            break;
+    }
+    return data;
+}
+function assertProjectionMode(value, label) {
+    if (value != null &&
+        value !== "full" &&
+        value !== "delta" &&
+        value !== "summary-tail") {
+        throw new Error(`${label} is invalid`);
+    }
+}
+function assertOptionalCount(value, label) {
+    if (value != null && (!Number.isSafeInteger(value) || Number(value) < 0)) {
+        throw new Error(`${label} is invalid`);
+    }
+}
+function assertThinking(value, label) {
+    if (value != null &&
+        value !== "off" &&
+        value !== "low" &&
+        value !== "medium" &&
+        value !== "high") {
+        throw new Error(`${label} is invalid`);
+    }
+}

package/dist/conversations/vault-transcript-store.d.ts

@@ -0,0 +1,22 @@
+import { type Vault } from "@lapis-notes/api/vault";
+import { type ConversationListEntry, type TranscriptStore } from "./transcript-store";
+import { type AgentBindingRecord, type ConversationLocation, type ConversationMetadata, type ConversationSnapshot, type TranscriptEntry } from "./types";
+declare const MAX_METADATA_BYTES: number;
+export declare class VaultTranscriptStore implements TranscriptStore {
+    private readonly vault;
+    private readonly queue;
+    constructor(vault: Vault);
+    create(location: ConversationLocation, metadata: ConversationMetadata): Promise<ConversationSnapshot>;
+    read(location: ConversationLocation): Promise<ConversationSnapshot>;
+    list(scopeDir: string): Promise<ConversationListEntry[]>;
+    listAll(): Promise<ConversationListEntry[]>;
+    writeMetadata(location: ConversationLocation, metadata: ConversationMetadata): Promise<void>;
+    appendAgentRecords(location: ConversationLocation, records: AgentBindingRecord[]): Promise<void>;
+    appendTranscriptEntries(location: ConversationLocation, entries: TranscriptEntry[]): Promise<void>;
+    delete(location: ConversationLocation): Promise<void>;
+    private metadataYaml;
+    private readRequired;
+    private replaceText;
+    private appendText;
+}
+export { MAX_METADATA_BYTES };