chapterhouse 0.4.1 → 0.4.3

package/dist/copilot/tools.memory.test.js

@@ -194,6 +194,130 @@ test("memory_propose queues pending proposals, defaults scope from the active sc
     assert.equal(payload.reason, "The user explicitly asked for the new proposal path.");
     assert.equal(payload.payload.content, "Subagents can queue durable observations for orchestrator review.");
 });
+test("memory_propose accepts entity proposals with entity_kind and queues the full payload", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools, "task-entity-propose");
+    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
+    const proposed = await findTool(coderTools, "memory_propose").handler({
+        kind: "entity",
+        payload: {
+            name: "truenas",
+            entity_kind: "host",
+            summary: "NAS host used by Bellonda.",
+        },
+        confidence: 0.8,
+    }, {});
+    assert.equal(proposed.status, "queued");
+    const row = dbModule.getDb().prepare(`
+    SELECT payload
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(proposed.proposal_id);
+    assert.ok(row, "memory_propose should insert a mem_inbox row");
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.kind, "entity");
+    assert.equal(payload.scope_slug, "chapterhouse");
+    assert.deepEqual(payload.payload, {
+        name: "truenas",
+        entity_kind: "host",
+        summary: "NAS host used by Bellonda.",
+    });
+});
+test("action item memory tools add, list, complete, drop, and snooze action items", async () => {
+    const { toolsModule, agentsModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools);
+    const memoryAddActionItem = findTool(chapterhouseTools, "memory_add_action_item");
+    const memoryListActionItems = findTool(coderTools, "memory_list_action_items");
+    const memoryCompleteActionItem = findTool(chapterhouseTools, "memory_complete_action_item");
+    const memoryDropActionItem = findTool(chapterhouseTools, "memory_drop_action_item");
+    const memorySnoozeActionItem = findTool(chapterhouseTools, "memory_snooze_action_item");
+    const visibleToCoder = agentsModule.filterToolsForAgent({
+        slug: "coder",
+        name: "Coder",
+        description: "Software engineer",
+        model: "gpt-5.4",
+        systemMessage: "test",
+    }, tools);
+    assert.equal(visibleToCoder.some((tool) => tool.name === "memory_list_action_items"), true);
+    assert.equal(visibleToCoder.some((tool) => tool.name === "memory_add_action_item"), false);
+    const added = await memoryAddActionItem.handler({
+        scope: "chapterhouse",
+        title: "Migrate feature ideas",
+        detail: "Move the parked feature-ideas.md page into mem_action_items.",
+        due_at: "2026-05-15T12:00:00.000Z",
+        entity_name: "Chapterhouse",
+        entity_kind: "project",
+        source: "test",
+    }, {});
+    assert.equal(added.ok, true);
+    const addedId = added.id;
+    const listed = await memoryListActionItems.handler({ scope: "chapterhouse" }, {});
+    assert.equal((listed.action_items).some((item) => item.id === addedId), true);
+    const completed = await memoryCompleteActionItem.handler({ id: addedId, resolution_reason: "Done." }, {});
+    assert.equal(completed.ok, true);
+    assert.equal(completed.status, "done");
+    const afterComplete = await memoryListActionItems.handler({ scope: "chapterhouse" }, {});
+    assert.equal((afterComplete.action_items).some((item) => item.id === addedId), false);
+    const dropped = await memoryAddActionItem.handler({ scope: "chapterhouse", title: "Drop me" }, {});
+    const droppedResult = await memoryDropActionItem.handler({
+        id: dropped.id,
+        reason: "No longer needed.",
+    }, {});
+    assert.equal(droppedResult.status, "dropped");
+    const snoozed = await memoryAddActionItem.handler({ scope: "chapterhouse", title: "Snooze me" }, {});
+    const snoozedResult = await memorySnoozeActionItem.handler({
+        id: snoozed.id,
+        snooze_until: "2999-01-01T00:00:00.000Z",
+    }, {});
+    assert.equal(snoozedResult.status, "snoozed");
+});
+test("memory_propose accepts action_item proposals with a resolvable payload shape", async () => {
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const coderTools = bindToolsToAgent("coder", tools, "task-action-propose");
+    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
+    const proposed = await findTool(coderTools, "memory_propose").handler({
+        kind: "action_item",
+        payload: {
+            title: "Remind infra about high disk usage",
+            detail: "Next time disk exceeds 85%, notify Bellonda.",
+            due_at: "2026-05-15T12:00:00.000Z",
+            source: "test",
+        },
+        confidence: 0.8,
+    }, {});
+    assert.equal(proposed.status, "queued");
+    const row = dbModule.getDb().prepare(`
+    SELECT payload
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(proposed.proposal_id);
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.kind, "action_item");
+    assert.equal(payload.scope_slug, "chapterhouse");
+    assert.equal(payload.payload.title, "Remind infra about high disk usage");
+    assert.equal(payload.payload.detail, "Next time disk exceeds 85%, notify Bellonda.");
+});
 test("memory_propose rejects invalid proposal kinds", async () => {
     const { toolsModule } = await loadModules();
     const tools = toolsModule.createTools({
@@ -205,7 +329,7 @@ test("memory_propose rejects invalid proposal kinds", async () => {
         kind: "pattern",
         payload: { content: "invalid kind" },
     }, {});
-    assert.match(String(result), /observation|decision|entity/i);
+    assert.match(String(result), /observation|decision|entity|action_item/i);
 });
 test("memory_housekeep is orchestrator-only and returns housekeeping summaries", async () => {
     const { toolsModule, agentsModule, dbModule } = await loadModules();

package/dist/copilot/turn-event-log.js

@@ -20,7 +20,7 @@
  * @module copilot/turn-event-log
  */
 import { childLogger } from "../util/logger.js";
-import { getDb } from "../store/db.js";
+import { getCurrentRunId, getDb } from "../store/db.js";
 import { config } from "../config.js";
 import { RingBuffer } from "./ring-buffer.js";
 const log = childLogger("turn-event-log");
@@ -192,9 +192,9 @@ export function subscribeSession(sessionKey, listener, afterSeq) {
 function persistIndexedTurnEvent(sessionKey, event) {
     try {
         const db = getDb();
-        const stmt = db.prepare(`INSERT INTO turn_events (turn_id, session_key, seq, ts, event_type, payload)
-       VALUES (?, ?, ?, ?, ?, ?)`);
-        stmt.run(event.turnId, sessionKey, event._seq, event._ts, event.type, JSON.stringify(event));
+        const stmt = db.prepare(`INSERT INTO turn_events (turn_id, session_key, run_id, seq, ts, event_type, payload)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        stmt.run(event.turnId, sessionKey, getCurrentRunId(), event._seq, event._ts, event.type, JSON.stringify(event));
     }
     catch (err) {
         log.warn({ err: err instanceof Error ? err.message : err, turnId: event.turnId }, "turn-event-log: SQLite persist failed");
@@ -260,19 +260,24 @@ export function getTurnEventsFromDb(turnId, afterSeq = 0) {
         return [];
     }
 }
-/**
- * Return persisted events for a session from SQLite, after a given sequence number.
- * Used as SSE replay fallback when the session buffer doesn't cover the requested range.
- */
-export function getSessionEventsFromDb(sessionKey, afterSeq = 0) {
+export function getSessionEventsFromDb(sessionKey, afterSeq = 0, options = {}) {
     try {
         const db = getDb();
-        const rows = db
-            .prepare(`SELECT payload FROM turn_events
-          WHERE session_key = ? AND seq > ?
-          ORDER BY seq ASC
-          LIMIT ?`)
-            .all(sessionKey, afterSeq, SESSION_REPLAY_LIMIT);
+        const includeHistorical = options.includeHistorical ?? false;
+        const runId = options.runId ?? getCurrentRunId();
+        const rows = includeHistorical
+            ? db
+                .prepare(`SELECT payload FROM turn_events
+            WHERE session_key = ? AND seq > ?
+            ORDER BY id ASC
+            LIMIT ?`)
+                .all(sessionKey, afterSeq, SESSION_REPLAY_LIMIT)
+            : db
+                .prepare(`SELECT payload FROM turn_events
+            WHERE session_key = ? AND run_id = ? AND seq > ?
+            ORDER BY seq ASC
+            LIMIT ?`)
+                .all(sessionKey, runId, afterSeq, SESSION_REPLAY_LIMIT);
         return rows.map((r) => JSON.parse(r.payload));
     }
     catch (err) {
@@ -280,6 +285,21 @@ export function getSessionEventsFromDb(sessionKey, afterSeq = 0) {
         return [];
     }
 }
+export function getSessionMaxSeqFromDb(sessionKey, options = {}) {
+    try {
+        const db = getDb();
+        const includeHistorical = options.includeHistorical ?? false;
+        const runId = options.runId ?? getCurrentRunId();
+        const row = includeHistorical
+            ? db.prepare(`SELECT MAX(seq) AS max_seq FROM turn_events WHERE session_key = ?`).get(sessionKey)
+            : db.prepare(`SELECT MAX(seq) AS max_seq FROM turn_events WHERE session_key = ? AND run_id = ?`).get(sessionKey, runId);
+        return row?.max_seq ?? undefined;
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err, sessionKey }, "turn-event-log: SQLite session max-seq read failed");
+        return undefined;
+    }
+}
 // ---------------------------------------------------------------------------
 // Diagnostics
 // ---------------------------------------------------------------------------

package/dist/copilot/turn-event-log.test.js

@@ -119,6 +119,37 @@ describe("turn-event-log", () => {
             assert.equal(persisted[0].type, "turn:started");
             assert.equal(persisted[0].turnId, turnId);
         });
+        it("replays persisted session events from the current daemon run by default and can include historical runs", () => {
+            const session = freshSessionKey();
+            const db = getDb();
+            const columns = db.prepare("PRAGMA table_info(turn_events)").all();
+            if (!columns.some((column) => column.name === "run_id")) {
+                db.exec("ALTER TABLE turn_events ADD COLUMN run_id TEXT");
+            }
+            const insert = db.prepare(`INSERT INTO turn_events (turn_id, session_key, seq, ts, event_type, payload, run_id)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`);
+            const previous = {
+                type: "turn:complete",
+                turnId: "previous-turn",
+                sessionKey: session,
+                finalMessage: "previous",
+                _seq: 10,
+                _ts: 10,
+            };
+            const current = {
+                type: "turn:complete",
+                turnId: "current-turn",
+                sessionKey: session,
+                finalMessage: "current",
+                _seq: 11,
+                _ts: 11,
+            };
+            insert.run(previous.turnId, session, previous._seq, previous._ts, previous.type, JSON.stringify(previous), "previous-run");
+            insert.run(current.turnId, session, current._seq, current._ts, current.type, JSON.stringify(current), "current-run");
+            const getEvents = getSessionEventsFromDb;
+            assert.deepEqual(getEvents(session, 0, { runId: "current-run" }).map((event) => event.turnId), ["current-turn"]);
+            assert.deepEqual(getEvents(session, 0, { runId: "current-run", includeHistorical: true }).map((event) => event.turnId), ["previous-turn", "current-turn"]);
+        });
     });
     describe("subscribeTurn", () => {
         it("replays existing buffered events immediately on subscribe", () => {

package/dist/daemon.js

@@ -19,7 +19,9 @@ import { registerShutdownSignals } from "./shutdown-signals.js";
 import { logger } from "./util/logger.js";
 import { CHAPTERHOUSE_VERSION } from "./version.js";
 import { isWorkiqAutoInstallEnabled, ensureWorkiqMcpEntry } from "./copilot/workiq-installer.js";
+import { MemoryHousekeepingScheduler } from "./memory/housekeeping-scheduler.js";
 const log = logger.child({ module: "daemon" });
+let memoryHousekeepingScheduler;
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 /**
  * How long the daemon waits for in-flight work to finish before forcing an exit.
@@ -149,6 +151,8 @@ async function main() {
     });
     // Start HTTP API + serve the web UI
     await startApiServer();
+    memoryHousekeepingScheduler = new MemoryHousekeepingScheduler();
+    memoryHousekeepingScheduler.start();
     if (config.chapterhouseMode === "personal" && (config.adoPat || config.teamChapterhouseUrl)) {
         new StandupScheduler().schedule();
     }
@@ -202,6 +206,7 @@ async function shutdown() {
     forceTimer.unref();
     // Destroy all active agent sessions
     await shutdownAgents();
+    await memoryHousekeepingScheduler?.stop();
     try {
         stopEpisodeWriter();
     }
@@ -223,6 +228,7 @@ export async function restartDaemon() {
     }
     // Destroy all active agent sessions
     await shutdownAgents();
+    await memoryHousekeepingScheduler?.stop();
     try {
         stopEpisodeWriter();
     }

package/dist/memory/action-items.js

@@ -0,0 +1,100 @@
+import { getDb } from "../store/db.js";
+function toActionItem(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        title: row.title,
+        detail: row.detail ?? undefined,
+        status: row.status,
+        dueAt: row.due_at ?? undefined,
+        snoozeUntil: row.snooze_until ?? undefined,
+        source: row.source ?? undefined,
+        tier: row.tier,
+        tierPinnedAt: row.tier_pinned_at ?? undefined,
+        tierReason: row.tier_reason ?? undefined,
+        lastRecalledAt: row.last_recalled_at ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        resolvedAt: row.resolved_at ?? undefined,
+        resolutionReason: row.resolution_reason ?? undefined,
+    };
+}
+const ACTION_ITEM_COLUMNS = `
+  id, scope_id, entity_id, title, detail, status, due_at, snooze_until, source,
+  created_at, updated_at, resolved_at, resolution_reason, tier, tier_pinned_at,
+  tier_reason, last_recalled_at
+`;
+export function recordActionItem(input) {
+    const result = getDb().prepare(`
+    INSERT INTO mem_action_items (
+      scope_id, entity_id, title, detail, due_at, source, tier, created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.entity_id ?? null, input.title, input.detail ?? null, input.due_at ?? null, input.source ?? null, input.tier ?? "warm");
+    return getActionItem(Number(result.lastInsertRowid));
+}
+export function getActionItem(id) {
+    const row = getDb().prepare(`
+    SELECT ${ACTION_ITEM_COLUMNS}
+    FROM mem_action_items
+    WHERE id = ?
+  `).get(id);
+    return row ? toActionItem(row) : undefined;
+}
+export function listActionItems(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT ${ACTION_ITEM_COLUMNS}
+    FROM mem_action_items
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (
+        ? IS NOT NULL
+        OR status = 'open'
+        OR (status = 'snoozed' AND snooze_until IS NOT NULL AND datetime(snooze_until) <= datetime('now'))
+      )
+      AND (? IS NULL OR status = ?)
+      AND (? IS NULL OR due_at IS NOT NULL AND datetime(due_at) <= datetime(?))
+      AND (? = 1 OR tier != 'cold')
+    ORDER BY
+      CASE WHEN due_at IS NULL THEN 1 ELSE 0 END ASC,
+      datetime(due_at) ASC,
+      datetime(created_at) DESC,
+      id DESC
+    LIMIT ? OFFSET ?
+  `).all(input.scope_id ?? null, input.scope_id ?? null, input.status ?? null, input.status ?? null, input.status ?? null, input.due_before ?? null, input.due_before ?? null, input.includeArchived ? 1 : 0, input.limit ?? 50, input.offset ?? 0);
+    return rows.map(toActionItem);
+}
+function resolveActionItem(id, status, reason) {
+    const result = getDb().prepare(`
+    UPDATE mem_action_items
+    SET status = ?,
+      resolved_at = CURRENT_TIMESTAMP,
+      resolution_reason = ?,
+      updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(status, reason ?? null, id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown action item id '${id}'.`);
+    }
+    return getActionItem(id);
+}
+export function completeActionItem(id, resolutionReason) {
+    return resolveActionItem(id, "done", resolutionReason);
+}
+export function dropActionItem(id, reason) {
+    return resolveActionItem(id, "dropped", reason);
+}
+export function snoozeActionItem(id, snoozeUntil) {
+    const result = getDb().prepare(`
+    UPDATE mem_action_items
+    SET status = 'snoozed',
+      snooze_until = ?,
+      updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(snoozeUntil, id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown action item id '${id}'.`);
+    }
+    return getActionItem(id);
+}
+//# sourceMappingURL=action-items.js.map

package/dist/memory/action-items.test.js

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+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", `memory-action-items-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("action items round-trip through add, list, and complete with done hidden by default", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordActionItem = getFunction(memoryModule, "recordActionItem");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const completeActionItem = getFunction(memoryModule, "completeActionItem");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const added = recordActionItem({
+        scope_id: chapterhouse.id,
+        title: "Migrate feature ideas into memory",
+        detail: "Move feature-ideas.md into mem_action_items once the schema exists.",
+        due_at: "2026-05-15T12:00:00.000Z",
+        source: "test",
+    });
+    assert.equal(added.status, "open");
+    assert.equal(added.title, "Migrate feature ideas into memory");
+    assert.equal(added.detail, "Move feature-ideas.md into mem_action_items once the schema exists.");
+    assert.equal(added.dueAt, "2026-05-15T12:00:00.000Z");
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.id), [added.id]);
+    const completed = completeActionItem(added.id, "Migrated successfully.");
+    assert.equal(completed.status, "done");
+    assert.ok(completed.resolvedAt);
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.id), []);
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id, status: "done" }).map((item) => item.id), [added.id]);
+});
+test("snoozed action items are hidden by default until snooze_until passes", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordActionItem = getFunction(memoryModule, "recordActionItem");
+    const snoozeActionItem = getFunction(memoryModule, "snoozeActionItem");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const future = recordActionItem({ scope_id: chapterhouse.id, title: "Remind infra later", source: "test" });
+    const expired = recordActionItem({ scope_id: chapterhouse.id, title: "Reappears now", source: "test" });
+    assert.equal(snoozeActionItem(future.id, "2999-01-01T00:00:00.000Z").status, "snoozed");
+    assert.equal(snoozeActionItem(expired.id, "2000-01-01T00:00:00.000Z").status, "snoozed");
+    const defaults = listActionItems({ scope_id: chapterhouse.id });
+    assert.equal(defaults.some((item) => item.id === future.id), false);
+    assert.equal(defaults.some((item) => item.id === expired.id), true);
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id, status: "snoozed" }).map((item) => item.id).sort(), [
+        expired.id,
+        future.id,
+    ].sort());
+});
+//# sourceMappingURL=action-items.test.js.map

package/dist/memory/eot.js

@@ -5,6 +5,7 @@ import { recordDecision } from "./decisions.js";
 import { upsertEntity } from "./entities.js";
 import { listPendingMemoryProposalsForTask, resolveInboxItem } from "./inbox.js";
 import { recordObservation } from "./observations.js";
+import { recordActionItem } from "./action-items.js";
 import { getScope } from "./scopes.js";
 const log = childLogger("memory.eot");
 function isEndOfTaskHookEnabled() {
@@ -30,6 +31,8 @@ function buildReviewerSystemPrompt() {
         "Optionally extract additional implicit durable memories from the task summary.",
         "Return JSON only with keys: decisions, implicit_memories.",
         "Each decision must include proposal_id, decision, reason.",
+        "Supported kinds are observation, decision, entity, and action_item.",
+        "Entity payloads must include name and entity_kind.",
         "Each implicit memory must include kind, scope_slug, payload, and may include confidence/reason.",
     ].join("\n");
 }
@@ -48,7 +51,10 @@ function parseEnvelope(raw) {
     if (!parsed || typeof parsed !== "object") {
         throw new Error("Invalid memory proposal payload.");
     }
-    if (parsed.kind !== "observation" && parsed.kind !== "decision" && parsed.kind !== "entity") {
+    if (parsed.kind !== "observation"
+        && parsed.kind !== "decision"
+        && parsed.kind !== "entity"
+        && parsed.kind !== "action_item") {
         throw new Error("Invalid proposal kind.");
     }
     if (!parsed.payload || typeof parsed.payload !== "object") {
@@ -93,7 +99,10 @@ function parseReviewerResponse(raw) {
                     return [];
                 }
                 const candidate = entry;
-                if (candidate.kind !== "observation" && candidate.kind !== "decision" && candidate.kind !== "entity") {
+                if (candidate.kind !== "observation"
+                    && candidate.kind !== "decision"
+                    && candidate.kind !== "entity"
+                    && candidate.kind !== "action_item") {
                     return [];
                 }
                 if (typeof candidate.scope_slug !== "string" || !candidate.payload || typeof candidate.payload !== "object") {
@@ -136,10 +145,26 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
         });
         return;
     }
+    if (kind === "action_item") {
+        const actionItem = payload;
+        recordActionItem({
+            scope_id: scope.id,
+            entity_id: actionItem.entity_id,
+            title: actionItem.title,
+            detail: actionItem.detail,
+            due_at: actionItem.due_at,
+            source: actionItem.source ?? source,
+        });
+        return;
+    }
     const entity = payload;
+    const entityKind = entity.entity_kind ?? entity.kind;
+    if (!entityKind) {
+        throw new Error("Entity proposal payload requires entity_kind.");
+    }
     upsertEntity({
         scope_id: scope.id,
-        kind: entity.kind,
+        kind: entityKind,
         name: entity.name,
         summary: entity.summary,
         confidence,