chapterhouse 0.4.2 → 0.4.3

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, turnId);
+                if (!options?.suppressPromptLog) {
+                    try {
+                        logConversation(logRole, prompt, sourceLabel, sessionKey, { turnId });
+                    }
+                    catch { /* best-effort */ }
                 }
-                catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey, turnId);
+                    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, turnId);
+                    logConversation("user", newPrompt, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey, turnId);
+                    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."),

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/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();
     }