chapterhouse 0.11.2 → 0.11.4

package/dist/api/routes/agents.js

@@ -268,10 +268,6 @@ export function createAgentsRouter(options) {
         res.setHeader("Connection", "keep-alive");
         res.setHeader("X-Accel-Buffering", "no");
         res.flushHeaders();
-        const rawLastId = req.headers["last-event-id"];
-        const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
-            ? parseInt(rawLastId.trim(), 10)
-            : undefined;
         const sendEvent = (event) => {
             let payload;
             if (event.kind === "output_delta") {
@@ -303,41 +299,48 @@ export function createAgentsRouter(options) {
             }
             res.write(`id: ${event.seq}\ndata: ${JSON.stringify(payload)}\n\n`);
         };
-        let replayHighSeq = lastSeq;
-        if (lastSeq !== undefined) {
-            const bufferedEvents = getTaskLogEvents(taskId);
-            const oldestBufferedSeq = bufferedEvents[0]?.seq;
-            const bufferMissesRange = oldestBufferedSeq === undefined || oldestBufferedSeq > lastSeq + 1;
-            if (bufferMissesRange) {
-                const dbEvents = getTaskEvents(taskId, lastSeq);
-                for (const event of dbEvents) {
-                    sendEvent(event);
-                    if (replayHighSeq === undefined || event.seq > replayHighSeq) {
-                        replayHighSeq = event.seq;
-                    }
-                }
-            }
-        }
-        const replayEvents = getTaskLogEvents(taskId, replayHighSeq ?? 0);
-        const backlog = replayEvents.length > 0 ? replayEvents : getTaskEvents(taskId, replayHighSeq ?? 0);
-        for (const event of backlog) {
-            sendEvent(event);
-        }
         const isTerminal = () => {
             const row = getDb()
                 .prepare(`SELECT status FROM agent_tasks WHERE task_id = ?`)
                 .get(taskId);
             return row ? TERMINAL_TASK_STATUSES.has(row.status) : true;
         };
-        res.write(`: connected task=${taskId}\n\n`);
-        if (isTerminal()) {
-            res.end();
-            return;
-        }
-        const heartbeat = setInterval(() => {
-            res.write(`: keep-alive\n\n`);
-        }, 15_000);
         setupSseCleanup((registerCleanup, cleanupNow) => {
+            req.on("close", cleanupNow);
+            res.on("close", cleanupNow);
+            res.on("error", cleanupNow);
+            const rawLastId = req.headers["last-event-id"];
+            const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
+                ? parseInt(rawLastId.trim(), 10)
+                : undefined;
+            let replayHighSeq = lastSeq;
+            if (lastSeq !== undefined) {
+                const bufferedEvents = getTaskLogEvents(taskId);
+                const oldestBufferedSeq = bufferedEvents[0]?.seq;
+                const bufferMissesRange = oldestBufferedSeq === undefined || oldestBufferedSeq > lastSeq + 1;
+                if (bufferMissesRange) {
+                    const dbEvents = getTaskEvents(taskId, lastSeq);
+                    for (const event of dbEvents) {
+                        sendEvent(event);
+                        if (replayHighSeq === undefined || event.seq > replayHighSeq) {
+                            replayHighSeq = event.seq;
+                        }
+                    }
+                }
+            }
+            const replayEvents = getTaskLogEvents(taskId, replayHighSeq ?? 0);
+            const backlog = replayEvents.length > 0 ? replayEvents : getTaskEvents(taskId, replayHighSeq ?? 0);
+            for (const event of backlog) {
+                sendEvent(event);
+            }
+            res.write(`: connected task=${taskId}\n\n`);
+            if (isTerminal()) {
+                res.end();
+                return;
+            }
+            const heartbeat = setInterval(() => {
+                res.write(`: keep-alive\n\n`);
+            }, 15_000);
             registerCleanup(() => clearInterval(heartbeat));
             registerCleanup(subscribeTaskLog(taskId, (event) => {
                 sendEvent(event);
@@ -359,7 +362,6 @@ export function createAgentsRouter(options) {
                     res.end();
                 }
             }));
-            req.on("close", cleanupNow);
         });
     });
     // ---------------------------------------------------------------------------
@@ -370,19 +372,21 @@ export function createAgentsRouter(options) {
     // Chat-specific events (delta, message, queued) are NOT emitted here.
     // ---------------------------------------------------------------------------
     router.get("/api/agents/stream", (req, res) => {
-        res.writeHead(200, {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-        });
-        res.write(formatSseData({ type: "connected" }));
-        const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
         setupSseCleanup((registerCleanup, cleanupNow) => {
+            req.on("close", cleanupNow);
+            res.on("close", cleanupNow);
+            res.on("error", cleanupNow);
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            res.write(formatSseData({ type: "connected" }));
+            const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
             registerCleanup(() => clearInterval(heartbeat));
             registerCleanup(agentEventBus.subscribeAll((event) => {
                 res.write(formatSseData({ type: "agent_event", agentEvent: event }));
             }));
-            req.on("close", cleanupNow);
         });
     });
     router.post("/api/agents/:slug/reload-confirm", async (req, res) => {

package/dist/api/routes/memory.js

@@ -1,6 +1,7 @@
 import { Router } from "express";
 import { z } from "zod";
 import { getActiveScope, setActiveScope } from "../../memory/active-scope.js";
+import { recordActionItem } from "../../memory/action-items.js";
 import { recordDecision } from "../../memory/decisions.js";
 import { upsertEntity } from "../../memory/entities.js";
 import { handleGitCommitHook, handlePrMergeHook } from "../../memory/hooks.js";
@@ -24,7 +25,8 @@ const setActiveScopeSchema = z.object({
     scope: z.string().nullable(),
 });
 const memoryEntriesQuerySchema = z.object({
-    store: z.enum(["observations", "decisions", "entities", "action_items"]).optional(),
+    store: z.enum(["observations", "decisions", "entities", "action_items", "patterns"]).optional(),
+    kind: z.enum(["observation", "decision", "entity", "action_item", "pattern"]).optional(),
     tier: z.enum(["hot", "warm", "cold"]).optional(),
     cursor: z.string().regex(/^\d+$/, "cursor must be a positive integer").optional(),
     limit: z.coerce.number().int().min(1).max(100).optional(),
@@ -43,6 +45,9 @@ const inboxRouteSchema = z.object({
     reason: z.string().optional(),
     target_scope: z.string().optional(),
 });
+const inboxRejectSchema = z.object({
+    reason: requiredString("Missing 'reason' in request body"),
+});
 const gitCommitHookSchema = z.object({
     message: requiredString("Missing 'message' in request body"),
     stat: z.string().optional(),
@@ -53,6 +58,130 @@ const prMergeHookSchema = z.object({
     body: z.string().optional(),
     files_changed: z.array(z.string()).optional(),
 });
+function sendError(res, status, message) {
+    res.status(status).type("application/json").send(JSON.stringify({ error: message }));
+}
+function scopeSlugForInboxItem(item) {
+    const envelope = JSON.parse(item.payload);
+    if (typeof envelope.scope_slug === "string" && envelope.scope_slug.trim()) {
+        return envelope.scope_slug;
+    }
+    if (item.scopeId) {
+        const scope = getScope(item.scopeId);
+        if (scope) {
+            return scope.slug;
+        }
+    }
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    const fallback = getScope("chapterhouse");
+    if (fallback) {
+        return fallback.slug;
+    }
+    throw new Error("No memory scope could be resolved for this proposal.");
+}
+function rememberAcceptedProposal(kind, scopeSlug, payload, source, confidence, sourceAgent) {
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
+    }
+    const payloadRecord = payload;
+    if (kind === "observation") {
+        const content = typeof payloadRecord.content === "string" ? payloadRecord.content.trim() : "";
+        if (!content) {
+            throw new Error("Observation proposal payload requires content.");
+        }
+        recordObservation({
+            scope_id: scope.id,
+            entity_id: typeof payloadRecord.entity_id === "number" ? payloadRecord.entity_id : undefined,
+            content,
+            source: typeof payloadRecord.source === "string" ? payloadRecord.source : source,
+            confidence,
+        });
+        return;
+    }
+    if (kind === "decision") {
+        const title = typeof payloadRecord.title === "string" ? payloadRecord.title.trim() : "";
+        if (!title) {
+            throw new Error("Decision proposal payload requires title.");
+        }
+        recordDecision({
+            scope_id: scope.id,
+            title,
+            rationale: typeof payloadRecord.rationale === "string" ? payloadRecord.rationale : title,
+            decided_at: typeof payloadRecord.decided_at === "string" ? payloadRecord.decided_at : undefined,
+        });
+        return;
+    }
+    if (kind === "action_item") {
+        const title = typeof payloadRecord.title === "string" ? payloadRecord.title.trim() : "";
+        if (!title) {
+            throw new Error("Action item proposal payload requires title.");
+        }
+        const entity = typeof payloadRecord.entity_name === "string" && typeof payloadRecord.entity_kind === "string"
+            ? upsertEntity({
+                scope_id: scope.id,
+                kind: payloadRecord.entity_kind,
+                name: payloadRecord.entity_name,
+                confidence,
+            })
+            : undefined;
+        recordActionItem({
+            scope_id: scope.id,
+            entity_id: entity?.id ?? (typeof payloadRecord.entity_id === "number" ? payloadRecord.entity_id : undefined),
+            title,
+            detail: typeof payloadRecord.detail === "string" ? payloadRecord.detail : undefined,
+            due_at: typeof payloadRecord.due_at === "string" ? payloadRecord.due_at : undefined,
+            source: sourceAgent ? `subagent_proposal:${sourceAgent}` : source,
+        });
+        return;
+    }
+    const entityKind = typeof payloadRecord.entity_kind === "string" ? payloadRecord.entity_kind :
+        typeof payloadRecord.kind === "string" ? payloadRecord.kind :
+            "";
+    const name = typeof payloadRecord.name === "string" ? payloadRecord.name.trim() : "";
+    if (!entityKind || !name) {
+        throw new Error("Entity proposal payload requires entity_kind and name.");
+    }
+    upsertEntity({
+        scope_id: scope.id,
+        kind: entityKind,
+        name,
+        summary: typeof payloadRecord.summary === "string" ? payloadRecord.summary : undefined,
+        confidence,
+    });
+}
+function acceptInboxItem(id) {
+    const item = getInboxItem(id);
+    if (!item) {
+        throw Object.assign(new Error(`Inbox item '${id}' not found`), { statusCode: 404 });
+    }
+    if (item.status !== "pending") {
+        throw Object.assign(new Error(`Inbox item '${id}' is already resolved`), { statusCode: 409 });
+    }
+    const envelope = JSON.parse(item.payload);
+    rememberAcceptedProposal(envelope.kind, scopeSlugForInboxItem(item), envelope.payload, `agent:${item.sourceAgent}`, envelope.confidence, item.sourceAgent);
+    resolveInboxItem(id, "accepted", "Accepted via web UI");
+}
+function rejectInboxItem(id, reason) {
+    const item = getInboxItem(id);
+    if (!item) {
+        throw Object.assign(new Error(`Inbox item '${id}' not found`), { statusCode: 404 });
+    }
+    if (item.status !== "pending") {
+        throw Object.assign(new Error(`Inbox item '${id}' is already resolved`), { statusCode: 409 });
+    }
+    resolveInboxItem(id, "rejected", reason);
+}
+function parseInboxId(raw) {
+    const id = Number(Array.isArray(raw) ? raw[0] : raw);
+    if (!Number.isInteger(id) || id <= 0) {
+        throw Object.assign(new Error("Invalid inbox item id"), { statusCode: 400 });
+    }
+    return id;
+}
 export function createMemoryRouter(options) {
     const { authMiddleware } = options;
     const router = Router();
@@ -74,7 +203,7 @@ export function createMemoryRouter(options) {
             sendJson(res, SetActiveScopeResponseSchema, { ok: true, scope: scope?.slug ?? null });
         }
         catch (err) {
-            res.status(404).json({ error: err instanceof Error ? err.message : String(err) });
+            sendError(res, 404, err instanceof Error ? err.message : String(err));
         }
     });
     router.get("/api/memory/scopes", (_req, res) => {
@@ -87,6 +216,7 @@ export function createMemoryRouter(options) {
                 decisions: db.prepare(`SELECT COUNT(*) AS count FROM mem_decisions WHERE scope_id = ?`).get(scope.id).count,
                 entities: db.prepare(`SELECT COUNT(*) AS count FROM mem_entities WHERE scope_id = ?`).get(scope.id).count,
                 action_items: db.prepare(`SELECT COUNT(*) AS count FROM mem_action_items WHERE scope_id = ?`).get(scope.id).count,
+                patterns: db.prepare(`SELECT COUNT(*) AS count FROM mem_patterns WHERE scope_id = ?`).get(scope.id).count,
             };
             return {
                 slug: scope.slug,
@@ -113,36 +243,69 @@ export function createMemoryRouter(options) {
         sendJson(res, MemoryInboxSchema, { items: result, total: result.length });
     });
     router.post("/api/memory/inbox/:id/route", (req, res) => {
-        const id = Number(req.params.id);
-        if (!Number.isInteger(id) || id <= 0) {
-            res.status(400).json({ error: "Invalid inbox item id" });
-            return;
-        }
+        const id = parseInboxId(req.params.id);
         const body = parseRequest(inboxRouteSchema, req.body ?? {});
         const item = getInboxItem(id);
         if (!item) {
-            res.status(404).json({ error: `Inbox item '${id}' not found` });
+            sendError(res, 404, `Inbox item '${id}' not found`);
             return;
         }
         if (item.status !== "pending") {
-            res.status(409).json({ error: `Inbox item '${id}' is already resolved` });
+            sendError(res, 409, `Inbox item '${id}' is already resolved`);
             return;
         }
-        const status = body.action === "accept" ? "accepted" : "rejected";
-        const reason = body.reason ?? (body.action === "accept" ? "Accepted via web UI" : "Rejected via web UI");
-        resolveInboxItem(id, status, reason);
+        if (body.action === "accept") {
+            acceptInboxItem(id);
+        }
+        else {
+            rejectInboxItem(id, body.reason ?? "Rejected via web UI");
+        }
         log.info({ id, action: body.action }, "inbox item routed via web UI");
         sendJson(res, InboxRouteResponseSchema, { ok: true });
     });
+    router.post("/api/memory/inbox/:id/accept", (req, res) => {
+        try {
+            const id = parseInboxId(req.params.id);
+            acceptInboxItem(id);
+            log.info({ id }, "inbox item accepted via web UI");
+            sendJson(res, InboxRouteResponseSchema, { ok: true });
+        }
+        catch (err) {
+            const statusCode = typeof err === "object" && err !== null && "statusCode" in err && typeof err.statusCode === "number"
+                ? err.statusCode
+                : 400;
+            sendError(res, statusCode, err instanceof Error ? err.message : String(err));
+        }
+    });
+    router.post("/api/memory/inbox/:id/reject", (req, res) => {
+        const body = parseRequest(inboxRejectSchema, req.body ?? {});
+        try {
+            const id = parseInboxId(req.params.id);
+            rejectInboxItem(id, body.reason);
+            log.info({ id }, "inbox item rejected via web UI");
+            sendJson(res, InboxRouteResponseSchema, { ok: true });
+        }
+        catch (err) {
+            const statusCode = typeof err === "object" && err !== null && "statusCode" in err && typeof err.statusCode === "number"
+                ? err.statusCode
+                : 400;
+            sendError(res, statusCode, err instanceof Error ? err.message : String(err));
+        }
+    });
     router.get("/api/memory/:scope", (req, res) => {
         const scopeSlug = String(req.params.scope);
         const scope = getScope(scopeSlug);
         if (!scope) {
-            res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+            sendError(res, 404, `Memory scope '${scopeSlug}' not found`);
             return;
         }
         const query = parseRequest(memoryEntriesQuerySchema, req.query);
-        const store = query.store ?? "observations";
+        const store = query.store ?? (query.kind === "observation" ? "observations" :
+            query.kind === "decision" ? "decisions" :
+                query.kind === "entity" ? "entities" :
+                    query.kind === "action_item" ? "action_items" :
+                        query.kind === "pattern" ? "patterns" :
+                            "observations");
         const tier = query.tier;
         const cursor = query.cursor ? Number(query.cursor) : undefined;
         const limit = query.limit ?? 100;
@@ -189,7 +352,7 @@ export function createMemoryRouter(options) {
                 total = db.prepare(`SELECT COUNT(*) AS n FROM mem_entities WHERE scope_id = ?`).get(scope.id).n;
             }
         }
-        else {
+        else if (store === "action_items") {
             const cursorClause = cursor ? "AND id < ?" : "";
             const params = tier ? [scope.id, tier] : [scope.id];
             const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
@@ -202,6 +365,19 @@ export function createMemoryRouter(options) {
                 total = db.prepare(`SELECT COUNT(*) AS n FROM mem_action_items WHERE scope_id = ?`).get(scope.id).n;
             }
         }
+        else {
+            const cursorClause = cursor ? "AND id < ?" : "";
+            const params = tier ? [scope.id, tier] : [scope.id];
+            const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
+            if (tier) {
+                entries = db.prepare(`SELECT id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated FROM mem_patterns WHERE scope_id = ? AND tier = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_patterns WHERE scope_id = ? AND tier = ?`).get(scope.id, tier).n;
+            }
+            else {
+                entries = db.prepare(`SELECT id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated FROM mem_patterns WHERE scope_id = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_patterns WHERE scope_id = ?`).get(scope.id).n;
+            }
+        }
         if (entries.length > limit) {
             const extra = entries.pop();
             const last = entries[entries.length - 1];
@@ -213,12 +389,12 @@ export function createMemoryRouter(options) {
         const scopeSlug = String(req.params.scope);
         const scope = getScope(scopeSlug);
         if (!scope) {
-            res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+            sendError(res, 404, `Memory scope '${scopeSlug}' not found`);
             return;
         }
         const body = parseRequest(memoryRememberSchema, req.body ?? {});
         if (body.entity_name && !body.entity_kind) {
-            res.status(400).json({ error: "entity_kind is required when entity_name is provided" });
+            sendError(res, 400, "entity_kind is required when entity_name is provided");
             return;
         }
         const kind = body.kind ?? "observation";
@@ -232,7 +408,7 @@ export function createMemoryRouter(options) {
             : undefined;
         if (kind === "decision") {
             if (!body.title) {
-                res.status(400).json({ error: "title is required when kind='decision'" });
+                sendError(res, 400, "title is required when kind='decision'");
                 return;
             }
             const decision = recordDecision({
@@ -277,7 +453,7 @@ export function createMemoryRouter(options) {
     router.post("/api/scopes", (req, res) => {
         const body = parseRequest(scopeCreateSchema, req.body ?? {});
         if (getScope(body.slug)) {
-            res.status(409).json({ error: `Memory scope '${body.slug}' already exists` });
+            sendError(res, 409, `Memory scope '${body.slug}' already exists`);
             return;
         }
         const scope = createScope({

package/dist/api/routes/memory.test.js

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import express from "express";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `api-memory-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function withMemoryApi(run) {
+    const { createMemoryRouter } = await import(new URL(`./memory.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const authMiddleware = (_req, _res, next) => next();
+    const app = express();
+    app.use(express.json());
+    app.use(createMemoryRouter({ authMiddleware }));
+    const server = app.listen(0, "127.0.0.1");
+    await new Promise((resolve) => server.once("listening", resolve));
+    const address = server.address();
+    assert.ok(address && typeof address === "object");
+    try {
+        await run(`http://127.0.0.1:${address.port}`);
+    }
+    finally {
+        await new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+        });
+    }
+}
+async function loadDbModule() {
+    return await import(new URL(`../../store/db.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test.beforeEach(async () => {
+    const dbModule = await loadDbModule();
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(sandboxRoot, { recursive: true });
+});
+test.after(async () => {
+    const dbModule = await loadDbModule();
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("memory API lists pattern entries and accepts PRD kind filters", async () => {
+    const { getDb } = await loadDbModule();
+    const db = getDb();
+    const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
+    db.prepare(`
+    INSERT INTO mem_entities (scope_id, kind, name, summary, tier, created_at, updated_at)
+    VALUES (?, 'project', 'Memory API Test Entity', 'Team AI assistant', 'hot', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(scope.id);
+    db.prepare(`
+    INSERT INTO mem_patterns (scope_id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated)
+    VALUES (?, 'Agents prefer scoped memory', 'Repeated observations show agents should stay scoped.', '[1,2,3]', 0.82, 'warm', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(scope.id);
+    await withMemoryApi(async (baseUrl) => {
+        const entityResponse = await fetch(`${baseUrl}/api/memory/chapterhouse?kind=entity&tier=hot`);
+        assert.equal(entityResponse.status, 200);
+        const entityPayload = await entityResponse.json();
+        assert.equal(entityPayload.total, 1);
+        assert.equal(entityPayload.entries[0]?.name, "Memory API Test Entity");
+        const patternResponse = await fetch(`${baseUrl}/api/memory/chapterhouse?kind=pattern`);
+        assert.equal(patternResponse.status, 200);
+        const patternPayload = await patternResponse.json();
+        assert.equal(patternPayload.total, 1);
+        assert.equal(patternPayload.entries[0]?.title, "Agents prefer scoped memory");
+        assert.equal(patternPayload.entries[0]?.summary, "Repeated observations show agents should stay scoped.");
+    });
+});
+test("memory API accepts and rejects inbox proposals through explicit endpoints", async () => {
+    const { getDb } = await loadDbModule();
+    const db = getDb();
+    const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
+    const first = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, status, created_at)
+    VALUES (?, 'memory_proposal', '{"kind":"observation","payload":{"content":"keep"}}', 'coder', 'pending', CURRENT_TIMESTAMP)
+  `).run(scope.id).lastInsertRowid;
+    const second = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, status, created_at)
+    VALUES (?, 'memory_proposal', '{"kind":"observation","payload":{"content":"drop"}}', 'coder', 'pending', CURRENT_TIMESTAMP)
+  `).run(scope.id).lastInsertRowid;
+    await withMemoryApi(async (baseUrl) => {
+        const acceptResponse = await fetch(`${baseUrl}/api/memory/inbox/${first}/accept`, { method: "POST" });
+        assert.equal(acceptResponse.status, 200);
+        assert.deepEqual(await acceptResponse.json(), { ok: true });
+        const rejectResponse = await fetch(`${baseUrl}/api/memory/inbox/${second}/reject`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ reason: "Not durable enough" }),
+        });
+        assert.equal(rejectResponse.status, 200);
+        assert.deepEqual(await rejectResponse.json(), { ok: true });
+    });
+    const rows = db.prepare(`
+    SELECT id, status, resolution_reason
+    FROM mem_inbox
+    ORDER BY id
+  `).all();
+    const acceptedObservation = db.prepare(`
+    SELECT content, source
+    FROM mem_observations
+    WHERE content = 'keep'
+  `).get();
+    assert.deepEqual(rows, [
+        { id: Number(first), status: "accepted", resolution_reason: "Accepted via web UI" },
+        { id: Number(second), status: "rejected", resolution_reason: "Not durable enough" },
+    ]);
+    assert.deepEqual(acceptedObservation, { content: "keep", source: "agent:coder" });
+});
+//# sourceMappingURL=memory.test.js.map