chapterhouse 0.4.2 → 0.5.0

package/dist/copilot/tools.js

@@ -7,7 +7,7 @@ import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
 import { agentEventBus } from "./agent-event-bus.js";
-import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
+import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, sendToAgentSession, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
 import { searchIndex, addToIndex, removeFromIndex, buildIndexEntryForPage } from "../wiki/index-manager.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) {
@@ -65,6 +65,21 @@ function requireOrchestratorMemoryWrite() {
     }
     return null;
 }
+function resolveProposalScopeSlug(requestedScopeSlug) {
+    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
+    if (!agentSlug || agentSlug === "chapterhouse") {
+        return requestedScopeSlug;
+    }
+    const activeScope = getMemoryActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    const agent = getAgent(agentSlug);
+    if (agent?.persistent && agent.scope) {
+        return agent.scope;
+    }
+    return requestedScopeSlug;
+}
 function resolveMemoryScopeForWrite(explicitScope, content) {
     const explicit = explicitScope ? getMemoryScope(explicitScope) : undefined;
     if (explicitScope && !explicit) {
@@ -106,11 +121,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 +155,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 +169,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}`;
 }
@@ -188,15 +225,6 @@ export function createTools(deps) {
                 }
                 const delegatedSlug = agent.slug;
                 const taskId = createTaskId();
-                let session;
-                try {
-                    const allTools = createTools(deps);
-                    session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override, undefined, taskId);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return `Failed to create session for @${delegatedSlug}: ${msg}`;
-                }
                 const task = registerTask(delegatedSlug, args.summary, getCurrentSourceChannel(), taskId);
                 const activeProjectRules = getCurrentActiveProjectRules();
                 const warningLines = activeProjectRules
@@ -210,6 +238,71 @@ export function createTools(deps) {
                 const db = getDb();
                 db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
            VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, args.task, task.originChannel || null, getCurrentSessionKey());
+                if (agent.persistent) {
+                    (async () => {
+                        try {
+                            const output = await sendToAgentSession(delegatedSlug, taskPrompt, task.taskId);
+                            completeTask(task.taskId, output);
+                            updateTaskResult(task.taskId, "completed", output);
+                            const statusEvent = appendTaskStatusEvent(task.taskId, "completed");
+                            if (statusEvent) {
+                                void agentEventBus.emit({
+                                    type: "session:tool_call",
+                                    sessionId: task.taskId,
+                                    payload: {
+                                        toolName: "",
+                                        toolArgs: {},
+                                        _kind: statusEvent.kind,
+                                        _seq: statusEvent.seq,
+                                        _ts: statusEvent.ts,
+                                        _summary: statusEvent.summary,
+                                        _text: statusEvent.text,
+                                        _status: statusEvent.status,
+                                    },
+                                    timestamp: new Date(statusEvent.ts),
+                                });
+                            }
+                            deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            failTask(task.taskId, msg);
+                            updateTaskResult(task.taskId, "error", msg);
+                            const statusEvent = appendTaskStatusEvent(task.taskId, "error", msg);
+                            if (statusEvent) {
+                                void agentEventBus.emit({
+                                    type: "session:tool_call",
+                                    sessionId: task.taskId,
+                                    payload: {
+                                        toolName: "",
+                                        toolArgs: {},
+                                        _kind: statusEvent.kind,
+                                        _seq: statusEvent.seq,
+                                        _ts: statusEvent.ts,
+                                        _summary: statusEvent.summary,
+                                        _text: statusEvent.text,
+                                        _status: statusEvent.status,
+                                    },
+                                    timestamp: new Date(statusEvent.ts),
+                                });
+                            }
+                            deps.onAgentTaskComplete(task.taskId, delegatedSlug, `Error: ${msg}`);
+                        }
+                    })();
+                    const model = (args.model_override && args.model_override.length > 0)
+                        ? args.model_override
+                        : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model || "claude-sonnet-4.6");
+                    return `Task delegated to @${delegatedSlug} (${model}). Task ID: ${task.taskId}. I'll notify you when it's done.`;
+                }
+                let session;
+                try {
+                    const allTools = createTools(deps);
+                    session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override, undefined, taskId);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return `Failed to create session for @${delegatedSlug}: ${msg}`;
+                }
                 // Capture the parent's activity callback so the child session can stream
                 // its events back to the originating SSE connection. This survives past
                 // the parent assistant turn — the child runs long after the parent's
@@ -849,10 +942,12 @@ 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,
+                        scopeSlug: resolveProposalScopeSlug(parsedArgs.scope_slug),
                         payload,
                         confidence: parsedArgs.confidence ?? 0.5,
                         reason: parsedArgs.reason,
@@ -872,12 +967,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

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
@@ -46,6 +46,7 @@ test("memory_set_scope invalidates the orchestrator session after scheduling the
             invalidateOrchestratorSession: (sessionKey) => {
                 events.push(`invalidate:${sessionKey}`);
             },
+            sendToAgentSession: async () => "",
             switchSessionModel: async () => { },
         },
     });
@@ -194,6 +195,178 @@ 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 from a persistent agent is bound to that agent's scope", async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    assert.ok(home, "test home should be set");
+    const chapterhouseHome = home.endsWith(".chapterhouse") ? home : join(home, ".chapterhouse");
+    const agentsDir = join(chapterhouseHome, "agents");
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(join(agentsDir, "bellonda.agent.md"), [
+        "---",
+        "name: Bellonda",
+        "description: Mentat of the infrastructure domain",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: infra",
+        "---",
+        "",
+        "You are Bellonda.",
+    ].join("\n"));
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    agentsModule.loadAgents();
+    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 bellondaTools = bindToolsToAgent("bellonda", tools, "task-persistent-scope-001");
+    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
+    const memoryModule = await import("../memory/index.js");
+    const proposed = await memoryModule.withActiveScope("infra", () => findTool(bellondaTools, "memory_propose").handler({
+        kind: "observation",
+        scope_slug: "chapterhouse",
+        payload: {
+            content: "Persistent agents should not be able to write proposals outside their bound scope.",
+        },
+    }, {}));
+    assert.equal(proposed.status, "queued");
+    const row = dbModule.getDb().prepare(`
+    SELECT source_agent, source_task_id, payload
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(proposed.proposal_id);
+    assert.ok(row, "memory_propose should insert a mem_inbox row");
+    assert.equal(row.source_agent, "bellonda");
+    assert.equal(row.source_task_id, "task-persistent-scope-001");
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.scope_slug, "infra");
+});
+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 +378,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();
     }