agent-office 0.0.3 → 0.0.4

package/dist/cli.js

@@ -13,6 +13,7 @@ program
     .option("--opencode-url <url>", "OpenCode server URL", process.env.OPENCODE_URL ?? "http://localhost:4096")
     .option("--host <host>", "Host to bind to", "127.0.0.1")
     .option("--port <port>", "Port to serve on", "7654")
+    .option("--memory-path <path>", "Directory for memory storage (default: ./.memory)", "./.memory")
     .option("--password <password>", "REQUIRED. API password", process.env.AGENT_OFFICE_PASSWORD)
     .action(async (options) => {
     const { serve } = await import("./commands/serve.js");
@@ -157,4 +158,47 @@ cronCmd
     const { cronHistory } = await import("./commands/worker.js");
     await cronHistory(token, cronId);
 });
+// ── Worker Memory Commands (nested) ──────────────────────────────────────────
+const memoryCmd = workerCmd
+    .command("memory")
+    .description("Manage your persistent memories");
+memoryCmd
+    .command("add")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .description("Add a new memory")
+    .requiredOption("--content <content>", "Memory content to store")
+    .action(async (token, options) => {
+    const { memoryAdd } = await import("./commands/worker.js");
+    await memoryAdd(token, options.content);
+});
+memoryCmd
+    .command("search")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .description("Search memories using hybrid search (keyword + semantic)")
+    .requiredOption("--query <query>", "Search query")
+    .option("--limit <limit>", "Maximum results (default 10)", "10")
+    .action(async (token, options) => {
+    const limit = parseInt(options.limit ?? "10", 10);
+    const { memorySearch } = await import("./commands/worker.js");
+    await memorySearch(token, options.query, limit);
+});
+memoryCmd
+    .command("list")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .description("List all stored memories")
+    .option("--limit <limit>", "Maximum memories to list (default 50)", "50")
+    .action(async (token, options) => {
+    const limit = parseInt(options.limit ?? "50", 10);
+    const { memoryList } = await import("./commands/worker.js");
+    await memoryList(token, limit);
+});
+memoryCmd
+    .command("forget")
+    .argument("<token>", "Agent token in the format <agent_code>@<server-url>")
+    .argument("<memoryId>", "ID of the memory to forget")
+    .description("Delete a memory by ID")
+    .action(async (token, memoryId) => {
+    const { memoryForget } = await import("./commands/worker.js");
+    await memoryForget(token, memoryId);
+});
 program.parse();

package/dist/commands/serve.d.ts

@@ -3,6 +3,7 @@ interface ServeOptions {
     opencodeUrl: string;
     host: string;
     port: string;
+    memoryPath: string;
     password?: string;
 }
 export declare function serve(options: ServeOptions): Promise<void>;

package/dist/commands/serve.js

@@ -3,6 +3,7 @@ import { runMigrations } from "../db/migrate.js";
 import { createOpencodeClient } from "../lib/opencode.js";
 import { createApp } from "../server/index.js";
 import { CronScheduler } from "../server/cron.js";
+import { MemoryManager } from "../server/memory.js";
 export async function serve(options) {
     const password = options.password;
     if (!password) {
@@ -36,10 +37,25 @@ export async function serve(options) {
     // Init OpenCode client
     const opencode = createOpencodeClient(options.opencodeUrl);
     const serverUrl = `http://${options.host}:${port}`;
+    // Create memory manager and verify embedding model
+    const memoryManager = new MemoryManager(options.memoryPath);
+    console.log("Warming up embedding model...");
+    try {
+        await memoryManager.warmup();
+        console.log("Embedding model ready.");
+    }
+    catch (err) {
+        console.error("Embedding model failed to load:", err);
+        console.error("Try deleting the model cache and restarting:");
+        console.error(`  rm -rf ${options.memoryPath}/.model-cache`);
+        memoryManager.closeAll();
+        await sql.end();
+        process.exit(1);
+    }
     // Create cron scheduler
     const cronScheduler = new CronScheduler();
     // Create Express app
-    const app = createApp(sql, opencode, password, serverUrl, cronScheduler);
+    const app = createApp(sql, opencode, password, serverUrl, cronScheduler, memoryManager);
     // Start cron scheduler
     await cronScheduler.start(sql, opencode);
     // Start server
@@ -51,6 +67,7 @@ export async function serve(options) {
         console.log("\nShutting down...");
         server.close(async () => {
             cronScheduler.stop();
+            memoryManager.closeAll();
             await sql.end();
             console.log("Goodbye.");
             process.exit(0);

package/dist/commands/worker.d.ts

@@ -13,3 +13,7 @@ export declare function deleteCron(token: string, cronId: number): Promise<void>
 export declare function enableCron(token: string, cronId: number): Promise<void>;
 export declare function disableCron(token: string, cronId: number): Promise<void>;
 export declare function cronHistory(token: string, cronId: number): Promise<void>;
+export declare function memoryAdd(token: string, content: string): Promise<void>;
+export declare function memorySearch(token: string, query: string, limit: number): Promise<void>;
+export declare function memoryList(token: string, limit: number): Promise<void>;
+export declare function memoryForget(token: string, memoryId: string): Promise<void>;

package/dist/commands/worker.js

@@ -167,3 +167,66 @@ export async function cronHistory(token, cronId) {
     const history = await fetchWorker(token, `/worker/crons/${cronId}/history`);
     console.log(JSON.stringify(history, null, 2));
 }
+// ── Memory Commands ──────────────────────────────────────────────────────────
+export async function memoryAdd(token, content) {
+    const result = await postWorker(token, "/worker/memory/add", { content });
+    console.log(JSON.stringify(result, null, 2));
+}
+export async function memorySearch(token, query, limit) {
+    const result = await postWorker(token, "/worker/memory/search", { query, limit });
+    console.log(JSON.stringify(result, null, 2));
+}
+export async function memoryList(token, limit) {
+    const { agentCode, serverUrl } = parseToken(token);
+    const url = `${serverUrl}/worker/memory/list?code=${encodeURIComponent(agentCode)}&limit=${limit}`;
+    let res;
+    try {
+        res = await fetch(url);
+    }
+    catch (err) {
+        console.error(`Error: could not reach ${serverUrl}`);
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        console.error(`Error: invalid response from server`);
+        process.exit(1);
+    }
+    if (!res.ok) {
+        const msg = body.error ?? `HTTP ${res.status}`;
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(body, null, 2));
+}
+export async function memoryForget(token, memoryId) {
+    const { agentCode, serverUrl } = parseToken(token);
+    const url = `${serverUrl}/worker/memory/${encodeURIComponent(memoryId)}?code=${encodeURIComponent(agentCode)}`;
+    let res;
+    try {
+        res = await fetch(url, { method: "DELETE" });
+    }
+    catch (err) {
+        console.error(`Error: could not reach ${serverUrl}`);
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+    let body;
+    try {
+        body = await res.json();
+    }
+    catch {
+        console.error(`Error: invalid response from server`);
+        process.exit(1);
+    }
+    if (!res.ok) {
+        const msg = body.error ?? `HTTP ${res.status}`;
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+    console.log(JSON.stringify(body, null, 2));
+}

package/dist/manage/app.js

@@ -23,7 +23,7 @@ const FOOTER_HINTS = {
     connecting: "",
     "auth-error": "",
     menu: "↑↓ navigate · Enter select · q quit",
-    list: "↑↓ navigate · c create · d delete · r reveal code · g regen · x revert · t tail · i inject · m mail · Esc back",
+    list: "↑↓ navigate · c create · d delete · r reveal code · g regen · x revert · t tail · i inject · m mail · M memories · Esc back",
     "send-message": "Enter submit · Esc back to menu",
     "my-mail": "↑↓ select message · r reply · m mark read · a mark all read · s sent tab · Esc back",
     "profile": "Enter submit · Esc back to menu",

package/dist/manage/components/SessionList.js

@@ -211,6 +211,267 @@ function CoworkerMailView({ serverUrl, password, sessionName, contentHeight, onC
                         ? _jsx(Text, { bold: true, color: "yellow", children: "[Sent]" })
                         : _jsx(Text, { dimColor: true, children: "Sent (s)" })] }), renderMessages()] }));
 }
+function MemoryView({ serverUrl, password, sessionName, contentHeight, onClose }) {
+    const { listMemories, searchMemories, deleteMemory, updateMemory, addMemory } = useApi(serverUrl, password);
+    const [memoryMode, setMemoryMode] = useState("browse");
+    const [memories, setMemories] = useState([]);
+    const [searchResults, setSearchResults] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [cursor, setCursor] = useState(0);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const [selectedMemory, setSelectedMemory] = useState(null);
+    const [actionMsg, setActionMsg] = useState(null);
+    const [searchInput, setSearchInput] = useState(false);
+    const loadMemories = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await listMemories(sessionName, 100);
+            setMemories(result.memories);
+            setTotal(result.total);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [sessionName]);
+    useEffect(() => { void loadMemories(); }, [loadMemories]);
+    useInput((input, key) => {
+        if (memoryMode === "browse") {
+            if (key.escape) {
+                onClose();
+                return;
+            }
+            if (!loading) {
+                if (input === "a") {
+                    setMemoryMode("adding");
+                }
+                if (input === "s") {
+                    setSearchInput(true);
+                    setMemoryMode("search");
+                }
+            }
+            if (!loading && memories.length > 0) {
+                if (key.upArrow)
+                    setCursor((c) => Math.max(0, c - 1));
+                if (key.downArrow)
+                    setCursor((c) => Math.min(memories.length - 1, c + 1));
+                if (key.return) {
+                    setSelectedMemory(memories[cursor] ?? null);
+                    setMemoryMode("view-detail");
+                    setScrollOffset(0);
+                }
+                if (input === "d") {
+                    setSelectedMemory(memories[cursor] ?? null);
+                    setMemoryMode("confirm-delete");
+                }
+            }
+        }
+        if (memoryMode === "view-detail") {
+            if (key.escape) {
+                setMemoryMode("browse");
+                setSelectedMemory(null);
+                return;
+            }
+            if (key.upArrow)
+                setScrollOffset((o) => Math.max(0, o - 1));
+            if (key.downArrow)
+                setScrollOffset((o) => o + 1);
+            if (input === "e") {
+                setMemoryMode("editing");
+            }
+            if (input === "d") {
+                setMemoryMode("confirm-delete");
+            }
+        }
+        if (memoryMode === "search-results") {
+            if (key.escape) {
+                setMemoryMode("browse");
+                setSearchResults([]);
+                setCursor(0);
+                return;
+            }
+            if (searchResults.length > 0) {
+                if (key.upArrow)
+                    setCursor((c) => Math.max(0, c - 1));
+                if (key.downArrow)
+                    setCursor((c) => Math.min(searchResults.length - 1, c + 1));
+                if (key.return) {
+                    setSelectedMemory(searchResults[cursor] ?? null);
+                    setMemoryMode("view-detail");
+                    setScrollOffset(0);
+                }
+            }
+        }
+        if (memoryMode === "confirm-delete") {
+            if (key.escape) {
+                setMemoryMode(selectedMemory ? "view-detail" : "browse");
+                return;
+            }
+            if (input === "y" || input === "Y") {
+                void handleDelete();
+            }
+            if (input === "n" || input === "N") {
+                setMemoryMode(selectedMemory ? "view-detail" : "browse");
+            }
+        }
+        if (memoryMode === "adding" && key.escape) {
+            setMemoryMode("browse");
+        }
+        if (memoryMode === "search" && key.escape) {
+            setSearchInput(false);
+            setMemoryMode("browse");
+        }
+        if (memoryMode === "editing" && key.escape) {
+            setMemoryMode("view-detail");
+        }
+    });
+    const handleDelete = async () => {
+        if (!selectedMemory)
+            return;
+        setMemoryMode("deleting");
+        try {
+            await deleteMemory(sessionName, selectedMemory.id);
+            setActionMsg(`Memory deleted.`);
+            setSelectedMemory(null);
+            setMemoryMode("browse");
+            setCursor(0);
+            await loadMemories();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setMemoryMode("browse");
+        }
+    };
+    const handleAdd = async (content) => {
+        const trimmed = content.trim();
+        if (!trimmed)
+            return;
+        setLoading(true);
+        try {
+            await addMemory(sessionName, trimmed);
+            setActionMsg("Memory added.");
+            setMemoryMode("browse");
+            await loadMemories();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setMemoryMode("browse");
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const handleSearch = async (query) => {
+        const trimmed = query.trim();
+        if (!trimmed)
+            return;
+        setSearchInput(false);
+        setLoading(true);
+        try {
+            const results = await searchMemories(sessionName, trimmed, 20);
+            setSearchResults(results);
+            setCursor(0);
+            setMemoryMode("search-results");
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setMemoryMode("browse");
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const handleEdit = async (newContent) => {
+        const trimmed = newContent.trim();
+        if (!trimmed || !selectedMemory)
+            return;
+        setLoading(true);
+        try {
+            await updateMemory(sessionName, selectedMemory.id, trimmed);
+            setActionMsg("Memory updated.");
+            setSelectedMemory(null);
+            setMemoryMode("browse");
+            await loadMemories();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : String(err));
+            setMemoryMode("view-detail");
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    // Clear action messages after a delay
+    useEffect(() => {
+        if (actionMsg) {
+            const t = setTimeout(() => setActionMsg(null), 2000);
+            return () => clearTimeout(t);
+        }
+    }, [actionMsg]);
+    if (loading && memories.length === 0 && memoryMode === "browse") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: `Loading memories for "${sessionName}"...` }) }));
+    }
+    if (memoryMode === "adding") {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Add Memory" }), _jsx(Text, { color: "cyan", children: sessionName })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "Content: " }), _jsx(TextInput, { placeholder: "Type memory content...", onSubmit: (v) => void handleAdd(v) })] }), _jsx(Text, { dimColor: true, children: "Enter to save \u00B7 Esc cancel" })] }));
+    }
+    if (memoryMode === "search") {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Search Memories" }), _jsx(Text, { color: "cyan", children: sessionName })] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "Query: " }), searchInput && (_jsx(TextInput, { placeholder: "semantic or keyword search...", onSubmit: (v) => void handleSearch(v) }))] }), _jsx(Text, { dimColor: true, children: "Enter to search \u00B7 Esc cancel" })] }));
+    }
+    if (memoryMode === "search-results") {
+        const viewHeight = contentHeight - 5;
+        return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Search Results" }), _jsx(Text, { color: "cyan", children: sessionName }), _jsxs(Text, { dimColor: true, children: ["(", searchResults.length, " results)"] })] }), loading && _jsx(Spinner, { label: "Searching..." }), searchResults.length === 0 && !loading ? (_jsx(Text, { dimColor: true, children: "No results found." })) : (_jsx(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: searchResults.map((mem, i) => {
+                        const sel = i === cursor;
+                        const preview = mem.content.length > 80 ? mem.content.slice(0, 80) + "..." : mem.content;
+                        return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: sel ? "cyan" : undefined, bold: sel, children: sel ? "▶" : " " }), _jsx(Text, { dimColor: true, children: (mem.score?.toFixed(4) ?? "").padEnd(8) }), _jsx(Text, { color: sel ? "cyan" : undefined, children: preview })] }, mem.id));
+                    }) })), _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u00B7 Enter view \u00B7 Esc back to list" })] }));
+    }
+    if (memoryMode === "view-detail" && selectedMemory) {
+        const lines = selectedMemory.content.split("\n");
+        const metaStr = Object.keys(selectedMemory.metadata).length > 0
+            ? JSON.stringify(selectedMemory.metadata, null, 2)
+            : "(none)";
+        const allLines = [
+            `ID:       ${selectedMemory.id}`,
+            `Created:  ${selectedMemory.createdAt}`,
+            ...(selectedMemory.score != null ? [`Score:    ${selectedMemory.score.toFixed(4)}`] : []),
+            `Metadata: ${metaStr}`,
+            ``,
+            `Content:`,
+            ...lines,
+        ];
+        const viewHeight = contentHeight - 5;
+        const maxOff = Math.max(0, allLines.length - viewHeight);
+        const clamped = Math.min(scrollOffset, maxOff);
+        const visible = allLines.slice(clamped, clamped + viewHeight);
+        return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Memory Detail" }), _jsx(Text, { color: "cyan", children: sessionName })] }), _jsx(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: visible.map((line, i) => (_jsx(Text, { children: line }, i))) }), _jsx(Text, { dimColor: true, children: "\u2191\u2193 scroll \u00B7 e edit \u00B7 d delete \u00B7 Esc back" })] }));
+    }
+    if (memoryMode === "confirm-delete") {
+        const target = selectedMemory ?? memories[cursor];
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, color: "red", children: "Delete Memory" }), _jsx(Text, { color: "cyan", children: sessionName })] }), target && (_jsxs(Text, { children: ["Delete memory: ", _jsxs(Text, { color: "yellow", children: ["\"", target.content.slice(0, 60), "...\""] }), "?"] })), _jsx(Text, { children: "y/n" })] }));
+    }
+    if (memoryMode === "deleting") {
+        return (_jsx(Box, { height: contentHeight, alignItems: "center", justifyContent: "center", children: _jsx(Spinner, { label: "Deleting memory..." }) }));
+    }
+    if (memoryMode === "editing" && selectedMemory) {
+        return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: "Edit Memory" }), _jsx(Text, { color: "cyan", children: sessionName })] }), _jsxs(Text, { dimColor: true, children: ["Current: ", selectedMemory.content.slice(0, 80), "..."] }), _jsxs(Box, { gap: 1, children: [_jsx(Text, { children: "New content: " }), _jsx(TextInput, { placeholder: "Enter new content...", defaultValue: selectedMemory.content, onSubmit: (v) => void handleEdit(v) })] }), _jsx(Text, { dimColor: true, children: "Enter to save \u00B7 Esc cancel" })] }));
+    }
+    // ── Browse mode ───────────────────────────────────────────────────────────
+    const viewHeight = contentHeight - 5;
+    const visibleStart = Math.max(0, cursor - viewHeight + 1);
+    const visibleMemories = memories.slice(visibleStart, visibleStart + viewHeight);
+    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, children: "Memories" }), _jsx(Text, { color: "cyan", children: sessionName }), _jsxs(Text, { dimColor: true, children: ["(", total, " total)"] }), loading && _jsx(Spinner, {})] }), actionMsg && _jsx(Text, { color: "green", children: actionMsg }), error && _jsxs(Text, { color: "red", children: ["Error: ", error] }), memories.length === 0 ? (_jsx(Text, { dimColor: true, children: "No memories stored yet." })) : (_jsx(Box, { flexDirection: "column", height: viewHeight, overflow: "hidden", children: visibleMemories.map((mem, i) => {
+                    const actualIdx = visibleStart + i;
+                    const sel = actualIdx === cursor;
+                    const preview = mem.content.length > 90 ? mem.content.slice(0, 90) + "..." : mem.content;
+                    const date = new Date(mem.createdAt).toLocaleDateString();
+                    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: sel ? "cyan" : undefined, bold: sel, children: sel ? "▶" : " " }), _jsx(Text, { dimColor: true, children: date.padEnd(12) }), _jsx(Text, { color: sel ? "cyan" : undefined, children: preview })] }, mem.id));
+                }) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "\u2191\u2193 navigate \u00B7 Enter view \u00B7 a add \u00B7 d delete \u00B7 s search \u00B7 Esc back" }) })] }));
+}
 // ─── Main component ──────────────────────────────────────────────────────────
 export function SessionList({ serverUrl, password, contentHeight }) {
     const { listSessions, createSession, deleteSession, regenerateCode, getModes, revertToStart } = useApi(serverUrl, password);
@@ -290,6 +551,8 @@ export function SessionList({ serverUrl, password, contentHeight }) {
                     setSubView("inject");
                 if (input === "m")
                     setSubView("coworker-mail");
+                if (input === "M")
+                    setSubView("memories");
             }
         }
         if (mode === "creating-pick-mode") {
@@ -450,6 +713,9 @@ export function SessionList({ serverUrl, password, contentHeight }) {
         if (subView === "coworker-mail") {
             return (_jsx(CoworkerMailView, { serverUrl: serverUrl, password: password, sessionName: activeSession.name, contentHeight: contentHeight, onClose: closeSubView }));
         }
+        if (subView === "memories") {
+            return (_jsx(MemoryView, { serverUrl: serverUrl, password: password, sessionName: activeSession.name, contentHeight: contentHeight, onClose: closeSubView }));
+        }
     }
     // ── Initial load ──────────────────────────────────────────────────────────
     if (loading && rows.length === 0) {

package/dist/manage/hooks/useApi.d.ts

@@ -55,6 +55,13 @@ export interface CronHistoryEntry {
     success: boolean;
     error_message: string | null;
 }
+export interface MemoryRecord {
+    id: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    score?: number;
+}
 export declare function useApi(serverUrl: string, password: string): {
     listSessions: () => Promise<Session[]>;
     createSession: (name: string, mode?: string) => Promise<Session>;
@@ -106,6 +113,23 @@ export declare function useApi(serverUrl: string, password: string): {
     enableCron: (id: number) => Promise<CronJob>;
     disableCron: (id: number) => Promise<CronJob>;
     getCronHistory: (id: number, limit?: number) => Promise<CronHistoryEntry[]>;
+    addMemory: (sessionName: string, content: string, metadata?: Record<string, unknown>) => Promise<{
+        ok: boolean;
+        id: string;
+    }>;
+    listMemories: (sessionName: string, limit?: number) => Promise<{
+        memories: MemoryRecord[];
+        total: number;
+    }>;
+    getMemory: (sessionName: string, memoryId: string) => Promise<MemoryRecord>;
+    updateMemory: (sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>) => Promise<{
+        ok: boolean;
+    }>;
+    deleteMemory: (sessionName: string, memoryId: string) => Promise<{
+        deleted: boolean;
+        id: string;
+    }>;
+    searchMemories: (sessionName: string, query: string, limit?: number) => Promise<MemoryRecord[]>;
 };
 export declare function useAsyncState<T>(): {
     run: (fn: () => Promise<T>) => Promise<T | null>;

package/dist/manage/hooks/useApi.js

@@ -106,6 +106,24 @@ export function useApi(serverUrl, password) {
     const getCronHistory = useCallback(async (id, limit = 10) => {
         return apiFetch(`${base}/crons/${id}/history?limit=${limit}`, password);
     }, [base, password]);
+    const addMemory = useCallback(async (sessionName, content, metadata) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(sessionName)}/memories`, password, { method: "POST", body: JSON.stringify({ content, ...(metadata ? { metadata } : {}) }) });
+    }, [base, password]);
+    const listMemories = useCallback(async (sessionName, limit = 50) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(sessionName)}/memories?limit=${limit}`, password);
+    }, [base, password]);
+    const getMemory = useCallback(async (sessionName, memoryId) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(sessionName)}/memories/${encodeURIComponent(memoryId)}`, password);
+    }, [base, password]);
+    const updateMemory = useCallback(async (sessionName, memoryId, content, metadata) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(sessionName)}/memories/${encodeURIComponent(memoryId)}`, password, { method: "PUT", body: JSON.stringify({ content, ...(metadata ? { metadata } : {}) }) });
+    }, [base, password]);
+    const deleteMemory = useCallback(async (sessionName, memoryId) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(sessionName)}/memories/${encodeURIComponent(memoryId)}`, password, { method: "DELETE" });
+    }, [base, password]);
+    const searchMemories = useCallback(async (sessionName, query, limit = 10) => {
+        return apiFetch(`${base}/sessions/${encodeURIComponent(sessionName)}/memories/search`, password, { method: "POST", body: JSON.stringify({ query, limit }) });
+    }, [base, password]);
     return {
         listSessions,
         createSession,
@@ -127,6 +145,12 @@ export function useApi(serverUrl, password) {
         enableCron,
         disableCron,
         getCronHistory,
+        addMemory,
+        listMemories,
+        getMemory,
+        updateMemory,
+        deleteMemory,
+        searchMemories,
     };
 }
 export function useAsyncState() {

package/dist/server/index.d.ts

@@ -1,4 +1,5 @@
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
 import { CronScheduler } from "./cron.js";
-export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string, serverUrl: string, cronScheduler: CronScheduler): import("express-serve-static-core").Express;
+import type { MemoryManager } from "./memory.js";
+export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string, serverUrl: string, cronScheduler: CronScheduler, memoryManager: MemoryManager): import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -10,13 +10,13 @@ function authMiddleware(password) {
         next();
     };
 }
-export function createApp(sql, opencode, password, serverUrl, cronScheduler) {
+export function createApp(sql, opencode, password, serverUrl, cronScheduler, memoryManager) {
     const app = express();
     app.use(express.json());
     // Worker routes are unauthenticated — mounted before auth middleware
-    app.use("/", createWorkerRouter(sql, opencode, serverUrl));
+    app.use("/", createWorkerRouter(sql, opencode, serverUrl, memoryManager));
     // Everything else requires Bearer auth
     app.use(authMiddleware(password));
-    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler));
+    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler, memoryManager));
     return app;
 }

package/dist/server/memory.d.ts

@@ -0,0 +1,64 @@
+import { createAgentMemory, type MemoryEntry } from "fastmemory";
+export interface MemoryRecord {
+    id: string;
+    content: string;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+}
+type MemoryStore = Awaited<ReturnType<typeof createAgentMemory>>;
+/**
+ * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Each session gets its own .db file under <memoryPath>/<sessionName>.db
+ */
+export declare class MemoryManager {
+    private basePath;
+    private stores;
+    constructor(memoryPath: string);
+    private dbPathFor;
+    getStore(sessionName: string): Promise<MemoryStore>;
+    /**
+     * Add a memory for a session
+     */
+    addMemory(sessionName: string, content: string, metadata?: Record<string, unknown>): Promise<string>;
+    /**
+     * Sanitize a query string for FTS5 MATCH syntax.
+     * Wraps each whitespace-delimited token in double quotes so that
+     * special characters (apostrophes, parens, asterisks, etc.) are
+     * treated as literals rather than FTS5 operators.
+     */
+    private sanitizeFts5Query;
+    /**
+     * Search memories using hybrid search (BM25 + vector + RRF)
+     */
+    searchMemories(sessionName: string, query: string, limit?: number): Promise<MemoryEntry[]>;
+    /**
+     * List all memories for a session (direct SQLite access since fastmemory has no list method)
+     */
+    listMemories(sessionName: string, limit?: number): MemoryRecord[];
+    /**
+     * Get a single memory by ID
+     */
+    getMemory(sessionName: string, memoryId: string): MemoryRecord | null;
+    /**
+     * Delete a memory by ID (direct SQLite - fastmemory has no delete method)
+     */
+    deleteMemory(sessionName: string, memoryId: string): boolean;
+    /**
+     * Update a memory's content (direct SQLite, re-embeds via delete+add)
+     */
+    updateMemory(sessionName: string, memoryId: string, content: string, metadata?: Record<string, unknown>): Promise<boolean>;
+    /**
+     * Get stats for a session's memory store
+     */
+    getStats(sessionName: string): {
+        total: number;
+    };
+    /**
+     * Warm up the embedding model and verify it loads correctly.
+     * Uses a temporary DB so no real session data is affected.
+     * Throws if the model is corrupt or fails to produce embeddings.
+     */
+    warmup(): Promise<void>;
+    closeAll(): void;
+}
+export {};

package/dist/server/memory.js

@@ -0,0 +1,214 @@
+import { createAgentMemory } from "fastmemory";
+import { mkdirSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import Database from "better-sqlite3";
+/**
+ * Manages per-session memory stores backed by fastmemory (SQLite + embeddings).
+ * Each session gets its own .db file under <memoryPath>/<sessionName>.db
+ */
+export class MemoryManager {
+    basePath;
+    stores = new Map();
+    constructor(memoryPath) {
+        this.basePath = resolve(memoryPath);
+        if (!existsSync(this.basePath)) {
+            mkdirSync(this.basePath, { recursive: true });
+        }
+    }
+    dbPathFor(sessionName) {
+        // Sanitize session name for filesystem safety
+        const safe = sessionName.replace(/[^a-zA-Z0-9_-]/g, "_");
+        return join(this.basePath, `${safe}.db`);
+    }
+    async getStore(sessionName) {
+        if (this.stores.has(sessionName)) {
+            return this.stores.get(sessionName);
+        }
+        const dbPath = this.dbPathFor(sessionName);
+        const cacheDir = join(this.basePath, ".model-cache");
+        const store = await createAgentMemory({
+            dbPath,
+            cacheDir,
+            dtype: "q4",
+        });
+        this.stores.set(sessionName, store);
+        return store;
+    }
+    /**
+     * Add a memory for a session
+     */
+    async addMemory(sessionName, content, metadata = {}) {
+        const store = await this.getStore(sessionName);
+        return await store.add(content, metadata);
+    }
+    /**
+     * Sanitize a query string for FTS5 MATCH syntax.
+     * Wraps each whitespace-delimited token in double quotes so that
+     * special characters (apostrophes, parens, asterisks, etc.) are
+     * treated as literals rather than FTS5 operators.
+     */
+    sanitizeFts5Query(query) {
+        return query
+            .split(/\s+/)
+            .filter((t) => t.length > 0)
+            .map((t) => `"${t.replace(/"/g, '""')}"`)
+            .join(" ");
+    }
+    /**
+     * Search memories using hybrid search (BM25 + vector + RRF)
+     */
+    async searchMemories(sessionName, query, limit = 10) {
+        const store = await this.getStore(sessionName);
+        const safeQuery = this.sanitizeFts5Query(query);
+        return await store.searchHybrid(safeQuery, limit);
+    }
+    /**
+     * List all memories for a session (direct SQLite access since fastmemory has no list method)
+     */
+    listMemories(sessionName, limit = 50) {
+        const dbPath = this.dbPathFor(sessionName);
+        if (!existsSync(dbPath))
+            return [];
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        try {
+            const rows = db.prepare(`SELECT id, content, metadata, created_at FROM memories ORDER BY created_at DESC LIMIT ?`).all(limit);
+            return rows.map((r) => ({
+                id: r.id,
+                content: r.content,
+                metadata: r.metadata ? JSON.parse(r.metadata) : {},
+                createdAt: r.created_at,
+            }));
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Get a single memory by ID
+     */
+    getMemory(sessionName, memoryId) {
+        const dbPath = this.dbPathFor(sessionName);
+        if (!existsSync(dbPath))
+            return null;
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        try {
+            const row = db.prepare(`SELECT id, content, metadata, created_at FROM memories WHERE id = ?`).get(memoryId);
+            if (!row)
+                return null;
+            return {
+                id: row.id,
+                content: row.content,
+                metadata: row.metadata ? JSON.parse(row.metadata) : {},
+                createdAt: row.created_at,
+            };
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Delete a memory by ID (direct SQLite - fastmemory has no delete method)
+     */
+    deleteMemory(sessionName, memoryId) {
+        const dbPath = this.dbPathFor(sessionName);
+        if (!existsSync(dbPath))
+            return false;
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        try {
+            const result = db.prepare(`DELETE FROM memories WHERE id = ?`).run(memoryId);
+            return result.changes > 0;
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Update a memory's content (direct SQLite, re-embeds via delete+add)
+     */
+    async updateMemory(sessionName, memoryId, content, metadata) {
+        const existing = this.getMemory(sessionName, memoryId);
+        if (!existing)
+            return false;
+        // Delete old and re-add with new content (to get new embedding)
+        this.deleteMemory(sessionName, memoryId);
+        // Close the cached store so it picks up the direct DB changes
+        if (this.stores.has(sessionName)) {
+            this.stores.get(sessionName).close();
+            this.stores.delete(sessionName);
+        }
+        const store = await this.getStore(sessionName);
+        // Re-add with new content but preserve metadata if not provided
+        const finalMetadata = metadata ?? existing.metadata;
+        await store.add(content, finalMetadata);
+        return true;
+    }
+    /**
+     * Get stats for a session's memory store
+     */
+    getStats(sessionName) {
+        const dbPath = this.dbPathFor(sessionName);
+        if (!existsSync(dbPath))
+            return { total: 0 };
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        try {
+            const row = db.prepare(`SELECT COUNT(*) as total FROM memories`).get();
+            return { total: row.total };
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Warm up the embedding model and verify it loads correctly.
+     * Uses a temporary DB so no real session data is affected.
+     * Throws if the model is corrupt or fails to produce embeddings.
+     */
+    async warmup() {
+        const testDbPath = join(this.basePath, "_warmup_test.db");
+        const cacheDir = join(this.basePath, ".model-cache");
+        const store = await createAgentMemory({
+            dbPath: testDbPath,
+            cacheDir,
+            dtype: "q4",
+        });
+        try {
+            // Force an embedding by adding and searching
+            const id = await store.add("warmup test memory");
+            const results = await store.searchHybrid("warmup test", 1);
+            if (results.length === 0) {
+                throw new Error("Embedding model warmup: search returned no results");
+            }
+        }
+        finally {
+            store.close();
+            // Clean up the temp DB files
+            try {
+                const { unlinkSync } = await import("fs");
+                unlinkSync(testDbPath);
+                // SQLite WAL/SHM files
+                try {
+                    unlinkSync(testDbPath + "-wal");
+                }
+                catch { /* may not exist */ }
+                try {
+                    unlinkSync(testDbPath + "-shm");
+                }
+                catch { /* may not exist */ }
+            }
+            catch { /* ignore cleanup errors */ }
+        }
+    }
+    closeAll() {
+        for (const [, store] of this.stores) {
+            try {
+                store.close();
+            }
+            catch { /* ignore */ }
+        }
+        this.stores.clear();
+    }
+}

package/dist/server/routes.d.ts

@@ -2,5 +2,6 @@ import { Router } from "express";
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
 import { CronScheduler } from "./cron.js";
-export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler): Router;
-export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string): Router;
+import type { MemoryManager } from "./memory.js";
+export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler, memoryManager: MemoryManager): Router;
+export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, memoryManager: MemoryManager): Router;

package/dist/server/routes.js

@@ -73,6 +73,24 @@ function generateWelcomeMessage(name, mode, status, humanName, humanDescription,
         `   agent-office worker cron \\`,
         `     ${token}`,
         ``,
+        ` Store a memory (persistent across sessions)`,
+        `   agent-office worker memory add \\`,
+        `     --content "your memory here" \\`,
+        `     ${token}`,
+        ``,
+        ` Search your memories`,
+        `   agent-office worker memory search \\`,
+        `     --query "your search" \\`,
+        `     ${token}`,
+        ``,
+        ` List all your memories`,
+        `   agent-office worker memory list \\`,
+        `     ${token}`,
+        ``,
+        ` Forget a memory`,
+        `   agent-office worker memory forget \\`,
+        `     ${token} <memory-id>`,
+        ``,
         `════════════════════════════════════════════════════════`,
         ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
         `════════════════════════════════════════════════════════`,
@@ -109,7 +127,7 @@ function generateWelcomeMessage(name, mode, status, humanName, humanDescription,
         ``,
     ].join("\n");
 }
-export function createRouter(sql, opencode, serverUrl, scheduler) {
+export function createRouter(sql, opencode, serverUrl, scheduler, memoryManager) {
     const router = Router();
     router.get("/health", (_req, res) => {
         res.json({ ok: true });
@@ -799,9 +817,135 @@ export function createRouter(sql, opencode, serverUrl, scheduler) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    // ── Memory Endpoints (authenticated, for manage TUI) ───────────────────────
+    router.get("/sessions/:name/memories", async (req, res) => {
+        const { name } = req.params;
+        const limit = Math.min(parseInt(req.query.limit ?? "50", 10), 200);
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const memories = memoryManager.listMemories(name, limit);
+            const stats = memoryManager.getStats(name);
+            res.json({ memories, total: stats.total });
+        }
+        catch (err) {
+            console.error("GET /sessions/:name/memories error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/sessions/:name/memories", async (req, res) => {
+        const { name } = req.params;
+        const { content, metadata } = req.body;
+        if (!content || typeof content !== "string" || !content.trim()) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const id = await memoryManager.addMemory(name, content.trim(), metadata ?? {});
+            res.status(201).json({ ok: true, id });
+        }
+        catch (err) {
+            console.error("POST /sessions/:name/memories error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.get("/sessions/:name/memories/:memoryId", async (req, res) => {
+        const { name, memoryId } = req.params;
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const memory = memoryManager.getMemory(name, memoryId);
+            if (!memory) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json(memory);
+        }
+        catch (err) {
+            console.error("GET /sessions/:name/memories/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.put("/sessions/:name/memories/:memoryId", async (req, res) => {
+        const { name, memoryId } = req.params;
+        const { content, metadata } = req.body;
+        if (!content || typeof content !== "string" || !content.trim()) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const updated = await memoryManager.updateMemory(name, memoryId, content.trim(), metadata);
+            if (!updated) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            console.error("PUT /sessions/:name/memories/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.delete("/sessions/:name/memories/:memoryId", async (req, res) => {
+        const { name, memoryId } = req.params;
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const deleted = memoryManager.deleteMemory(name, memoryId);
+            if (!deleted) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json({ deleted: true, id: memoryId });
+        }
+        catch (err) {
+            console.error("DELETE /sessions/:name/memories/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/sessions/:name/memories/search", async (req, res) => {
+        const { name } = req.params;
+        const { query, limit } = req.body;
+        if (!query || typeof query !== "string" || !query.trim()) {
+            res.status(400).json({ error: "query is required" });
+            return;
+        }
+        const rows = await sql `SELECT id FROM sessions WHERE name = ${name}`;
+        if (rows.length === 0) {
+            res.status(404).json({ error: `Session "${name}" not found` });
+            return;
+        }
+        try {
+            const results = await memoryManager.searchMemories(name, query.trim(), Math.min(limit ?? 10, 50));
+            res.json(results);
+        }
+        catch (err) {
+            console.error("POST /sessions/:name/memories/search error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     return router;
 }
-export function createWorkerRouter(sql, opencode, serverUrl) {
+export function createWorkerRouter(sql, opencode, serverUrl, memoryManager) {
     const router = Router();
     router.get("/worker/clock-in", async (req, res) => {
         const { code } = req.query;
@@ -870,6 +1014,24 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             `   agent-office worker cron \\`,
             `     ${token}`,
             ``,
+            ` Store a memory (persistent across sessions)`,
+            `   agent-office worker memory add \\`,
+            `     --content "your memory here" \\`,
+            `     ${token}`,
+            ``,
+            ` Search your memories`,
+            `   agent-office worker memory search \\`,
+            `     --query "your search" \\`,
+            `     ${token}`,
+            ``,
+            ` List all your memories`,
+            `   agent-office worker memory list \\`,
+            `     ${token}`,
+            ``,
+            ` Forget a memory`,
+            `   agent-office worker memory forget \\`,
+            `     ${token} <memory-id>`,
+            ``,
             `════════════════════════════════════════════════════════`,
             ` ⚠  IMPORTANT: YOUR SESSIONS ARE PRIVATE`,
             `════════════════════════════════════════════════════════`,
@@ -1370,5 +1532,115 @@ export function createWorkerRouter(sql, opencode, serverUrl) {
             res.status(500).json({ error: "Internal server error" });
         }
     });
+    // ── Worker Memory Endpoints (authenticated via agent_code in query) ────────
+    router.post("/worker/memory/add", async (req, res) => {
+        const { code } = req.query;
+        const { content, metadata } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (!content || typeof content !== "string" || !content.trim()) {
+            res.status(400).json({ error: "content is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const id = await memoryManager.addMemory(sessionName, content.trim(), metadata ?? {});
+            res.status(201).json({ ok: true, id });
+        }
+        catch (err) {
+            console.error("POST /worker/memory/add error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.post("/worker/memory/search", async (req, res) => {
+        const { code } = req.query;
+        const { query, limit } = req.body;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        if (!query || typeof query !== "string" || !query.trim()) {
+            res.status(400).json({ error: "query is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const results = await memoryManager.searchMemories(sessionName, query.trim(), Math.min(limit ?? 10, 50));
+            res.json(results);
+        }
+        catch (err) {
+            console.error("POST /worker/memory/search error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.get("/worker/memory/list", async (req, res) => {
+        const { code, limit: limitStr } = req.query;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        const limit = Math.min(parseInt(limitStr ?? "50", 10), 200);
+        try {
+            const memories = memoryManager.listMemories(sessionName, limit);
+            const stats = memoryManager.getStats(sessionName);
+            res.json({ memories, total: stats.total });
+        }
+        catch (err) {
+            console.error("GET /worker/memory/list error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
+    router.delete("/worker/memory/:memoryId", async (req, res) => {
+        const { code } = req.query;
+        const { memoryId } = req.params;
+        if (!code || typeof code !== "string") {
+            res.status(400).json({ error: "code query parameter is required" });
+            return;
+        }
+        const session = await sql `
+      SELECT name FROM sessions WHERE agent_code = ${code}
+    `;
+        if (session.length === 0) {
+            res.status(401).json({ error: "Invalid agent code" });
+            return;
+        }
+        const sessionName = session[0].name;
+        try {
+            const deleted = memoryManager.deleteMemory(sessionName, memoryId);
+            if (!deleted) {
+                res.status(404).json({ error: "Memory not found" });
+                return;
+            }
+            res.json({ deleted: true, id: memoryId });
+        }
+        catch (err) {
+            console.error("DELETE /worker/memory/:memoryId error:", err);
+            res.status(500).json({ error: "Internal server error" });
+        }
+    });
     return router;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-office",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Manage OpenCode sessions with named aliases",
   "type": "module",
   "license": "MIT",
@@ -38,11 +38,13 @@
     "croner": "^10.0.1",
     "dotenv": "^16.0.0",
     "express": "^4.18.0",
+    "fastmemory": "^0.1.5",
     "ink": "^5.0.0",
     "postgres": "^3.4.0",
     "react": "^18.0.0"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^4.17.0",
     "@types/node": "^20.0.0",
     "@types/react": "^18.0.0",