chapterhouse 0.4.1 → 0.4.3

package/dist/api/server.js

@@ -23,9 +23,9 @@ import { withWikiWrite } from "../wiki/lock.js";
 import { listSkills, removeSkill } from "../copilot/skills.js";
 import { restartDaemon } from "../daemon.js";
 import { API_TOKEN_PATH } from "../paths.js";
-import { getDb, getSessionMessages, getTaskEvents } from "../store/db.js";
+import { getCurrentRunId, getDb, getSessionMessages, getTaskEvents } from "../store/db.js";
 import { getTaskLogEvents, subscribeTaskLog } from "../copilot/task-event-log.js";
-import { subscribeSession, getSessionEventsFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
+import { subscribeSession, getSessionEventsFromDb, getSessionMaxSeqFromDb, oldestSessionSeq, } from "../copilot/turn-event-log.js";
 import { getStatus, onStatusChange } from "../status.js";
 import { formatSseData, formatSseEvent } from "./sse.js";
 import { assertAuthenticationConfigured, createHealthPayload, createPublicConfigPayload, getDisplayHost, resolveApiToken, shouldServeSpaPath, } from "./server-runtime.js";
@@ -728,6 +728,7 @@ if (config.chatSseEnabled) {
         const sessionKey = Array.isArray(req.params.key) ? req.params.key[0] : req.params.key;
         if (!sessionKey)
             throw new BadRequestError("Missing session key");
+        const includeHistorical = req.query.include === "all";
         res.setHeader("Content-Type", "text/event-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.setHeader("Connection", "keep-alive");
@@ -738,6 +739,10 @@ if (config.chatSseEnabled) {
         const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
             ? parseInt(rawLastId.trim(), 10)
             : undefined;
+        const maxCurrentSeq = getSessionMaxSeqFromDb(sessionKey, { includeHistorical });
+        const effectiveLastSeq = maxCurrentSeq !== undefined && lastSeq !== undefined && lastSeq > maxCurrentSeq
+            ? 0
+            : lastSeq;
         // Helper: send a named SSE event with an id: field
         const sendEvent = (event, seq) => {
             const payload = JSON.stringify(event);
@@ -745,13 +750,13 @@ if (config.chatSseEnabled) {
         };
         // If Last-Event-ID is present and the session ring buffer doesn't cover it,
         // fall back to SQLite for replay of completed turns.
-        let replayHighSeq = lastSeq;
-        if (lastSeq !== undefined) {
+        let replayHighSeq = effectiveLastSeq;
+        if (effectiveLastSeq !== undefined) {
             const oldestBuf = oldestSessionSeq(sessionKey);
-            const bufferMissesRange = oldestBuf === undefined || oldestBuf > lastSeq + 1;
+            const bufferMissesRange = oldestBuf === undefined || oldestBuf > effectiveLastSeq + 1;
             if (bufferMissesRange) {
                 // Replay from SQLite (completed turns)
-                const dbEvents = getSessionEventsFromDb(sessionKey, lastSeq);
+                const dbEvents = getSessionEventsFromDb(sessionKey, effectiveLastSeq, { includeHistorical });
                 for (const e of dbEvents) {
                     sendEvent(e, e._seq);
                     if (replayHighSeq === undefined || e._seq > replayHighSeq)
@@ -766,7 +771,7 @@ if (config.chatSseEnabled) {
             sendEvent(e, e._seq);
         }, replayHighSeq);
         // Send connected event
-        res.write(`: connected session=${sessionKey}\n\n`);
+        res.write(`: connected session=${sessionKey} run=${getCurrentRunId()}\n\n`);
         // Keep-alive every 15 s
         const keepAlive = setInterval(() => {
             res.write(`: keep-alive\n\n`);
@@ -1063,7 +1068,8 @@ app.get("/api/session/:sessionKey/messages", (req, res) => {
     if (limit !== undefined && (!Number.isFinite(limit) || limit < 1)) {
         throw new BadRequestError("'limit' must be a positive integer");
     }
-    const messages = getSessionMessages(sessionKey, limit);
+    const includeHistorical = req.query.include === "all";
+    const messages = getSessionMessages(sessionKey, limit, { includeHistorical });
     res.json({ sessionKey, messages });
 });
 app.use(apiNotFoundHandler);

package/dist/api/server.test.js

@@ -371,6 +371,36 @@ test("server worker detail returns the stored dispatched prompt", async () => {
         assert.equal(body.completedAt, null);
     });
 });
+test("server session message hydration returns current run by default and include=all returns history", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
+        const db = new Database(join(testRoot, ".chapterhouse", "chapterhouse.db"));
+        try {
+            const currentRun = db.prepare(`SELECT run_id FROM daemon_runs LIMIT 1`).get();
+            db.prepare(`INSERT INTO conversation_log (role, content, source, session_key, run_id)
+         VALUES ('user', ?, 'web', 'hydration-session', ?)`).run("previous run", "previous-run");
+            db.prepare(`INSERT INTO conversation_log (role, content, source, session_key, run_id)
+         VALUES ('assistant', ?, 'web', 'hydration-session', ?)`).run("current run", currentRun.run_id);
+        }
+        finally {
+            db.close();
+        }
+        const currentOnly = await fetch(`${baseUrl}/api/session/hydration-session/messages`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(currentOnly.status, 200);
+        assert.deepEqual((await currentOnly.json()).messages.map((message) => message.content), [
+            "current run",
+        ]);
+        const allRuns = await fetch(`${baseUrl}/api/session/hydration-session/messages?include=all`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(allRuns.status, 200);
+        assert.deepEqual((await allRuns.json()).messages.map((message) => message.content), [
+            "previous run",
+            "current run",
+        ]);
+    });
+});
 test("server wiki route synthesizes a welcome page when pages/index.md is missing", async () => {
     await withStartedServer(async ({ baseUrl, authHeader, testRoot }) => {
         rmSync(join(testRoot, ".chapterhouse", "wiki", "pages", "index.md"), { force: true });

package/dist/copilot/agents.js

@@ -227,7 +227,7 @@ function getAgentBasePrompt() {
 You are an agent within Chapterhouse, a team-level AI assistant for engineering teams. You run on the user's local machine.
 
 ### Agent Memory
-Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, and a named system/tool/person can be proposed as an \`entity\`.
+Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\` and \`memory_list_action_items\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, a named system/tool/person can be proposed as an \`entity\`, and a reminder/follow-up can be proposed as an \`action_item\`.
 
 ### Shared Wiki
 All agents share a wiki knowledge base for persistent memory. Use \`wiki_read\` and \`wiki_search\` to find existing knowledge, and \`wiki_update\` to save important findings.
@@ -275,7 +275,7 @@ export function buildAgentRoster() {
 const WIKI_TOOL_NAMES = new Set([
     "wiki_search", "wiki_read", "wiki_update", "remember", "recall", "forget",
     "wiki_ingest", "wiki_lint", "wiki_rebuild_index",
-    "memory_recall", "memory_propose",
+    "memory_recall", "memory_propose", "memory_list_action_items",
 ]);
 // Management tools that only @chapterhouse should have
 const MANAGEMENT_TOOL_NAMES = new Set([
@@ -285,6 +285,7 @@ const MANAGEMENT_TOOL_NAMES = new Set([
     "restart_chapterhouse", "list_skills", "learn_skill", "uninstall_skill",
     "list_machine_sessions", "attach_machine_session",
     "memory_remember", "memory_set_scope", "memory_housekeep", "memory_promote", "memory_demote",
+    "memory_add_action_item", "memory_complete_action_item", "memory_drop_action_item", "memory_snooze_action_item",
 ]);
 export function getCurrentToolAgentSlug() {
     return toolAgentContext.getStore();

package/dist/copilot/orchestrator.js

@@ -380,13 +380,49 @@ export function feedAgentResult(taskId, agentSlug, result) {
             log.error({ err: error, taskId }, "memory.eot.error");
         });
     }
-    const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}:\n\n${result}`;
-    const sessionKey = getTaskSessionKey(taskId);
+    const sessionKey = getTaskSessionKey(taskId) || "default";
+    const agentTurnId = randomUUID();
+    const agentDisplayName = getAgentRegistry().find((agent) => agent.slug === agentSlug)?.name ?? agentSlug;
+    try {
+        emitTurnEvent(sessionKey, {
+            type: "turn:started",
+            turnId: agentTurnId,
+            sessionKey,
+            prompt: "",
+            agentSlug,
+            agentDisplayName,
+        });
+        const chunkSize = 500;
+        const chunks = result.length === 0 ? [""] : Array.from({ length: Math.ceil(result.length / chunkSize) }, (_, index) => result.slice(index * chunkSize, (index + 1) * chunkSize));
+        for (const chunk of chunks) {
+            emitTurnEvent(sessionKey, {
+                type: "turn:delta",
+                turnId: agentTurnId,
+                sessionKey,
+                part: { type: "text", text: chunk },
+            });
+        }
+        finalizeTurnEvent(sessionKey, { type: "turn:complete", turnId: agentTurnId, finalMessage: result });
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err, taskId, agentSlug }, "Failed to emit synthetic agent reply turn");
+    }
+    try {
+        logConversation("agent_completion", result, "background", sessionKey, {
+            agentSlug,
+            agentDisplayName,
+            turnId: agentTurnId,
+        });
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err, taskId, agentSlug }, "Failed to persist agent completion");
+    }
+    const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}. Their reply has been shown to the user. Acknowledge briefly.`;
     sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
         if (done && proactiveNotifyFn) {
             proactiveNotifyFn(text);
         }
-    });
+    }, undefined, undefined, undefined, undefined, undefined, { suppressPromptLog: true });
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -1034,7 +1070,7 @@ function isRecoverableError(err) {
         return false;
     return /disconnect|connection|EPIPE|ECONNRESET|ECONNREFUSED|socket|closed|ENOENT|spawn|not found|expired|stale/i.test(msg);
 }
-export async function sendToOrchestrator(prompt, source, callback, attachments, onActivity, onQueued, onAdvance, externalTurnId) {
+export async function sendToOrchestrator(prompt, source, callback, attachments, onActivity, onQueued, onAdvance, externalTurnId, options) {
     updateUserContext(source);
     updateRequestContext(source);
     // Use the externally-supplied turnId if provided (POST→SSE path needs the ID
@@ -1103,12 +1139,14 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     logMessage("out", sourceLabel, finalContent);
                 }
                 catch { /* best-effort */ }
-                try {
-                    logConversation(logRole, prompt, sourceLabel, sessionKey);
+                if (!options?.suppressPromptLog) {
+                    try {
+                        logConversation(logRole, prompt, sourceLabel, sessionKey, { turnId });
+                    }
+                    catch { /* best-effort */ }
                 }
-                catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey);
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
@@ -1205,11 +1243,11 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("user", newPrompt, sourceLabel, sessionKey);
+                    logConversation("user", newPrompt, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey);
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);

package/dist/copilot/orchestrator.test.js

@@ -249,8 +249,14 @@ async function loadOrchestratorModule(t, overrides = {}) {
     });
     t.mock.module("../store/db.js", {
         namedExports: {
-            logConversation: (role, content, source) => {
-                state.dbLogs.push({ role, content, source });
+            logConversation: (role, content, source, sessionKey, metadata) => {
+                state.dbLogs.push({
+                    role,
+                    content,
+                    source,
+                    ...(sessionKey && sessionKey !== "default" ? { sessionKey } : {}),
+                    ...metadata,
+                });
             },
             getState: (key) => state.store.get(key),
             setState: (key, value) => {
@@ -559,9 +565,11 @@ test("sendToOrchestrator logs both sides, remembers web auth context, and record
         { direction: "in", source: "web", text: "Summarize the deployment" },
         { direction: "out", source: "web", text: "All green" },
     ]);
+    const loggedTurnId = state.dbLogs[0]?.turnId;
+    assert.equal(typeof loggedTurnId, "string");
     assert.deepEqual(state.dbLogs, [
-        { role: "user", content: "Summarize the deployment", source: "web" },
-        { role: "assistant", content: "All green", source: "web" },
+        { role: "user", content: "Summarize the deployment", source: "web", turnId: loggedTurnId },
+        { role: "assistant", content: "All green", source: "web", turnId: loggedTurnId },
     ]);
     assert.equal(state.episodeWrites, 1);
 });
@@ -999,7 +1007,7 @@ test("@mentions route through the orchestrator session without invoking the mode
     assert.deepEqual(state.routerArgs, []);
     assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] polish the landing page" }]);
 });
-test("feedAgentResult injects a background completion turn and proactively notifies listeners", async (t) => {
+test("feedAgentResult emits an attributed agent reply turn and sends only a short orchestrator prompt", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
             copilotModel: "claude-sonnet-4.6",
@@ -1016,25 +1024,62 @@ test("feedAgentResult injects a background completion turn and proactively notif
     orchestrator.feedAgentResult("task-9", "coder", "Fixed the flaky test");
     assert.equal(await notified, "Agent complete");
     assert.deepEqual(state.sessionPrompts, [{
-            prompt: "[Agent task completed] @coder finished task task-9:\n\nFixed the flaky test",
+            prompt: "[Agent task completed] @coder finished task task-9. Their reply has been shown to the user. Acknowledge briefly.",
         }]);
+    assert.equal(state.sessionPrompts[0]?.prompt.includes("Fixed the flaky test"), false, "orchestrator notification must not include the full agent reply body");
+    const started = events.filter((event) => event.type === "turn:started");
+    const deltas = events.filter((event) => event.type === "turn:delta");
+    const completed = events.filter((event) => event.type === "turn:complete");
+    assert.equal(started.length, 2, "agent reply plus orchestrator acknowledgement should each emit turn:started");
+    assert.equal(deltas.length, 1, "agent reply should stream as one or more deltas");
+    assert.equal(completed.length, 2, "agent reply plus orchestrator acknowledgement should each emit turn:complete");
+    assert.equal(started[0]?.agentSlug, "coder");
+    assert.equal(started[0]?.agentDisplayName, "Kaylee");
+    assert.equal(started[0]?.prompt, "");
     assert.deepEqual(state.dbLogs, [
         {
             role: "agent_completion",
-            content: "[Agent task completed] @coder finished task task-9:\n\nFixed the flaky test",
+            content: "Fixed the flaky test",
             source: "background",
+            sessionKey: "chat:bg-lifecycle",
+            agentSlug: "coder",
+            agentDisplayName: "Kaylee",
+            turnId: started[0]?.turnId,
         },
         {
             role: "assistant",
             content: "Agent complete",
             source: "background",
+            sessionKey: "chat:bg-lifecycle",
+            turnId: started[1]?.turnId,
         },
     ]);
-    const started = events.filter((event) => event.type === "turn:started");
-    const completed = events.filter((event) => event.type === "turn:complete");
-    assert.equal(started.length, 1, "background turn should emit one turn:started event");
-    assert.equal(completed.length, 1, "background turn should emit one turn:complete event");
-    assert.equal(started[0]?.turnId, completed[0]?.turnId, "background lifecycle events must share the same turnId");
+    assert.equal(deltas[0]?.turnId, started[0]?.turnId);
+    assert.deepEqual(deltas[0]?.part, { type: "text", text: "Fixed the flaky test" });
+    assert.equal(completed[0]?.turnId, started[0]?.turnId);
+    assert.equal(completed[0]?.finalMessage, "Fixed the flaky test");
+    assert.notEqual(started[0]?.turnId, started[1]?.turnId, "agent reply and orchestrator acknowledgement need distinct turns");
+});
+test("feedAgentResult emits a delta even when the agent result is empty", async (t) => {
+    const { orchestrator, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: true },
+        sendResult: "Acknowledged",
+        taskSessionKeys: new Map([["task-empty", "chat:bg-empty"]]),
+    });
+    await orchestrator.initOrchestrator(client);
+    const events = captureSessionEvents(t, "chat:bg-empty");
+    const notified = new Promise((resolve) => {
+        orchestrator.setProactiveNotify(resolve);
+    });
+    orchestrator.feedAgentResult("task-empty", "coder", "");
+    assert.equal(await notified, "Acknowledged");
+    const agentStarted = events.find((event) => event.type === "turn:started" && event.agentSlug === "coder");
+    assert.ok(agentStarted, "agent reply should emit a started event");
+    const deltas = events
+        .filter((event) => event.type === "turn:delta")
+        .filter((event) => event.turnId === agentStarted.turnId);
+    assert.equal(deltas.length, 1);
+    assert.deepEqual(deltas[0]?.part, { type: "text", text: "" });
 });
 test("enqueueForSse emits exactly one turn lifecycle pair for sse-web turns", async (t) => {
     const { orchestrator, client } = await loadOrchestratorModule(t, {
@@ -1227,11 +1272,11 @@ test("feedAgentResult routes to a non-default session when the task's session_ke
     // A second createSession call proves the orchestrator opened a fresh non-default session
     // rather than reusing the already-open default session.
     assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "feedAgentResult should spin up a non-default session, not recycle the default one");
-    // The prompt must reference the task and agent
+    // The prompt must reference the task and agent but not include the full reply body.
     const prompt = state.sessionPrompts.at(-1);
     assert.ok(prompt?.prompt.includes("chat-task-1"), "prompt should reference the task id");
     assert.ok(prompt?.prompt.includes("coder"), "prompt should reference the agent slug");
-    assert.ok(prompt?.prompt.includes("Feature done"), "prompt should include the result text");
+    assert.equal(prompt?.prompt.includes("Feature done"), false, "prompt should not include the result text");
 });
 test("ensureOrchestratorSession cleans up in-flight promise on session creation failure", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {

package/dist/copilot/tools.js

@@ -29,7 +29,7 @@ import { TeamsNotifier } from "../integrations/teams-notify.js";
 import { TeamPushClient } from "../integrations/team-push.js";
 import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
 import { childLogger } from "../util/logger.js";
-import { getActiveScope as getMemoryActiveScope, getScope as getMemoryScope, inferScopeFromText, demoteToCold, demoteToWarm, queueMemoryProposal, recall as recallMemory, recordDecision, recordObservation, runHousekeeping, setActiveScope as setMemoryActiveScope, promoteToHot, upsertEntity, } from "../memory/index.js";
+import { getActiveScope as getMemoryActiveScope, getScope as getMemoryScope, inferScopeFromText, completeActionItem, demoteToCold, demoteToWarm, dropActionItem, queueMemoryProposal, recall as recallMemory, listActionItems, recordDecision, recordActionItem, recordObservation, runHousekeeping, setActiveScope as setMemoryActiveScope, snoozeActionItem, promoteToHot, upsertEntity, } from "../memory/index.js";
 const log = childLogger("tools");
 /** Escape a string for safe inclusion as a single-line YAML scalar value. */
 function yamlEscape(value) {
@@ -106,11 +106,31 @@ const decisionProposalPayloadSchema = z.object({
 });
 const entityProposalPayloadSchema = z.object({
     name: z.string(),
-    kind: z.string(),
+    entity_kind: z.string().optional(),
+    kind: z.string().optional(),
     summary: z.string().optional(),
+}).superRefine((value, context) => {
+    if (!value.entity_kind && !value.kind) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "entity_kind is required for entity proposals.",
+            path: ["entity_kind"],
+        });
+    }
+}).transform((value) => ({
+    name: value.name,
+    entity_kind: value.entity_kind ?? value.kind,
+    summary: value.summary,
+}));
+const actionItemProposalPayloadSchema = z.object({
+    title: z.string(),
+    detail: z.string().optional(),
+    due_at: z.string().optional(),
+    source: z.string().optional(),
+    entity_id: z.number().int().positive().optional(),
 });
 const memoryProposeArgsSchema = z.object({
-    kind: z.enum(["observation", "decision", "entity"]),
+    kind: z.enum(["observation", "decision", "entity", "action_item"]),
     scope_slug: z.string().optional(),
     payload: z.record(z.string(), z.unknown()),
     confidence: z.number().min(0).max(1).optional(),
@@ -120,7 +140,9 @@ const memoryProposeArgsSchema = z.object({
         ? observationProposalPayloadSchema
         : value.kind === "decision"
             ? decisionProposalPayloadSchema
-            : entityProposalPayloadSchema;
+            : value.kind === "entity"
+                ? entityProposalPayloadSchema
+                : actionItemProposalPayloadSchema;
     const parsed = schema.safeParse(value.payload);
     if (!parsed.success) {
         for (const issue of parsed.error.issues) {
@@ -132,7 +154,7 @@ const memoryProposeArgsSchema = z.object({
         }
     }
 });
-const memoryTierTableSchema = z.enum(["observation", "decision", "entity"]);
+const memoryTierTableSchema = z.enum(["observation", "decision", "entity", "action_item"]);
 function getCurrentQuarter(now = new Date()) {
     return `${now.getUTCFullYear()}-Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
 }
@@ -849,7 +871,9 @@ export function createTools(deps) {
                         ? observationProposalPayloadSchema.parse(parsedArgs.payload)
                         : parsedArgs.kind === "decision"
                             ? decisionProposalPayloadSchema.parse(parsedArgs.payload)
-                            : entityProposalPayloadSchema.parse(parsedArgs.payload);
+                            : parsedArgs.kind === "entity"
+                                ? entityProposalPayloadSchema.parse(parsedArgs.payload)
+                                : actionItemProposalPayloadSchema.parse(parsedArgs.payload);
                     const proposal = queueMemoryProposal({
                         kind: parsedArgs.kind,
                         scopeSlug: parsedArgs.scope_slug,
@@ -872,12 +896,164 @@ export function createTools(deps) {
                 }
             },
         }),
+        defineTool("memory_add_action_item", {
+            description: "Add a scoped memory action item/reminder. Orchestrator-only write tool for follow-ups and proactive reminders.",
+            parameters: z.object({
+                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope, then keyword inference."),
+                title: z.string().min(1).describe("Short action item title."),
+                detail: z.string().optional().describe("Longer action item detail."),
+                due_at: z.string().optional().describe("Optional ISO due timestamp."),
+                entity_name: z.string().optional().describe("Optional entity name to attach. Auto-upserts the entity if provided."),
+                entity_kind: z.string().optional().describe("Required when entity_name is provided."),
+                source: z.string().optional().describe("Action item source, e.g. manual, subagent_proposal, external."),
+            }),
+            handler: async (args) => {
+                const denied = requireOrchestratorMemoryWrite();
+                if (denied)
+                    return denied;
+                if (args.entity_name && !args.entity_kind) {
+                    return "entity_kind is required when entity_name is provided.";
+                }
+                try {
+                    const { scopeId, scopeSlug } = resolveMemoryScopeForWrite(args.scope, `${args.title}\n${args.detail ?? ""}`);
+                    const entity = args.entity_name
+                        ? upsertEntity({
+                            scope_id: scopeId,
+                            kind: args.entity_kind,
+                            name: args.entity_name,
+                        })
+                        : undefined;
+                    const actionItem = recordActionItem({
+                        scope_id: scopeId,
+                        entity_id: entity?.id,
+                        title: args.title,
+                        detail: args.detail,
+                        due_at: args.due_at,
+                        source: args.source ?? "manual",
+                    });
+                    return {
+                        ok: true,
+                        id: actionItem.id,
+                        scope: scopeSlug,
+                        status: actionItem.status,
+                        entity_id: entity?.id,
+                    };
+                }
+                catch (err) {
+                    return err instanceof Error ? err.message : String(err);
+                }
+            },
+        }),
+        defineTool("memory_complete_action_item", {
+            description: "Complete a memory action item. Orchestrator-only write tool.",
+            parameters: z.object({
+                id: z.number().int().positive(),
+                resolution_reason: z.string().optional(),
+            }),
+            handler: async (args) => {
+                const denied = requireOrchestratorMemoryWrite();
+                if (denied)
+                    return denied;
+                try {
+                    const actionItem = completeActionItem(args.id, args.resolution_reason);
+                    return { ok: true, id: actionItem.id, status: actionItem.status, resolved_at: actionItem.resolvedAt };
+                }
+                catch (err) {
+                    return err instanceof Error ? err.message : String(err);
+                }
+            },
+        }),
+        defineTool("memory_drop_action_item", {
+            description: "Drop a memory action item with a reason. Orchestrator-only write tool.",
+            parameters: z.object({
+                id: z.number().int().positive(),
+                reason: z.string().min(1),
+            }),
+            handler: async (args) => {
+                const denied = requireOrchestratorMemoryWrite();
+                if (denied)
+                    return denied;
+                try {
+                    const actionItem = dropActionItem(args.id, args.reason);
+                    return { ok: true, id: actionItem.id, status: actionItem.status, resolved_at: actionItem.resolvedAt };
+                }
+                catch (err) {
+                    return err instanceof Error ? err.message : String(err);
+                }
+            },
+        }),
+        defineTool("memory_snooze_action_item", {
+            description: "Snooze a memory action item until an ISO timestamp. Orchestrator-only write tool.",
+            parameters: z.object({
+                id: z.number().int().positive(),
+                snooze_until: z.string().min(1),
+            }),
+            handler: async (args) => {
+                const denied = requireOrchestratorMemoryWrite();
+                if (denied)
+                    return denied;
+                try {
+                    const actionItem = snoozeActionItem(args.id, args.snooze_until);
+                    return {
+                        ok: true,
+                        id: actionItem.id,
+                        status: actionItem.status,
+                        snooze_until: actionItem.snoozeUntil,
+                    };
+                }
+                catch (err) {
+                    return err instanceof Error ? err.message : String(err);
+                }
+            },
+        }),
+        defineTool("memory_list_action_items", {
+            description: "List scoped memory action items/reminders. Defaults to currently actionable open items.",
+            parameters: z.object({
+                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope when available."),
+                status: z.enum(["open", "done", "dropped", "snoozed"]).optional().describe("Optional status filter."),
+                due_before: z.string().optional().describe("Optional ISO timestamp; only include items due at or before this time."),
+                includeArchived: z.boolean().optional().describe("Include cold-tier items. Defaults to false."),
+            }),
+            handler: async (args) => {
+                const requestedScope = args.scope ? getMemoryScope(args.scope) : undefined;
+                if (args.scope && !requestedScope) {
+                    return `Unknown memory scope '${args.scope}'.`;
+                }
+                const activeScope = getMemoryActiveScope();
+                const scope = requestedScope ?? activeScope ?? undefined;
+                const actionItems = listActionItems({
+                    scope_id: scope?.id,
+                    status: args.status,
+                    due_before: args.due_before,
+                    includeArchived: args.includeArchived,
+                });
+                return {
+                    active_scope: activeScope ? { slug: activeScope.slug, title: activeScope.title } : null,
+                    scope: scope ? { slug: scope.slug, title: scope.title } : null,
+                    action_items: actionItems.map((item) => ({
+                        id: item.id,
+                        scope_id: item.scopeId,
+                        entity_id: item.entityId,
+                        title: item.title,
+                        detail: item.detail,
+                        status: item.status,
+                        due_at: item.dueAt,
+                        snooze_until: item.snoozeUntil,
+                        source: item.source,
+                        created_at: item.createdAt,
+                        updated_at: item.updatedAt,
+                        resolved_at: item.resolvedAt,
+                        resolution_reason: item.resolutionReason,
+                    })),
+                };
+            },
+        }),
         defineTool("memory_recall", {
             description: "Search scoped agent memory with FTS-backed recall. Use this for the new agent-memory store, not the wiki-backed recall tool.",
             parameters: z.object({
                 query: z.string().describe("Query text to search for."),
                 scope: z.string().optional().describe("Optional scope slug. Defaults to the active scope when available."),
-                kinds: z.array(z.enum(["observation", "decision", "entity"])).optional()
+                kinds: z.array(z.enum(["observation", "decision", "entity", "action_item"])).optional()
                     .describe("Optional filter for memory entry kinds."),
                 limit: z.number().int().positive().optional().describe("Maximum number of ranked hits to return. Defaults to 10."),
                 includeSuperseded: z.boolean().optional().describe("Include superseded observations and decisions. Defaults to false."),