@lapis-notes/ai 0.1.0

package/dist/jsonl/ai-jsonl-view.js

@@ -0,0 +1,57 @@
+import { TextFileView, mountComponent, } from "@lapis-notes/api";
+import AiJsonlViewSurface from "./ai-jsonl-view.svelte";
+import { AiJsonlViewType } from "./ai-jsonl-view-type";
+export { AiJsonlViewType } from "./ai-jsonl-view-type";
+export class AiJsonlView extends TextFileView {
+    #component = null;
+    getViewType() {
+        return AiJsonlViewType;
+    }
+    getViewData() {
+        return this.data;
+    }
+    setViewData(data, clear = false) {
+        void clear;
+        this.data = data;
+        if (this.#component)
+            this.#component.props.data = data;
+    }
+    clear() {
+        this.setViewData("", true);
+    }
+    load() {
+        if (!this.containerEl)
+            return;
+        this.unload();
+        this.containerEl.replaceChildren();
+        this.containerEl.classList.add("text-view", "ai-jsonl-file-view");
+        this.actions = [];
+        this.#component = mountComponent(AiJsonlViewSurface, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                data: this.data,
+                filePath: this.file?.path ?? "",
+            },
+        });
+    }
+    unload() {
+        this.#component?.destroy();
+        this.#component = null;
+    }
+    canAcceptExtension(extension) {
+        return extension.trim().replace(/^\./u, "").toLowerCase() === "jsonl";
+    }
+    getDisplayText() {
+        return this.file?.name ?? "JSONL preview";
+    }
+    getIcon() {
+        return "messages-square";
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+}

package/dist/jsonl/ai-jsonl-view.svelte

@@ -0,0 +1,260 @@
+<script lang="ts">
+  import type { App } from "@lapis-notes/api";
+  import { MarkdownEmbed } from "@lapis-notes/markdown/embed";
+  import * as Chat from "@lapismd/design-core/ai/chat";
+  import { Reasoning } from "@lapismd/design-core/ai/experimental";
+  import { CodeBlock } from "@lapismd/design-core/shadcn/code-block";
+  import * as Empty from "@lapismd/design-core/shadcn/empty";
+  import FileJsonIcon from "@lucide/svelte/icons/file-json";
+  import type { ToolCallItem } from "@lapismd/design-core/ai/chat";
+  import { mentionTokensFromText } from "../chat/chat-mentions";
+  import { formatChatTimestamp, groupChatItemsByDate } from "../chat/chat-time";
+  import {
+    isOneLineAlert,
+    presentToolPayload,
+    toolCallStatus,
+    toolCallTarget,
+    type AiChatToolItem,
+  } from "../chat/chat-tool-display";
+  import type { AgentBindingRecord } from "../conversations/types";
+  import { createAiJsonlPreview } from "./ai-jsonl-preview";
+
+  let {
+    app,
+    data,
+    filePath,
+  }: { app: App; data: string; filePath: string } = $props();
+
+  const preview = $derived(createAiJsonlPreview(filePath, data));
+  const timeline = $derived(
+    preview.kind === "transcript"
+      ? groupChatItemsByDate(preview.items)
+      : [],
+  );
+  const isEmpty = $derived(
+    (preview.kind === "transcript" && preview.entries.length === 0) ||
+      (preview.kind === "agents" && preview.records.length === 0) ||
+      (preview.kind === "records" && preview.records.length === 0),
+  );
+
+  function toolCallProps(item: AiChatToolItem): ToolCallItem {
+    const hint = { toolName: item.name, input: item.input };
+    const presentedError =
+      item.state === "error" ? presentToolPayload(item.output, hint) : undefined;
+    return {
+      id: item.toolId,
+      name: item.name,
+      status: toolCallStatus(item.state),
+      errorMessage:
+        presentedError && isOneLineAlert(presentedError)
+          ? presentedError.code
+          : undefined,
+      target: toolCallTarget(item.input, item.server),
+      data: { input: item.input, output: item.output },
+      detail: item.input || item.output ? toolDetail : undefined,
+    };
+  }
+
+  function agentRecordLabel(record: AgentBindingRecord): string {
+    switch (record.type) {
+      case "binding.created":
+        return `Agent binding created · ${record.agent ?? record.runtime}`;
+      case "usage.updated":
+        return `Context usage updated · ${record.usage.used.toLocaleString()} of ${record.usage.limit.toLocaleString()}`;
+      case "binding.context.updated":
+        return `Context checkpoint updated · ${record.cause}`;
+      case "binding.config.updated":
+        return "Agent configuration updated";
+      case "handoff.summary.created":
+        return "Handoff summary created";
+    }
+  }
+
+  function recordJson(value: unknown): string {
+    return JSON.stringify(value, null, 2);
+  }
+</script>
+
+{#snippet emptyComposer()}{/snippet}
+
+{#snippet emptyState()}
+  <Empty.Root>
+    <Empty.Header>
+      <Empty.Media variant="icon"><FileJsonIcon aria-hidden="true" /></Empty.Media>
+      <Empty.Title>Empty JSONL file</Empty.Title>
+      <Empty.Description>Records will appear here when they are appended.</Empty.Description>
+    </Empty.Header>
+  </Empty.Root>
+{/snippet}
+
+{#snippet toolDetail(call: ToolCallItem)}
+  {@const payload = call.data as { input?: string; output?: string }}
+  <div class="ai-jsonl-view__tool-detail">
+    {#if payload.input}
+      <CodeBlock
+        code={presentToolPayload(payload.input)?.code ?? payload.input}
+        language={presentToolPayload(payload.input)?.language ?? "plaintext"}
+        title="Input"
+        width="100%"
+        size="sm"
+        isWrapped
+      />
+    {/if}
+    {#if payload.output}
+      <CodeBlock
+        code={presentToolPayload(payload.output)?.code ?? payload.output}
+        language={presentToolPayload(payload.output)?.language ?? "plaintext"}
+        title="Output"
+        width="100%"
+        size="sm"
+        isWrapped
+      />
+    {/if}
+  </div>
+{/snippet}
+
+<div
+  class="ai-jsonl-view"
+  data-ui-component="ai-jsonl-view"
+  data-preview-kind={preview.kind}
+  data-file-path={filePath}
+>
+  <Chat.Layout
+    density="compact"
+    {isEmpty}
+    {emptyState}
+    composer={emptyComposer}
+    aria-label="AI JSONL preview"
+  >
+    <Chat.MessageList
+      density="compact"
+      {isEmpty}
+      {emptyState}
+      aria-label="JSONL records"
+    >
+      {#if preview.kind === "error"}
+        <Chat.Message sender="assistant">
+          <Chat.MessageBubble>{preview.message}</Chat.MessageBubble>
+          {#snippet metadata()}
+            <Chat.MessageMetadata status="error" />
+          {/snippet}
+        </Chat.Message>
+      {:else}
+        {#each preview.warnings as warning}
+          <Chat.SystemMessage>
+            Line {warning.line}: {warning.message}
+          </Chat.SystemMessage>
+        {/each}
+      {/if}
+
+      {#if preview.kind === "transcript"}
+        {#each timeline as entry (entry.kind === "item" ? entry.item.id : entry.id)}
+          {#if entry.kind === "divider"}
+            <Chat.SystemMessage variant="divider">{entry.label}</Chat.SystemMessage>
+          {:else if entry.kind === "tools"}
+            <Chat.ToolCalls
+              calls={entry.items.map(toolCallProps)}
+              defaultExpanded={false}
+            />
+          {:else if entry.item.type === "message"}
+            {@const message = entry.item}
+            <Chat.Message sender={message.role}>
+              <Chat.MessageBubble>
+                {#if message.role === "assistant"}
+                  <MarkdownEmbed
+                    {app}
+                    value={message.text}
+                    htmlPolicy="safe"
+                    class="ai-jsonl-view__markdown"
+                  />
+                {:else}
+                  <Chat.TokenizedText
+                    text={message.text}
+                    tokens={mentionTokensFromText(message.text)}
+                  />
+                {/if}
+              </Chat.MessageBubble>
+              {#snippet metadata()}
+                {#if message.createdAt}
+                  <Chat.MessageMetadata timestamp={formatChatTimestamp(message.createdAt)} />
+                {/if}
+              {/snippet}
+            </Chat.Message>
+          {:else if entry.item.type === "thinking"}
+            <Reasoning
+              preview={entry.item.text}
+              label={entry.item.kind === "plan" ? "Plan" : "Thinking"}
+            >
+              {entry.item.text}
+            </Reasoning>
+          {:else if entry.item.type === "error"}
+            <Chat.Message sender="assistant">
+              <Chat.MessageBubble>{entry.item.text}</Chat.MessageBubble>
+              {#snippet metadata()}
+                <Chat.MessageMetadata
+                  timestamp={entry.item.createdAt
+                    ? formatChatTimestamp(entry.item.createdAt)
+                    : undefined}
+                  status="error"
+                />
+              {/snippet}
+            </Chat.Message>
+          {:else if entry.item.type === "approval"}
+            <Chat.SystemMessage>
+              Approval {entry.item.status}: {entry.item.request.title}
+            </Chat.SystemMessage>
+          {:else if entry.item.type === "question"}
+            <Chat.SystemMessage>
+              Question {entry.item.status}: {entry.item.request.title}
+            </Chat.SystemMessage>
+          {:else}
+            <Chat.SystemMessage>{entry.item.text}</Chat.SystemMessage>
+          {/if}
+        {/each}
+      {:else if preview.kind === "agents"}
+        {#each preview.records as record (record.id)}
+          <section class="ai-jsonl-view__record" data-record-type={record.type}>
+            <Chat.SystemMessage>
+              {agentRecordLabel(record)} · {formatChatTimestamp(record.createdAt)}
+            </Chat.SystemMessage>
+            {#if record.type === "handoff.summary.created"}
+              <Chat.Message sender="assistant">
+                <Chat.MessageBubble>
+                  <MarkdownEmbed
+                    {app}
+                    value={record.summary}
+                    htmlPolicy="safe"
+                    class="ai-jsonl-view__markdown"
+                  />
+                </Chat.MessageBubble>
+              </Chat.Message>
+            {/if}
+            <CodeBlock
+              code={recordJson(record)}
+              language="json"
+              width="100%"
+              size="sm"
+              isCollapsible
+              collapsibleThreshold={8}
+              hasLineNumbers
+            />
+          </section>
+        {/each}
+      {:else if preview.kind === "records"}
+        {#each preview.records as record (record.line)}
+          <section class="ai-jsonl-view__record">
+            <Chat.SystemMessage variant="divider">Line {record.line}</Chat.SystemMessage>
+            <CodeBlock
+              code={recordJson(record.value)}
+              language="json"
+              width="100%"
+              size="sm"
+              isWrapped
+              hasLineNumbers
+            />
+          </section>
+        {/each}
+      {/if}
+    </Chat.MessageList>
+  </Chat.Layout>
+</div>

package/dist/jsonl/ai-jsonl-view.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { App } from "@lapis-notes/api";
+type $$ComponentProps = {
+    app: App;
+    data: string;
+    filePath: string;
+};
+declare const AiJsonlView: import("svelte").Component<$$ComponentProps, {}, "">;
+type AiJsonlView = ReturnType<typeof AiJsonlView>;
+export default AiJsonlView;

package/dist/memory/candidate-extractor.d.ts

@@ -0,0 +1,25 @@
+import type { AppDatabase } from "@lapis-notes/api";
+import type { ConversationSnapshot, TranscriptEntry } from "../conversations/types";
+import type { DurableMemoryKind } from "./types";
+export type CandidateExtractionResult = {
+    examined: number;
+    staged: number;
+    review: number;
+    rejectedSecrets: number;
+};
+export type CandidateExtractionOptions = {
+    entries?: TranscriptEntry[];
+    yieldToApp?: () => Promise<void>;
+};
+export declare function extractDeterministicCandidates(snapshot: ConversationSnapshot, database: AppDatabase, options?: CandidateExtractionOptions): Promise<CandidateExtractionResult>;
+declare function normalizeClaim(text: string): string;
+declare function supersessionKey(text: string, kind: DurableMemoryKind): string | undefined;
+declare function extractTriggers(claim: string): string[];
+export declare function isSecretBearingMemoryText(text: string): boolean;
+export declare const __candidateExtractorInternals: {
+    containsSecret: typeof isSecretBearingMemoryText;
+    extractTriggers: typeof extractTriggers;
+    normalizeClaim: typeof normalizeClaim;
+    supersessionKey: typeof supersessionKey;
+};
+export {};

package/dist/memory/candidate-extractor.js

@@ -0,0 +1,191 @@
+import { deterministicMemoryId, sha256Text, transcriptEntryHash } from "./hashes";
+import { conversationMemoryScope } from "./paths";
+const SECRET_PATTERNS = [
+    /-----BEGIN [A-Z ]*PRIVATE KEY-----/iu,
+    /\b(?:api[_ -]?key|password|passwd|secret|access[_ -]?token)\s*[:=]\s*\S+/iu,
+    /\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]{16,}\b/u,
+];
+const EXPLICIT_CUE = /\b(?:remember(?:\s+that)?|i\s+prefer|we\s+decided|always\s+for\s+this\s+project)\b/iu;
+const STABLE_CUE = /\b(?:prefer|uses?|must|should|decided|convention|workflow|constraint)\b/iu;
+const STOP_WORDS = new Set([
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "for",
+    "i",
+    "in",
+    "is",
+    "it",
+    "of",
+    "on",
+    "or",
+    "that",
+    "the",
+    "this",
+    "to",
+    "use",
+    "uses",
+    "we",
+    "with",
+]);
+export async function extractDeterministicCandidates(snapshot, database, options = {}) {
+    let examined = 0;
+    let staged = 0;
+    let review = 0;
+    let rejectedSecrets = 0;
+    const entries = options.entries ?? snapshot.transcript;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (index > 0 && index % 200 === 0) {
+            await options.yieldToApp?.();
+        }
+        if (entry.type !== "message")
+            continue;
+        const originClass = entry.role === "user" ? "owner" : "agent";
+        if (!STABLE_CUE.test(entry.text) && !EXPLICIT_CUE.test(entry.text))
+            continue;
+        examined += 1;
+        if (isSecretBearingMemoryText(entry.text)) {
+            rejectedSecrets += 1;
+            continue;
+        }
+        const explicit = originClass === "owner" && EXPLICIT_CUE.test(entry.text);
+        const input = await candidateFromEntry(snapshot, entry, originClass, explicit);
+        const existing = (await database.queryMemoryCandidates({
+            scopeKind: input.candidate.scopeKind,
+            scopePath: input.candidate.scopePath,
+            limit: 10_000,
+        })).find((candidate) => candidate.candidate.id === input.candidate.id);
+        const origins = dedupeOrigins([
+            ...(existing?.origins ?? []),
+            ...input.origins,
+        ]);
+        const conversations = new Set(origins.map((origin) => origin.conversationId));
+        const days = new Set(origins.map((origin) => new Date(origin.observedAt).toISOString().slice(0, 10)));
+        const qualifiesRecurring = conversations.size >= 2 && days.size >= 2;
+        const state = originClass === "agent"
+            ? "review"
+            : explicit || qualifiesRecurring
+                ? "staged"
+                : "review";
+        await database.upsertMemoryCandidate({
+            candidate: {
+                ...(existing?.candidate ?? input.candidate),
+                lastSeenAt: Math.max(existing?.candidate.lastSeenAt ?? 0, input.candidate.lastSeenAt),
+                recurrenceCount: origins.length,
+                conversationCount: conversations.size,
+                state: existing?.candidate.state === "promoted"
+                    ? "promoted"
+                    : state,
+            },
+            origins,
+        });
+        if (state === "staged")
+            staged += 1;
+        else
+            review += 1;
+    }
+    return { examined, staged, review, rejectedSecrets };
+}
+async function candidateFromEntry(snapshot, entry, originClass, explicit) {
+    const scope = candidateScope(snapshot.location.scopeDir, entry.text);
+    const normalizedClaim = normalizeClaim(entry.text);
+    const claimHash = await sha256Text(normalizedClaim.toLocaleLowerCase());
+    const scopePath = scope.kind === "project" ? scope.projectDir : "";
+    const kind = candidateKind(entry.text);
+    const id = await deterministicMemoryId("candidate", scope.kind, scopePath, kind, claimHash);
+    const observedAt = Date.parse(entry.createdAt);
+    return {
+        candidate: {
+            id,
+            scopeKind: scope.kind,
+            scopePath,
+            kind,
+            normalizedClaim,
+            claimHash,
+            ...(supersessionKey(entry.text, kind)
+                ? { supersessionKey: supersessionKey(entry.text, kind) }
+                : {}),
+            originClass,
+            importance: explicit ? 4 : 3,
+            triggers: extractTriggers(normalizedClaim),
+            state: originClass === "agent" ? "review" : explicit ? "staged" : "review",
+            firstSeenAt: observedAt,
+            lastSeenAt: observedAt,
+            recurrenceCount: 1,
+            conversationCount: 1,
+        },
+        origins: [
+            {
+                candidateId: id,
+                conversationId: snapshot.location.conversationId,
+                entryId: entry.id,
+                entryHash: await transcriptEntryHash(entry),
+                observedAt,
+            },
+        ],
+    };
+}
+function candidateScope(scopeDir, text) {
+    if (/\b(?:this|the)\s+project\b/iu.test(text) && scopeDir) {
+        return conversationMemoryScope(scopeDir);
+    }
+    if (/\b(?:i\s+prefer|my\s+preference)\b/iu.test(text)) {
+        return { kind: "user" };
+    }
+    return scopeDir
+        ? conversationMemoryScope(scopeDir)
+        : { kind: "workspace" };
+}
+function normalizeClaim(text) {
+    return text
+        .replace(/^\s*(?:please\s+)?remember(?:\s+that)?\s+/iu, "")
+        .replace(/^\s*i\s+prefer\s+/iu, "Prefer ")
+        .replace(/^\s*we\s+decided\s+(?:that\s+|to\s+)?/iu, "")
+        .replace(/^\s*always\s+for\s+this\s+project[,;:]?\s*/iu, "")
+        .replace(/\s+/gu, " ")
+        .trim()
+        .replace(/[.!?]+$/u, "");
+}
+function candidateKind(text) {
+    if (/\bprefer(?:ence)?\b/iu.test(text))
+        return "preference";
+    if (/\bdecided\b/iu.test(text))
+        return "decision";
+    if (/\b(?:must|never|always|constraint)\b/iu.test(text))
+        return "constraint";
+    if (/\b(?:workflow|procedure|steps?|run|execute)\b/iu.test(text)) {
+        return "procedure";
+    }
+    return "fact";
+}
+function supersessionKey(text, kind) {
+    const normalized = normalizeClaim(text).toLocaleLowerCase();
+    const subject = /^(.{2,80}?)\s+(?:is|are|uses?|must|should)\b/u.exec(normalized)?.[1];
+    if (!subject)
+        return undefined;
+    return `${kind}:${subject.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-|-$/gu, "")}`;
+}
+function extractTriggers(claim) {
+    const tokens = claim.toLocaleLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? [];
+    return [...new Set(tokens.filter((token) => token.length > 2 && !STOP_WORDS.has(token)))].slice(0, 8);
+}
+export function isSecretBearingMemoryText(text) {
+    return SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}
+function dedupeOrigins(origins) {
+    return [...new Map(origins.map((origin) => [
+            `${origin.conversationId}\u0000${origin.entryId}`,
+            origin,
+        ])).values()].sort((left, right) => `${left.conversationId}\u0000${left.entryId}`.localeCompare(`${right.conversationId}\u0000${right.entryId}`));
+}
+export const __candidateExtractorInternals = {
+    containsSecret: isSecretBearingMemoryText,
+    extractTriggers,
+    normalizeClaim,
+    supersessionKey,
+};

package/dist/memory/forget-confirmation.d.ts

@@ -0,0 +1,3 @@
+import { type App } from "@lapis-notes/api";
+import type { MemoryForgetPreview } from "./types";
+export declare function confirmForgetDerivedMemory(app: App, preview: MemoryForgetPreview): Promise<boolean>;

package/dist/memory/forget-confirmation.js

@@ -0,0 +1,45 @@
+import { Modal, Setting } from "@lapis-notes/api";
+export function confirmForgetDerivedMemory(app, preview) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (confirmed) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(confirmed);
+            modal.close();
+        };
+        const modal = new (class extends Modal {
+            onOpen() {
+                this.setTitle("Forget derived conversation memory");
+                const document = this.contentEl.ownerDocument;
+                const description = document.createElement("p");
+                description.textContent = [
+                    `Remove ${preview.episodeRefs.length} episodic reference${preview.episodeRefs.length === 1 ? "" : "s"}`,
+                    `${preview.candidateIds.length} candidate${preview.candidateIds.length === 1 ? "" : "s"}`,
+                    `and retract ${preview.memoryIds.length} curated record${preview.memoryIds.length === 1 ? "" : "s"}.`,
+                    "The immutable conversation transcript is not deleted.",
+                ].join(", ");
+                this.contentEl.replaceChildren(description);
+                new Setting(this.contentEl)
+                    .addButton((button) => {
+                    button.setButtonText("Cancel").onClick(() => finish(false));
+                })
+                    .addButton((button) => {
+                    button
+                        .setWarning()
+                        .setButtonText("Forget derived memory")
+                        .onClick(() => finish(true));
+                });
+            }
+            onClose() {
+                if (!settled) {
+                    settled = true;
+                    resolve(false);
+                }
+                this.contentEl.replaceChildren();
+            }
+        })(app);
+        modal.open();
+    });
+}

package/dist/memory/hashes.d.ts

@@ -0,0 +1,5 @@
+import type { TranscriptEntry } from "../conversations/types";
+export declare function sha256Text(value: string): Promise<string>;
+export declare function canonicalJson(value: unknown): string;
+export declare function transcriptEntryHash(entry: TranscriptEntry): Promise<string>;
+export declare function deterministicMemoryId(namespace: string, ...parts: string[]): Promise<string>;

package/dist/memory/hashes.js

@@ -0,0 +1,37 @@
+function canonicalize(value) {
+    if (value === null || typeof value === "boolean" || typeof value === "string") {
+        return JSON.stringify(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new Error("Cannot hash a non-finite number");
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(canonicalize).join(",")}]`;
+    }
+    if (typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record)
+            .filter((key) => record[key] !== undefined)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`)
+            .join(",")}}`;
+    }
+    throw new Error(`Cannot hash ${typeof value}`);
+}
+export async function sha256Text(value) {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+    return [...new Uint8Array(digest)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+export function canonicalJson(value) {
+    return canonicalize(value);
+}
+export function transcriptEntryHash(entry) {
+    return sha256Text(canonicalJson(entry));
+}
+export async function deterministicMemoryId(namespace, ...parts) {
+    return `${namespace}-${(await sha256Text(parts.join("\u0000"))).slice(0, 32)}`;
+}

package/dist/memory/memory-ingestion-coordinator.d.ts

@@ -0,0 +1,19 @@
+import type { ConversationRepository, ConversationRepositoryChange } from "../conversations/conversation-repository";
+import type { ConversationLocation } from "../conversations/types";
+import type { MemoryService } from "./types";
+export type MemoryIngestionErrorHandler = (operation: "ingest" | "rebuild", location: ConversationLocation | undefined, error: unknown) => void;
+export declare class MemoryIngestionCoordinator {
+    #private;
+    private readonly repository;
+    private readonly memory;
+    private readonly onError;
+    private readonly delay;
+    constructor(repository: ConversationRepository, memory: MemoryService, onError?: MemoryIngestionErrorHandler, delay?: number);
+    handleRepositoryChange(change: ConversationRepositoryChange): void;
+    handleVaultChange(path: string, oldPath?: string): void;
+    startCatchUp(): void;
+    flush(): Promise<void>;
+    dispose(): void;
+    private schedule;
+    private hasTerminalTranscriptBoundary;
+}