@chengchenccc/oh-my-agent 0.1.1-rc.1

package/dist/core/memory/autonomous-memory.js

@@ -0,0 +1,202 @@
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { extractText } from "@chengchenccc/message";
+/**
+ * Autonomous memory pipeline (v1, OMP AutoLearn-style but per-Run).
+ *
+ * After a COMPLETED oma run the child:
+ *   1. asks the model to extract durable facts from the run transcript
+ *   2. writes them to `.oma/memory/facts/<runId>.md` (idempotent per run);
+ *   3. merges them into `.oma/memory/memory_summary.md` (a second call);
+ *   4. prepends the summary to the NEXT Run's system prompt (read side).
+ *
+ * `.oma/memory/MEMORY.md` stays agent-written — the pipeline never touches it.
+ * Every failure is swallowed: memory must never fail or slow the Run.
+ * Env: OMA_MEMORY_EXTRACT=0 disables; OMA_MEMORY_MODEL=<provider>/<model>
+ * overrides the extract/merge model (default: the Run's own model).
+ */
+// omp AutoLearn bar: capture sparingly, only after the run actually SOLVED
+// or REVEALED something — one strong reusable lesson beats several vague
+// ones, and a run that merely chatted must learn nothing.
+const EXTRACT_PROMPT = `You are a memory extractor for a coding agent.
+Extract ONLY lessons that would change how a future run works in this
+workspace: a non-obvious fix, a discovered project convention, a decision
+with its why, a pitfall with its fix, or a workflow that worked.
+
+The bar is HIGH. The run must have actually solved or revealed something;
+a greeting, a question answered from general knowledge, or plain chatter
+has NOTHING to learn — return {"facts":[]} without hesitation.
+
+NEVER extract:
+- static configuration: skill/tool listings, model catalogs, agent
+  capabilities, repository or directory structure — re-derivable any time
+- summaries of what the run did (the transcript already knows that)
+- transient details without reuse value, or unverified guesses
+
+Capture sparingly: one strong, specific lesson beats several vague ones.
+When in doubt, don't write.
+
+Return STRICT JSON only:
+{"facts":[{"content":"one durable lesson","context":"where it applies (file/module/scope)"}]}`;
+const CONSOLIDATE_PROMPT = `You maintain the agent's long-term memory summary
+(memory/memory_summary.md). Merge the NEW facts into the EXISTING summary,
+keeping it a compact digest of durable knowledge. Drop facts already
+covered, and drop anything that is static configuration or re-derivable
+from the repo. Return the new summary text only (markdown), no preamble.`;
+const EXTRACT_TIMEOUT_MS = 60_000;
+const TRANSCRIPT_BUDGET_CHARS = 8_000;
+export async function extractAutonomousMemory(input) {
+    try {
+        if (process.env.OMA_MEMORY_EXTRACT === "0")
+            return { ran: false, freshFacts: 0 };
+        // Default: the cheapest available catalog model (memory extraction is
+        // quality-tolerant); OMA_MEMORY_MODEL explicitly overrides; fall back to
+        // the Run's own model when the catalog is empty/unreadable.
+        const modelRef = await resolveMemoryModel(input.modelRuntime, input.modelId);
+        const transcript = buildTranscript(input.messages, input.compactions);
+        if (transcript.trim().length === 0)
+            return { ran: false, freshFacts: 0 };
+        const facts = parseFacts(await callModel(input.modelRuntime, modelRef, `${EXTRACT_PROMPT}\n\n<transcript>\n${transcript}\n</transcript>`));
+        if (facts.length === 0)
+            return { ran: true, freshFacts: 0 };
+        const memDir = join(input.workspaceRoot, ".oma", "memory");
+        const factsDir = join(memDir, "facts");
+        // Cross-run dedup: only genuinely NEW facts are persisted per run (and
+        // fed to consolidation). Repeated learnings from later runs are dropped,
+        // so memory/facts/*.md stays a unique-facts set, not an append log.
+        const existing = readExistingFactContents(factsDir);
+        const fresh = facts.filter((f) => !existing.has(normalizeFact(f.content)));
+        if (fresh.length === 0)
+            return { ran: true, freshFacts: 0 };
+        mkdirSync(factsDir, { recursive: true });
+        writeFileSync(join(factsDir, `${input.runId}.md`), renderFacts(input.runId, fresh), "utf-8");
+        const oldSummary = readTextOrNull(join(memDir, "memory_summary.md"));
+        const newSummary = await callModel(input.modelRuntime, modelRef, `${CONSOLIDATE_PROMPT}\n\n<existing_summary>\n${oldSummary ?? "(none)"}\n</existing_summary>\n\n<new_facts>\n${renderFacts(input.runId, fresh)}\n</new_facts>`);
+        if (newSummary)
+            writeFileSync(join(memDir, "memory_summary.md"), newSummary, "utf-8");
+        return { ran: true, freshFacts: fresh.length };
+    }
+    catch (err) {
+        // Memory is best-effort: never fail or slow the Run over it.
+        console.error("[oma] autonomous memory skipped:", err instanceof Error ? err.message : String(err));
+        return { ran: false, freshFacts: 0 };
+    }
+}
+async function resolveMemoryModel(modelRuntime, runModelId) {
+    const explicit = process.env.OMA_MEMORY_MODEL;
+    if (explicit)
+        return explicit;
+    try {
+        const catalog = await modelRuntime.getCatalog();
+        const candidates = catalog.models.filter((m) => m.available !== false);
+        if (candidates.length > 0) {
+            const costOf = (m) => m.cost.input + m.cost.output;
+            const cheapest = candidates.reduce((a, b) => (costOf(a) <= costOf(b) ? a : b));
+            // On a cost tie prefer the Run's own model: never surprise-upgrade
+            // (or downgrade) the memory model when the catalog gives no reason.
+            const runEntry = candidates.find((m) => `${m.providerId}/${m.modelId}` === runModelId);
+            if (runEntry && costOf(runEntry) <= costOf(cheapest))
+                return runModelId;
+            return `${cheapest.providerId}/${cheapest.modelId}`;
+        }
+    }
+    catch {
+        /* unreadable catalog — fall back to the Run's model */
+    }
+    return runModelId;
+}
+function buildTranscript(messages, compactions) {
+    const lines = [];
+    for (const m of messages) {
+        const label = m.role === "assistant" ? "Assistant" : m.role === "user" ? "User" : m.role;
+        const text = extractText(m).trim();
+        if (text)
+            lines.push(`${label}: ${text}`);
+    }
+    for (const c of compactions) {
+        if (c.trim())
+            lines.push(`[compaction summary]\n${c.trim()}`);
+    }
+    return lines.join("\n\n").slice(0, TRANSCRIPT_BUDGET_CHARS);
+}
+async function callModel(modelRuntime, modelRef, prompt) {
+    const slash = modelRef.indexOf("/");
+    const providerId = slash > 0 ? modelRef.slice(0, slash) : modelRef;
+    const modelId = slash > 0 ? modelRef.slice(slash + 1) : modelRef;
+    let text = "";
+    for await (const chunk of modelRuntime.stream(providerId, modelId, [{ role: "user", text: prompt }], {
+        signal: AbortSignal.timeout(EXTRACT_TIMEOUT_MS),
+    })) {
+        if (chunk.delta?.type === "text" && chunk.delta.text)
+            text += chunk.delta.text;
+    }
+    return text.trim();
+}
+function parseFacts(raw) {
+    const m = raw.match(/\{[\s\S]*\}/);
+    if (!m)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(m[0]);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed.facts))
+        return [];
+    return parsed.facts.filter((f) => typeof f?.content === "string" && f.content.trim().length > 0);
+}
+function renderFacts(runId, facts) {
+    const lines = [`---`, `runId: ${runId}`, `createdAt: ${Date.now()}`, `---`, ""];
+    for (const f of facts) {
+        lines.push(f.context?.trim() ? `- **${f.context.trim()}** ${f.content.trim()}` : `- ${f.content.trim()}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Normalized fact identity: trimmed, case-folded bullet content. */
+function normalizeFact(content) {
+    return content.trim().toLowerCase();
+}
+/** Every fact bullet already persisted across all facts/*.md files
+ *  (pipeline and agent-written alike), best-effort parse of `- ` lines. */
+function readExistingFactContents(factsDir) {
+    const set = new Set();
+    let files;
+    try {
+        files = readdirSync(factsDir).filter((f) => f.endsWith(".md"));
+    }
+    catch {
+        return set;
+    }
+    for (const file of files) {
+        let text;
+        try {
+            text = readFileSync(join(factsDir, file), "utf-8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of text.split("\n")) {
+            const t = line.trim();
+            if (!t.startsWith("- "))
+                continue;
+            const content = t
+                .slice(2)
+                .replace(/^\*\*[^*]+\*\*\s*/, "")
+                .trim();
+            if (content)
+                set.add(normalizeFact(content));
+        }
+    }
+    return set;
+}
+function readTextOrNull(path) {
+    try {
+        const text = readFileSync(path, "utf-8");
+        return text.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/core/persistence/in-memory-session-store.d.ts

@@ -0,0 +1,3 @@
+import type { SessionStore } from "./session-store.js";
+export declare function createInMemorySessionStore(): SessionStore;
+//# sourceMappingURL=in-memory-session-store.d.ts.map

package/dist/core/persistence/in-memory-session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-session-store.d.ts","sourceRoot":"","sources":["../../../src/core/persistence/in-memory-session-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAuC,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAS5F,wBAAgB,0BAA0B,IAAI,YAAY,CAgIzD"}

package/dist/core/persistence/in-memory-session-store.js

@@ -0,0 +1,109 @@
+import { validateBatch } from "./session-store.js";
+export function createInMemorySessionStore() {
+    const sessions = new Map();
+    return {
+        async create(metadata) {
+            if (sessions.has(metadata.sessionId)) {
+                throw new Error(`Session ${metadata.sessionId} already exists`);
+            }
+            sessions.set(metadata.sessionId, {
+                metadata: { ...metadata },
+                entries: [],
+                operations: [],
+                productEntrySet: new Set(),
+            });
+        },
+        async open(sessionId) {
+            const s = sessions.get(sessionId);
+            if (!s)
+                throw new Error(`Session ${sessionId} not found`);
+            return {
+                metadata: { ...s.metadata },
+                entries: [...s.entries],
+                operations: [...s.operations],
+            };
+        },
+        async delete(sessionId) {
+            if (!sessions.delete(sessionId)) {
+                throw new Error(`Session ${sessionId} not found`);
+            }
+        },
+        async close() {
+            // In-memory store holds no external resources.
+        },
+        async appendBatch(sessionId, input) {
+            const s = sessions.get(sessionId);
+            if (!s)
+                throw new Error(`Session ${sessionId} not found`);
+            // Validate before any mutation so a failed batch writes nothing.
+            validateBatch(input.entries);
+            const appendedIds = [];
+            let parentId = s.metadata.leafEntryId;
+            for (const entry of input.entries) {
+                const productEntryId = "productEntryId" in entry
+                    ? entry.productEntryId
+                    : undefined;
+                if (productEntryId && s.productEntrySet.has(productEntryId))
+                    continue;
+                const entryId = crypto.randomUUID().replace(/-/g, "").slice(0, 26);
+                const now = Date.now();
+                const full = {
+                    ...entry,
+                    entryId,
+                    parentId,
+                    createdAt: now,
+                };
+                s.entries.push(full);
+                if (productEntryId)
+                    s.productEntrySet.add(productEntryId);
+                appendedIds.push(entryId);
+                parentId = entryId;
+            }
+            if (appendedIds.length > 0) {
+                const oldLeaf = s.metadata.leafEntryId;
+                s.metadata.leafEntryId = parentId;
+                s.metadata.updatedAt = Date.now();
+                // Mirror SQLite: entries + leaf_moved operation + cache are one logical
+                // transaction. The operation log lets reopen() reconstruct the leaf.
+                s.operations.push({ type: "leaf_moved", entryId: parentId, fromLeafId: oldLeaf });
+            }
+            return { appendedIds };
+        },
+        async moveLeaf(sessionId, entryId) {
+            const s = sessions.get(sessionId);
+            if (!s)
+                throw new Error(`Session ${sessionId} not found`);
+            if (!s.entries.some((e) => e.entryId === entryId)) {
+                throw new Error(`Entry ${entryId} not found`);
+            }
+            s.operations.push({ type: "leaf_moved", entryId, fromLeafId: s.metadata.leafEntryId });
+            s.metadata.leafEntryId = entryId;
+            s.metadata.updatedAt = Date.now();
+        },
+        async readBranch(sessionId) {
+            const s = sessions.get(sessionId);
+            if (!s)
+                throw new Error(`Session ${sessionId} not found`);
+            // Walk from leaf to root via parent links, then reverse
+            const result = [];
+            let currentId = s.metadata.leafEntryId;
+            const entryMap = new Map(s.entries.map((e) => [e.entryId, e]));
+            while (currentId) {
+                const entry = entryMap.get(currentId);
+                if (!entry)
+                    break;
+                result.push(entry);
+                currentId = entry.parentId;
+            }
+            return result.reverse();
+        },
+        async findByProductEntryIds(sessionId, ids) {
+            const s = sessions.get(sessionId);
+            if (!s)
+                throw new Error(`Session ${sessionId} not found`);
+            return s.entries.filter((e) => e.type === "message" &&
+                e.productEntryId &&
+                ids.includes(e.productEntryId));
+        },
+    };
+}

package/dist/core/persistence/session-store.contract.d.ts

@@ -0,0 +1,5 @@
+import type { SessionStore } from "./session-store.js";
+/** Reusable contract suite for SessionStore implementations.
+ *  Each adapter test imports and invokes this. */
+export declare function runSessionStoreContract(name: string, factory: () => Promise<SessionStore>, cleanup?: () => Promise<void>): void;
+//# sourceMappingURL=session-store.contract.d.ts.map

package/dist/core/persistence/session-store.contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.contract.d.ts","sourceRoot":"","sources":["../../../src/core/persistence/session-store.contract.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGvD;kDACkD;AAClD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,OAAO,CAAC,YAAY,CAAC,EACpC,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC5B,IAAI,CA6MN"}

package/dist/core/persistence/session-store.contract.js

@@ -0,0 +1,183 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+/** Reusable contract suite for SessionStore implementations.
+ *  Each adapter test imports and invokes this. */
+export function runSessionStoreContract(name, factory, cleanup) {
+    let store;
+    const sessionId = `sess-${Math.random().toString(36).slice(2, 10)}`;
+    const meta = {
+        sessionId,
+        backendKind: "oma",
+        workspaceRoot: "/ws",
+        leafEntryId: null,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    beforeAll(async () => {
+        store = await factory();
+        await store.create(meta);
+    });
+    afterAll(async () => {
+        await cleanup?.();
+    });
+    function messageEntry(text, productEntryId) {
+        return {
+            type: "message",
+            productEntryId,
+            role: "user",
+            source: "prompt",
+            message: { role: "user", text },
+            createdAt: Date.now(),
+        };
+    }
+    describe(`${name} SessionStore`, () => {
+        test("create and open returns correct metadata", async () => {
+            const snap = await store.open(sessionId);
+            expect(snap.metadata.sessionId).toBe(sessionId);
+            expect(snap.metadata.leafEntryId).toBeNull();
+            expect(snap.entries).toHaveLength(0);
+        });
+        test("appendBatch appends entries atomically and records a leaf_moved operation", async () => {
+            const result = await store.appendBatch(sessionId, {
+                entries: [messageEntry("hello", "pe1")],
+            });
+            expect(result.appendedIds).toHaveLength(1);
+            const snap = await store.open(sessionId);
+            expect(snap.metadata.leafEntryId).toBe(result.appendedIds[0]);
+            expect(snap.entries).toHaveLength(1);
+            // entries + leaf operation + cache are one logical transaction: a
+            // successful append must record a leaf_moved operation too.
+            const lastOp = snap.operations.at(-1);
+            expect(lastOp?.type).toBe("leaf_moved");
+            expect(lastOp?.entryId).toBe(result.appendedIds[0]);
+        });
+        test("appendBatch skips duplicate productEntryIds", async () => {
+            await store.appendBatch(sessionId, {
+                entries: [messageEntry("hello", "pe1")],
+            });
+            const snap = await store.open(sessionId);
+            expect(snap.entries).toHaveLength(1); // still 1, duplicate skipped
+        });
+        test("readBranch returns root-to-leaf order", async () => {
+            await store.appendBatch(sessionId, {
+                entries: [messageEntry("reply", "pe2")],
+            });
+            const branch = await store.readBranch(sessionId);
+            expect(branch.length).toBeGreaterThanOrEqual(2);
+        });
+        test("moveLeaf navigates to existing entry", async () => {
+            const entries = await store.readBranch(sessionId);
+            const firstEntryId = entries[0]?.entryId;
+            if (firstEntryId) {
+                await store.moveLeaf(sessionId, firstEntryId);
+                const snapAfter = await store.open(sessionId);
+                expect(snapAfter.metadata.leafEntryId).toBe(firstEntryId);
+                // leaf movement is a durable operation
+                expect(snapAfter.operations.at(-1)?.type).toBe("leaf_moved");
+                expect(snapAfter.operations.at(-1)?.entryId).toBe(firstEntryId);
+            }
+        });
+        test("findByProductEntryIds returns matching entries", async () => {
+            const found = await store.findByProductEntryIds(sessionId, ["pe1", "nonexistent"]);
+            expect(found).toHaveLength(1);
+            expect(found[0]?.type).toBe("message");
+        });
+        test("failed batch rolls back and writes nothing", async () => {
+            const before = await store.open(sessionId);
+            const beforeCount = before.entries.length;
+            await expect(store.appendBatch(sessionId, {
+                entries: [messageEntry("valid"), { type: "bogus", createdAt: Date.now() }],
+            })).rejects.toThrow();
+            const after = await store.open(sessionId);
+            expect(after.entries).toHaveLength(beforeCount);
+            expect(after.metadata.leafEntryId).toBe(before.metadata.leafEntryId);
+        });
+        test("concurrent appends do not create accidental siblings", async () => {
+            // Capture the current leaf before appending.
+            const before = await store.open(sessionId);
+            const [a, b] = await Promise.all([
+                store.appendBatch(sessionId, { entries: [messageEntry("a")] }),
+                store.appendBatch(sessionId, { entries: [messageEntry("b")] }),
+            ]);
+            expect(a.appendedIds).toHaveLength(1);
+            expect(b.appendedIds).toHaveLength(1);
+            // Both entries must be on one linear chain: leaf walks back through both.
+            const branch = await store.readBranch(sessionId);
+            const branchIds = branch.map((e) => e.entryId);
+            expect(branchIds).toContain(a.appendedIds[0]);
+            expect(branchIds).toContain(b.appendedIds[0]);
+            // No orphaned sibling: every entry is reachable from the leaf.
+            expect(branchIds).toHaveLength(new Set(branchIds).size);
+            // The two new entries are consecutive children (no shared parent).
+            const idxA = branchIds.indexOf(a.appendedIds[0]);
+            const idxB = branchIds.indexOf(b.appendedIds[0]);
+            expect(Math.abs(idxA - idxB)).toBe(1);
+            // New leaf is one of the two appended entries.
+            expect([a.appendedIds[0], b.appendedIds[0]]).toContain(branch.at(-1)?.entryId);
+            // The pre-existing leaf is the parent of the first new entry (both
+            // appends derived from the same leaf; no accidental sibling).
+            const firstNewIdx = Math.min(idxA, idxB);
+            const parentOfFirstNew = branch.at(firstNewIdx - 1)?.entryId;
+            expect(parentOfFirstNew ?? null).toBe(before.metadata.leafEntryId);
+        });
+        test("todo state persists and latest entry wins on read", async () => {
+            await store.appendBatch(sessionId, {
+                entries: [
+                    {
+                        type: "todo",
+                        state: { items: [{ id: "t1", text: "first", status: "pending" }] },
+                        createdAt: Date.now(),
+                    },
+                ],
+            });
+            await store.appendBatch(sessionId, {
+                entries: [
+                    {
+                        type: "todo",
+                        state: { items: [{ id: "t1", text: "first", status: "done" }] },
+                        createdAt: Date.now(),
+                    },
+                ],
+            });
+            const branch = await store.readBranch(sessionId);
+            const todoEntries = branch.filter((e) => e.type === "todo");
+            expect(todoEntries).toHaveLength(2);
+            // readTodo scans from the leaf; the latest state is the last todo entry
+            const latest = todoEntries.at(-1);
+            expect(latest.state.items[0]?.status).toBe("done");
+        });
+        test("compaction entry does not delete original entries", async () => {
+            await store.appendBatch(sessionId, {
+                entries: [
+                    messageEntry("old-1", "pe3"),
+                    messageEntry("old-2", "pe4"),
+                    messageEntry("old-3", "pe5"),
+                    messageEntry("old-4", "pe6"),
+                ],
+            });
+            const branchBefore = await store.readBranch(sessionId);
+            const msgIds = branchBefore.filter((e) => e.type === "message").map((e) => e.entryId);
+            await store.appendBatch(sessionId, {
+                entries: [
+                    {
+                        type: "compaction",
+                        summary: "compacted",
+                        coversEntryIds: msgIds.slice(0, 2),
+                        createdAt: Date.now(),
+                    },
+                ],
+            });
+            const branchAfter = await store.open(sessionId);
+            // Originals retained
+            for (const id of msgIds) {
+                expect(branchAfter.entries.some((e) => e.entryId === id)).toBe(true);
+            }
+            const comp = branchAfter.entries.filter((e) => e.type === "compaction");
+            expect(comp).toHaveLength(1);
+            expect(comp[0].coversEntryIds).toEqual(msgIds.slice(0, 2));
+        });
+        test("delete removes session", async () => {
+            await store.delete(sessionId);
+            expect(store.open(sessionId)).rejects.toThrow();
+        });
+    });
+}

package/dist/core/persistence/session-store.d.ts

@@ -0,0 +1,33 @@
+import type { CodingSessionEntry, CodingSessionMetadata, CodingSessionSnapshot } from "./session-tree.js";
+export interface AppendBatchInput {
+    readonly entries: readonly Record<string, unknown>[];
+}
+export interface AppendBatchResult {
+    readonly appendedIds: readonly string[];
+}
+/** Validate a batch before any write. Throws on the first invalid entry so
+ *  both adapters fail atomically with identical semantics. */
+export declare function validateBatch(entries: readonly Record<string, unknown>[]): void;
+export interface SessionStore {
+    /** Create a new session. */
+    create(metadata: CodingSessionMetadata): Promise<void>;
+    /** Open an existing session, returning current snapshot. */
+    open(sessionId: string): Promise<CodingSessionSnapshot>;
+    /** Delete a session and all its data. */
+    delete(sessionId: string): Promise<void>;
+    /** Atomically append a batch of entries. ParentIds are derived from the
+     *  current leaf. Duplicate productEntryIds in the batch are skipped.
+     *  The leaf is updated only after the full batch succeeds. */
+    appendBatch(sessionId: string, input: AppendBatchInput): Promise<AppendBatchResult>;
+    /** Move the session leaf to an existing entry. Appends a leaf_moved operation. */
+    moveLeaf(sessionId: string, entryId: string): Promise<void>;
+    /** Read all entries on the current branch from root to leaf. */
+    readBranch(sessionId: string): Promise<readonly CodingSessionEntry[]>;
+    /** Find entries by their product entry IDs. */
+    findByProductEntryIds(sessionId: string, ids: readonly string[]): Promise<readonly CodingSessionEntry[]>;
+    /** Release backend resources (SQLite connection). Idempotent; the store is
+     *  unusable afterwards. One-shot Workers call this before exiting so the
+     *  session file is not held open after the outcome. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=session-store.d.ts.map

package/dist/core/persistence/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../../src/core/persistence/session-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACtD;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;8DAC8D;AAC9D,wBAAgB,aAAa,CAAC,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,IAAI,CAmB/E;AAED,MAAM,WAAW,YAAY;IAC3B,4BAA4B;IAC5B,MAAM,CAAC,QAAQ,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD,4DAA4D;IAC5D,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAExD,yCAAyC;IACzC,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzC;;kEAE8D;IAC9D,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAEpF,kFAAkF;IAClF,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5D,gEAAgE;IAChE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAAC;IAEtE,+CAA+C;IAC/C,qBAAqB,CACnB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,SAAS,MAAM,EAAE,GACrB,OAAO,CAAC,SAAS,kBAAkB,EAAE,CAAC,CAAC;IAE1C;;2DAEuD;IACvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dist/core/persistence/session-store.js

@@ -0,0 +1,22 @@
+/** Validate a batch before any write. Throws on the first invalid entry so
+ *  both adapters fail atomically with identical semantics. */
+export function validateBatch(entries) {
+    for (const entry of entries) {
+        const type = entry.type;
+        if (type !== "message" && type !== "compaction" && type !== "todo") {
+            throw new Error(`Invalid entry type: ${String(type)}`);
+        }
+        if (type === "message") {
+            const msg = entry.message;
+            if (!msg || typeof msg !== "object" || typeof msg.role !== "string") {
+                throw new Error("Message entry requires a message object with a role");
+            }
+        }
+        if (type === "compaction" && typeof entry.summary !== "string") {
+            throw new Error("Compaction entry requires a summary string");
+        }
+        if (type === "todo" && typeof entry.state !== "object") {
+            throw new Error("Todo entry requires a state object");
+        }
+    }
+}

package/dist/core/persistence/session-tree.d.ts

@@ -0,0 +1,49 @@
+import type { Message } from "@chengchenccc/message";
+export interface MessageEntry {
+    readonly type: "message";
+    readonly entryId: string;
+    readonly parentId: string | null;
+    readonly role: "user" | "assistant" | "system" | "tool";
+    readonly source: "product_history" | "meta" | "prompt" | "steer" | "follow_up" | "assistant" | "tool_result";
+    readonly message: Message;
+    readonly createdAt: number;
+}
+export interface CompactionEntry {
+    readonly type: "compaction";
+    readonly entryId: string;
+    readonly parentId: string | null;
+    readonly summary: string;
+    readonly coversEntryIds: readonly string[];
+    /** Estimated token count of covered messages before compaction. */
+    readonly tokensBefore?: number;
+    /** Entry IDs deliberately left uncovered (the retained tail). */
+    readonly retainedEntryIds?: readonly string[];
+    readonly createdAt: number;
+}
+export interface TodoStateEntry {
+    readonly type: "todo";
+    readonly entryId: string;
+    readonly parentId: string | null;
+    readonly state: Readonly<Record<string, unknown>>;
+    readonly createdAt: number;
+}
+export type CodingSessionEntry = MessageEntry | CompactionEntry | TodoStateEntry;
+export type CodingSessionOperation = {
+    readonly type: "leaf_moved";
+    readonly entryId: string;
+    readonly fromLeafId: string | null;
+};
+export interface CodingSessionMetadata {
+    readonly sessionId: string;
+    readonly backendKind: string;
+    readonly workspaceRoot: string;
+    readonly leafEntryId: string | null;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+}
+export interface CodingSessionSnapshot {
+    readonly metadata: CodingSessionMetadata;
+    readonly entries: readonly CodingSessionEntry[];
+    readonly operations: readonly CodingSessionOperation[];
+}
+//# sourceMappingURL=session-tree.d.ts.map

package/dist/core/persistence/session-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tree.d.ts","sourceRoot":"","sources":["../../../src/core/persistence/session-tree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAIrD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,CAAC;IACxD,QAAQ,CAAC,MAAM,EACX,iBAAiB,GACjB,MAAM,GACN,QAAQ,GACR,OAAO,GACP,WAAW,GACX,WAAW,GACX,aAAa,CAAC;IAClB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3C,mEAAmE;IACnE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAClD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AACD,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,eAAe,GAAG,cAAc,CAAC;AAEjF,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC,CAAC;AAIF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAChD,QAAQ,CAAC,UAAU,EAAE,SAAS,sBAAsB,EAAE,CAAC;CACxD"}

package/dist/core/persistence/session-tree.js

@@ -0,0 +1 @@
+export {};

package/dist/core/plugins/plugin-code.d.ts

@@ -0,0 +1,13 @@
+import type { PluginHooks, PluginTool } from "../runtime/plugin.js";
+export interface PluginCodeResult {
+    readonly ok: boolean;
+    readonly tools?: readonly PluginTool[];
+    readonly hooks?: PluginHooks;
+    readonly warnings: readonly string[];
+    readonly error?: string;
+}
+/** Load ONE code entry (tools or hooks) from an installed plugin root.
+ *  Never throws: any failure degrades to {ok:false, error} (spec failure
+ *  semantics — a broken plugin must never fail the Run). */
+export declare function loadPluginCode(root: string, entry: string): Promise<PluginCodeResult>;
+//# sourceMappingURL=plugin-code.d.ts.map

package/dist/core/plugins/plugin-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-code.d.ts","sourceRoot":"","sources":["../../../src/core/plugins/plugin-code.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAcpE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAYD;;4DAE4D;AAC5D,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAqC3F"}