@dsh-libing/memory-manager 0.0.0-stage → 0.1.1

package/lib/scope.js

@@ -0,0 +1,100 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { realpath } from 'node:fs/promises';
+import { resolve, basename } from 'node:path';
+import { createHash } from 'node:crypto';
+import { MemoryError, abort } from "./shared.js";
+export const canonical = async (path) => await realpath(resolve(path));
+export const workspaceKey = (path) => createHash('sha256').update(path).digest('hex');
+export async function agentScope(agent, ctx) {
+    if (!agent.session.header.cwd)
+        throw new MemoryError('unknownScope', 403);
+    const binding = ctx?.get('libingMemoryScopes')?.resolveSession(agent.id);
+    if (!binding && /^solo:(?:chat|standing-run):/u.test(agent.session.header.agentPreset ?? ''))
+        throw new MemoryError('memoryDisabled', 403);
+    if (binding && !binding.enabled)
+        throw new MemoryError('memoryDisabled', 403);
+    return { workspace: binding?.namespace || workspaceKey(await canonical(agent.session.header.cwd)), session: agent.session.id, ...binding ? { includePersonal: false } : {} };
+}
+export async function selection(ctx, input, signal) {
+    const records = await ctx.sessionQuery.listSessions(signal);
+    const workspaces = [];
+    const paths = new Map();
+    const sessions = [];
+    for (const workspace of ctx.workspaceRegistry.list()) {
+        try {
+            const path = await canonical(workspace.path);
+            const id = workspaceKey(path);
+            paths.set(id, path);
+            if (!workspaces.some(row => row.id === id))
+                workspaces.push({ id, title: workspace.title });
+        }
+        catch { /* deleted workspace is not an authority */ }
+    }
+    const titles = await ctx.sessionQuery.readTitleSnapshots(records.map(row => row.header.id), signal);
+    for (const record of records) {
+        if (!record.header.cwd)
+            continue;
+        try {
+            const path = await canonical(record.header.cwd);
+            const binding = ctx.get('libingMemoryScopes')?.resolveSession(record.header.id);
+            const id = binding?.namespace || workspaceKey(path);
+            paths.set(id, path);
+            if (!workspaces.some(row => row.id === id))
+                workspaces.push({ id, title: binding?.namespace ? binding.label : basename(path) });
+            const result = titles.find(row => row.sessionId === record.header.id);
+            sessions.push({ id: record.header.id, title: result?.status === 'fulfilled' ? result.value.title?.title ?? record.header.id : record.header.id, workspace: id });
+        }
+        catch { /* unknown roots cannot fall back to another workspace */ }
+    }
+    const chosen = input.sessionId ? sessions.find(row => row.id === input.sessionId) : undefined;
+    if (input.sessionId && !chosen)
+        throw new MemoryError('notFound', 404);
+    const workspace = input.workspaceId ?? chosen?.workspace ?? workspaces[0]?.id;
+    if (!workspace || !paths.has(workspace))
+        throw new MemoryError('unknownScope', 403);
+    if (chosen && chosen.workspace !== workspace)
+        throw new MemoryError('outsideScope', 403);
+    abort(signal);
+    const matched = sessions.filter(row => row.workspace === workspace);
+    const session = chosen?.id ?? matched[0]?.id ?? null;
+    const managed = session ? ctx.get('libingMemoryScopes')?.resolveSession(session) : undefined;
+    return { scope: { workspace, session, ...managed ? { includePersonal: false } : {} }, selectedSession: session, workspaces, sessions: matched.map(({ workspace: _workspace, ...row }) => row) };
+}
+export async function observedTurn(ctx, session, requested, signal) {
+    const view = await ctx.sessionQuery.observeSession(SessionId(session), signal ? { signal } : {});
+    try {
+        const ends = view.events.flatMap(event => event.type === 'turn/end' && event.data.reason.kind === 'completed' ? [event.data.turn] : []);
+        const last = requested ?? ends.at(-1);
+        if (!last || !ends.includes(last))
+            throw new MemoryError('completedTurnRequired');
+        let inside = false;
+        const seqs = [];
+        const lines = [];
+        for (const event of view.events) {
+            if (event.type === 'turn/start')
+                inside = event.data.turn === last;
+            if (!inside)
+                continue;
+            if (event.type === 'user/message' && event.data.source.kind === 'user') {
+                lines.push(`User: ${event.data.content.filter(block => block.type === 'text').map(block => block.text).join('\n')}`);
+                seqs.push(event.seq);
+            }
+            if (event.type === 'assistant/message') {
+                lines.push(`Assistant: ${event.data.message.content.filter(block => block.type === 'text').map(block => block.text).join('\n')}`);
+                seqs.push(event.seq);
+            }
+            if (event.type === 'turn/end')
+                inside = false;
+        }
+        if (!lines.some(line => line.startsWith('User:')))
+            throw new MemoryError('noUserInput');
+        const text = lines.join('\n').slice(0, 12000);
+        // Skip, rather than redact and silently change, credential-bearing extraction input.
+        if (/-----BEGIN .*PRIVATE KEY|(?:api[_-]?key|password|token|密钥|密码)\s*[:=]\s*\S+/iu.test(text))
+            throw new MemoryError('sensitiveInput');
+        return { turn: last, input: text, source: { kind: 'capture', session, turn: last, evidence: text.slice(0, 1200), seqs: seqs.slice(0, 100) } };
+    }
+    finally {
+        view[Symbol.dispose]();
+    }
+}

package/lib/shared.d.ts

@@ -0,0 +1,508 @@
+/** Validated wire/domain identities; candidates never belong to the readable collection. */
+import { z } from 'zod';
+export declare const API = "/api/libing-memory-manager";
+export declare const kinds: readonly ["agreement", "decision", "lesson", "handoff"];
+export declare const kindSchema: z.ZodEnum<{
+    agreement: "agreement";
+    decision: "decision";
+    lesson: "lesson";
+    handoff: "handoff";
+}>;
+export declare const scopeSchema: z.ZodObject<{
+    workspace: z.ZodString;
+    session: z.ZodNullable<z.ZodString>;
+    includePersonal: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Scope = z.infer<typeof scopeSchema>;
+export declare const draftSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    kind: z.ZodEnum<{
+        agreement: "agreement";
+        decision: "decision";
+        lesson: "lesson";
+        handoff: "handoff";
+    }>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    pinned: z.ZodDefault<z.ZodBoolean>;
+    recall: z.ZodDefault<z.ZodBoolean>;
+    range: z.ZodDefault<z.ZodEnum<{
+        workspace: "workspace";
+        session: "session";
+        personal: "personal";
+    }>>;
+}, z.core.$strict>;
+export type Draft = z.infer<typeof draftSchema>;
+export declare const sourceSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        manual: "manual";
+        model: "model";
+        capture: "capture";
+    }>;
+    session: z.ZodNullable<z.ZodString>;
+    turn: z.ZodNullable<z.ZodNumber>;
+    evidence: z.ZodString;
+    seqs: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>;
+export type Source = z.infer<typeof sourceSchema>;
+export declare const entrySchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    kind: z.ZodEnum<{
+        agreement: "agreement";
+        decision: "decision";
+        lesson: "lesson";
+        handoff: "handoff";
+    }>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    pinned: z.ZodDefault<z.ZodBoolean>;
+    recall: z.ZodDefault<z.ZodBoolean>;
+    range: z.ZodDefault<z.ZodEnum<{
+        workspace: "workspace";
+        session: "session";
+        personal: "personal";
+    }>>;
+    id: z.ZodString;
+    version: z.ZodNumber;
+    workspace: z.ZodString;
+    session: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        trash: "trash";
+    }>;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            manual: "manual";
+            model: "model";
+            capture: "capture";
+        }>;
+        session: z.ZodNullable<z.ZodString>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        evidence: z.ZodString;
+        seqs: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    updated: z.ZodString;
+}, z.core.$strict>;
+export type Entry = z.infer<typeof entrySchema>;
+export declare const candidateSchema: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+    expected: z.ZodNumber;
+    workspace: z.ZodString;
+    session: z.ZodNullable<z.ZodString>;
+    draft: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            agreement: "agreement";
+            decision: "decision";
+            lesson: "lesson";
+            handoff: "handoff";
+        }>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        recall: z.ZodDefault<z.ZodBoolean>;
+        range: z.ZodDefault<z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+            personal: "personal";
+        }>>;
+    }, z.core.$strict>;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            manual: "manual";
+            model: "model";
+            capture: "capture";
+        }>;
+        session: z.ZodNullable<z.ZodString>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        evidence: z.ZodString;
+        seqs: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strict>;
+    state: z.ZodEnum<{
+        pending: "pending";
+        rejected: "rejected";
+        accepted: "accepted";
+    }>;
+    updated: z.ZodString;
+}, z.core.$strip>;
+export type Candidate = z.infer<typeof candidateSchema>;
+export declare const activityItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    title: z.ZodString;
+    summary: z.ZodString;
+    status: z.ZodEnum<{
+        prepared: "prepared";
+        included: "included";
+        search: "search";
+        read: "read";
+        deleted: "deleted";
+    }>;
+}, z.core.$strip>;
+export type ActivityItem = z.infer<typeof activityItemSchema>;
+export declare const activitySchema: z.ZodObject<{
+    id: z.ZodString;
+    workspace: z.ZodString;
+    session: z.ZodNullable<z.ZodString>;
+    turn: z.ZodNullable<z.ZodNumber>;
+    kind: z.ZodString;
+    reason: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodNumber;
+        title: z.ZodString;
+        summary: z.ZodString;
+        status: z.ZodEnum<{
+            prepared: "prepared";
+            included: "included";
+            search: "search";
+            read: "read";
+            deleted: "deleted";
+        }>;
+    }, z.core.$strip>>;
+    updated: z.ZodString;
+}, z.core.$strip>;
+export type Activity = z.infer<typeof activitySchema>;
+export declare const jobSchema: z.ZodObject<{
+    id: z.ZodString;
+    workspace: z.ZodString;
+    session: z.ZodString;
+    turn: z.ZodNumber;
+    state: z.ZodEnum<{
+        queued: "queued";
+        running: "running";
+        done: "done";
+        failed: "failed";
+        cancelled: "cancelled";
+        interrupted: "interrupted";
+        skipped: "skipped";
+    }>;
+    reason: z.ZodString;
+    candidateIds: z.ZodArray<z.ZodString>;
+    updated: z.ZodString;
+    automatic: z.ZodBoolean;
+}, z.core.$strip>;
+export type Job = z.infer<typeof jobSchema>;
+export declare const settingsSchema: z.ZodObject<{
+    revision: z.ZodDefault<z.ZodNumber>;
+    autoRecall: z.ZodDefault<z.ZodBoolean>;
+    autoCapture: z.ZodDefault<z.ZodBoolean>;
+    provider: z.ZodDefault<z.ZodString>;
+    model: z.ZodDefault<z.ZodString>;
+    maxDailyCalls: z.ZodDefault<z.ZodNumber>;
+    maxRecallChars: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type Settings = z.infer<typeof settingsSchema>;
+export declare const selectionSchema: z.ZodObject<{
+    workspaceId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type Selection = z.infer<typeof selectionSchema>;
+export declare const mutationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"create">;
+    draft: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            agreement: "agreement";
+            decision: "decision";
+            lesson: "lesson";
+            handoff: "handoff";
+        }>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        recall: z.ZodDefault<z.ZodBoolean>;
+        range: z.ZodDefault<z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+            personal: "personal";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"propose">;
+    draft: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            agreement: "agreement";
+            decision: "decision";
+            lesson: "lesson";
+            handoff: "handoff";
+        }>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        recall: z.ZodDefault<z.ZodBoolean>;
+        range: z.ZodDefault<z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+            personal: "personal";
+        }>>;
+    }, z.core.$strict>;
+    target: z.ZodOptional<z.ZodString>;
+    expected: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"approve">;
+    id: z.ZodString;
+    revision: z.ZodString;
+    draft: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            agreement: "agreement";
+            decision: "decision";
+            lesson: "lesson";
+            handoff: "handoff";
+        }>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        recall: z.ZodDefault<z.ZodBoolean>;
+        range: z.ZodDefault<z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+            personal: "personal";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"reject">;
+    id: z.ZodString;
+    revision: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodEnum<{
+        trash: "trash";
+        restore: "restore";
+        toggle: "toggle";
+    }>;
+    id: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"purge">;
+    id: z.ZodString;
+    version: z.ZodNumber;
+    confirmTitle: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"settings">;
+    settings: z.ZodObject<{
+        revision: z.ZodDefault<z.ZodNumber>;
+        autoRecall: z.ZodDefault<z.ZodBoolean>;
+        autoCapture: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodString>;
+        model: z.ZodDefault<z.ZodString>;
+        maxDailyCalls: z.ZodDefault<z.ZodNumber>;
+        maxRecallChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"capture">;
+    turn: z.ZodOptional<z.ZodNumber>;
+    expectedModel: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    action: z.ZodLiteral<"cancel">;
+    id: z.ZodString;
+}, z.core.$strict>], "action">;
+export type Mutation = z.infer<typeof mutationSchema>;
+export declare const captureModelSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodString;
+    source: z.ZodEnum<{
+        session: "session";
+        default: "default";
+        custom: "custom";
+    }>;
+    available: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const modelDirectorySchema: z.ZodObject<{
+    providers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>>;
+        unavailable: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CaptureModel = z.infer<typeof captureModelSchema>;
+export type ModelDirectory = z.infer<typeof modelDirectorySchema>;
+export declare const stateSchema: z.ZodObject<{
+    profile: z.ZodString;
+    scope: z.ZodObject<{
+        workspace: z.ZodString;
+        session: z.ZodNullable<z.ZodString>;
+        includePersonal: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    selectedSession: z.ZodNullable<z.ZodString>;
+    workspaces: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    entries: z.ZodArray<z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+        kind: z.ZodEnum<{
+            agreement: "agreement";
+            decision: "decision";
+            lesson: "lesson";
+            handoff: "handoff";
+        }>;
+        tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        pinned: z.ZodDefault<z.ZodBoolean>;
+        recall: z.ZodDefault<z.ZodBoolean>;
+        range: z.ZodDefault<z.ZodEnum<{
+            workspace: "workspace";
+            session: "session";
+            personal: "personal";
+        }>>;
+        id: z.ZodString;
+        version: z.ZodNumber;
+        workspace: z.ZodString;
+        session: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            active: "active";
+            trash: "trash";
+        }>;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                manual: "manual";
+                model: "model";
+                capture: "capture";
+            }>;
+            session: z.ZodNullable<z.ZodString>;
+            turn: z.ZodNullable<z.ZodNumber>;
+            evidence: z.ZodString;
+            seqs: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        updated: z.ZodString;
+    }, z.core.$strict>>;
+    candidates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodString;
+        target: z.ZodNullable<z.ZodString>;
+        expected: z.ZodNumber;
+        workspace: z.ZodString;
+        session: z.ZodNullable<z.ZodString>;
+        draft: z.ZodObject<{
+            title: z.ZodString;
+            content: z.ZodString;
+            kind: z.ZodEnum<{
+                agreement: "agreement";
+                decision: "decision";
+                lesson: "lesson";
+                handoff: "handoff";
+            }>;
+            tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            pinned: z.ZodDefault<z.ZodBoolean>;
+            recall: z.ZodDefault<z.ZodBoolean>;
+            range: z.ZodDefault<z.ZodEnum<{
+                workspace: "workspace";
+                session: "session";
+                personal: "personal";
+            }>>;
+        }, z.core.$strict>;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                manual: "manual";
+                model: "model";
+                capture: "capture";
+            }>;
+            session: z.ZodNullable<z.ZodString>;
+            turn: z.ZodNullable<z.ZodNumber>;
+            evidence: z.ZodString;
+            seqs: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strict>;
+        state: z.ZodEnum<{
+            pending: "pending";
+            rejected: "rejected";
+            accepted: "accepted";
+        }>;
+        updated: z.ZodString;
+    }, z.core.$strip>>;
+    activities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspace: z.ZodString;
+        session: z.ZodNullable<z.ZodString>;
+        turn: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodString;
+        reason: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodNumber;
+            title: z.ZodString;
+            summary: z.ZodString;
+            status: z.ZodEnum<{
+                prepared: "prepared";
+                included: "included";
+                search: "search";
+                read: "read";
+                deleted: "deleted";
+            }>;
+        }, z.core.$strip>>;
+        updated: z.ZodString;
+    }, z.core.$strip>>;
+    jobs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspace: z.ZodString;
+        session: z.ZodString;
+        turn: z.ZodNumber;
+        state: z.ZodEnum<{
+            queued: "queued";
+            running: "running";
+            done: "done";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+            skipped: "skipped";
+        }>;
+        reason: z.ZodString;
+        candidateIds: z.ZodArray<z.ZodString>;
+        updated: z.ZodString;
+        automatic: z.ZodBoolean;
+    }, z.core.$strip>>;
+    settings: z.ZodObject<{
+        revision: z.ZodDefault<z.ZodNumber>;
+        autoRecall: z.ZodDefault<z.ZodBoolean>;
+        autoCapture: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodString>;
+        model: z.ZodDefault<z.ZodString>;
+        maxDailyCalls: z.ZodDefault<z.ZodNumber>;
+        maxRecallChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    captureModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        source: z.ZodEnum<{
+            session: "session";
+            default: "default";
+            custom: "custom";
+        }>;
+        available: z.ZodBoolean;
+    }, z.core.$strip>>>;
+    followingModel: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        source: z.ZodEnum<{
+            session: "session";
+            default: "default";
+            custom: "custom";
+        }>;
+        available: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type State = z.infer<typeof stateSchema>;
+export declare const visible: (value: {
+    workspace: string;
+    session: string | null;
+}, scope: Scope) => boolean;
+export declare class MemoryError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, status?: number);
+}
+export declare function abort(signal?: AbortSignal): void;

package/lib/shared.js

@@ -0,0 +1,40 @@
+/** Validated wire/domain identities; candidates never belong to the readable collection. */
+import { z } from 'zod';
+export const API = '/api/libing-memory-manager';
+export const kinds = ['agreement', 'decision', 'lesson', 'handoff'];
+export const kindSchema = z.enum(kinds);
+export const scopeSchema = z.object({ workspace: z.string().min(1), session: z.string().min(1).nullable(), includePersonal: z.boolean().optional() }).strict();
+export const draftSchema = z.object({ title: z.string().trim().min(1).max(120), content: z.string().trim().min(1).max(6000), kind: kindSchema, tags: z.array(z.string().trim().min(1).max(40)).max(12).default([]), pinned: z.boolean().default(false), recall: z.boolean().default(true), range: z.enum(['workspace', 'session', 'personal']).default('workspace') }).strict();
+export const sourceSchema = z.object({ kind: z.enum(['manual', 'model', 'capture']), session: z.string().nullable(), turn: z.number().int().nonnegative().nullable(), evidence: z.string().max(1200), seqs: z.array(z.number().int().nonnegative()).max(100) }).strict();
+export const entrySchema = draftSchema.extend({ id: z.string(), version: z.number().int().positive(), workspace: z.string(), session: z.string().nullable(), state: z.enum(['active', 'trash']), source: sourceSchema, updated: z.string() });
+export const candidateSchema = z.object({ id: z.string(), revision: z.string(), target: z.string().nullable(), expected: z.number().int().nonnegative(), workspace: z.string(), session: z.string().nullable(), draft: draftSchema, source: sourceSchema, state: z.enum(['pending', 'rejected', 'accepted']), updated: z.string() });
+export const activityItemSchema = z.object({ id: z.string(), version: z.number().int(), title: z.string(), summary: z.string(), status: z.enum(['prepared', 'included', 'search', 'read', 'deleted']) });
+export const activitySchema = z.object({ id: z.string(), workspace: z.string(), session: z.string().nullable(), turn: z.number().int().nullable(), kind: z.string(), reason: z.string(), items: z.array(activityItemSchema), updated: z.string() });
+export const jobSchema = z.object({ id: z.string(), workspace: z.string(), session: z.string(), turn: z.number().int(), state: z.enum(['queued', 'running', 'done', 'failed', 'cancelled', 'interrupted', 'skipped']), reason: z.string(), candidateIds: z.array(z.string()), updated: z.string(), automatic: z.boolean() });
+export const settingsSchema = z.object({ revision: z.number().int().nonnegative().default(0), autoRecall: z.boolean().default(true), autoCapture: z.boolean().default(false), provider: z.string().max(120).default(''), model: z.string().max(160).default(''), maxDailyCalls: z.number().int().min(1).max(100).default(20), maxRecallChars: z.number().int().min(500).max(8000).default(4000) }).strict();
+export const selectionSchema = z.object({ workspaceId: z.string().optional(), sessionId: z.string().optional() }).strict();
+export const mutationSchema = z.discriminatedUnion('action', [
+    z.strictObject({ action: z.literal('create'), draft: draftSchema }),
+    z.strictObject({ action: z.literal('propose'), draft: draftSchema, target: z.string().optional(), expected: z.number().int().optional() }),
+    z.strictObject({ action: z.literal('approve'), id: z.string(), revision: z.string(), draft: draftSchema }),
+    z.strictObject({ action: z.literal('reject'), id: z.string(), revision: z.string() }),
+    z.strictObject({ action: z.enum(['trash', 'restore', 'toggle']), id: z.string(), version: z.number().int().positive() }),
+    z.strictObject({ action: z.literal('purge'), id: z.string(), version: z.number().int().positive(), confirmTitle: z.string() }),
+    z.strictObject({ action: z.literal('settings'), settings: settingsSchema }),
+    z.strictObject({ action: z.literal('capture'), turn: z.number().int().positive().optional(), expectedModel: z.strictObject({ provider: z.string(), model: z.string() }).optional() }),
+    z.strictObject({ action: z.literal('cancel'), id: z.string() })
+]);
+export const captureModelSchema = z.object({ provider: z.string(), model: z.string(), source: z.enum(['session', 'default', 'custom']), available: z.boolean() });
+export const modelDirectorySchema = z.object({ providers: z.array(z.object({ id: z.string(), name: z.string(), models: z.array(z.object({ id: z.string(), name: z.string() })), unavailable: z.boolean() })) });
+export const stateSchema = z.object({ profile: z.string(), scope: scopeSchema, selectedSession: z.string().nullable(), workspaces: z.array(z.object({ id: z.string(), title: z.string() })), sessions: z.array(z.object({ id: z.string(), title: z.string() })), entries: z.array(entrySchema), candidates: z.array(candidateSchema), activities: z.array(activitySchema), jobs: z.array(jobSchema), settings: settingsSchema, captureModel: captureModelSchema.nullable().default(null), followingModel: captureModelSchema.nullable().default(null) });
+export const visible = (value, scope) => (value.workspace === 'personal' && scope.includePersonal !== false || value.workspace === scope.workspace) && (value.session === null || value.session === scope.session);
+export class MemoryError extends Error {
+    code;
+    status;
+    constructor(code, status = 409) {
+        super(code);
+        this.code = code;
+        this.status = status;
+    }
+}
+export function abort(signal) { signal?.throwIfAborted(); }

package/lib/storage-worker.d.ts

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