chapterhouse 0.4.3 → 0.5.1

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, completeActionItem, demoteToCold, demoteToWarm, dropActionItem, queueMemoryProposal, recall as recallMemory, listActionItems, recordDecision, recordActionItem, recordObservation, runHousekeeping, setActiveScope as setMemoryActiveScope, snoozeActionItem, promoteToHot, upsertEntity, } from "../memory/index.js";
+import { getActiveScope as getMemoryActiveScope, createScope as createMemoryScope, 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) {
+    if (requestedScopeSlug) {
+        return requestedScopeSlug;
+    }
+    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
+    if (!agentSlug || agentSlug === "chapterhouse") {
+        return getMemoryActiveScope()?.slug;
+    }
+    const agent = getAgent(agentSlug);
+    const boundScope = agent?.scope ?? loadAgents().find((entry) => entry.slug === agentSlug)?.scope;
+    if (boundScope && getMemoryScope(boundScope)) {
+        return boundScope;
+    }
+    return getMemoryActiveScope()?.slug;
+}
 function resolveMemoryScopeForWrite(explicitScope, content) {
     const explicit = explicitScope ? getMemoryScope(explicitScope) : undefined;
     if (explicitScope && !explicit) {
@@ -123,11 +138,28 @@ const entityProposalPayloadSchema = z.object({
     summary: value.summary,
 }));
 const actionItemProposalPayloadSchema = z.object({
-    title: z.string(),
+    title: z.string().trim().min(1, "title is required for action_item proposals."),
     detail: z.string().optional(),
     due_at: z.string().optional(),
     source: z.string().optional(),
     entity_id: z.number().int().positive().optional(),
+    entity_name: z.string().trim().min(1, "entity_name must be non-empty when provided.").optional(),
+    entity_kind: z.string().trim().min(1, "entity_kind must be non-empty when provided.").optional(),
+}).superRefine((value, context) => {
+    if ((value.entity_name && !value.entity_kind) || (!value.entity_name && value.entity_kind)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "entity_name and entity_kind must be provided together for action_item proposals.",
+            path: ["entity_name"],
+        });
+    }
+    if (value.entity_id !== undefined && value.entity_name) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide either entity_id or entity_name/entity_kind for action_item proposals, not both.",
+            path: ["entity_id"],
+        });
+    }
 });
 const memoryProposeArgsSchema = z.object({
     kind: z.enum(["observation", "decision", "entity", "action_item"]),
@@ -210,15 +242,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
@@ -232,6 +255,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
@@ -876,7 +964,7 @@ export function createTools(deps) {
                                 : 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,
@@ -896,6 +984,54 @@ export function createTools(deps) {
                 }
             },
         }),
+        defineTool("memory_create_scope", {
+            description: "Create a new user-defined memory scope. Slugs must be unique kebab-case; baseline installs only include global and chapterhouse.",
+            parameters: z.object({
+                slug: z.string()
+                    .trim()
+                    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
+                title: z.string().trim().min(1, "title is required"),
+                description: z.string().optional(),
+            }),
+            handler: async (args) => {
+                const denied = requireOrchestratorMemoryWrite();
+                if (denied)
+                    return denied;
+                const parsed = z.object({
+                    slug: z.string()
+                        .trim()
+                        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
+                    title: z.string().trim().min(1, "title is required"),
+                    description: z.string().optional(),
+                }).safeParse(args);
+                if (!parsed.success) {
+                    return parsed.error.issues.map((issue) => issue.message).join("; ");
+                }
+                try {
+                    if (getMemoryScope(parsed.data.slug)) {
+                        return `Memory scope '${parsed.data.slug}' already exists.`;
+                    }
+                    const scope = createMemoryScope({
+                        slug: parsed.data.slug,
+                        title: parsed.data.title,
+                        description: parsed.data.description ?? "",
+                        keywords: [parsed.data.slug],
+                    });
+                    return {
+                        ok: true,
+                        scope: {
+                            slug: scope.slug,
+                            title: scope.title,
+                            description: scope.description,
+                            active: scope.active,
+                        },
+                    };
+                }
+                catch (err) {
+                    return err instanceof Error ? err.message : String(err);
+                }
+            },
+        }),
         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({

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 () => { },
         },
     });
@@ -84,6 +85,7 @@ test("memory tools remember, recall, set scope, and enforce orchestrator-only wr
     const memoryRemember = findTool(tools, "memory_remember");
     const memoryRecall = findTool(tools, "memory_recall");
     const memorySetScope = findTool(tools, "memory_set_scope");
+    const memoryCreateScope = findTool(tools, "memory_create_scope");
     const bindToolsToAgent = agentsModule.bindToolsToAgent;
     assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
     const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
@@ -120,6 +122,30 @@ test("memory tools remember, recall, set scope, and enforce orchestrator-only wr
     assert.equal((recalled.hits ?? []).some((hit) => hit.id === row.id), true);
     const scopeResult = await chapterhouseSetScope.handler({ slug: "chapterhouse" }, {});
     assert.equal(scopeResult.active_scope?.slug, "chapterhouse");
+    const createdScope = await memoryCreateScope.handler({
+        slug: "docs-site",
+        title: "Docs Site",
+        description: "Documentation publishing and content workflows",
+    }, {});
+    assert.deepEqual(createdScope, {
+        ok: true,
+        scope: {
+            slug: "docs-site",
+            title: "Docs Site",
+            description: "Documentation publishing and content workflows",
+            active: true,
+        },
+    });
+    const duplicateScope = await memoryCreateScope.handler({
+        slug: "docs-site",
+        title: "Docs Site Again",
+    }, {});
+    assert.match(String(duplicateScope), /already exists/i);
+    const invalidScope = await memoryCreateScope.handler({
+        slug: "Docs Site",
+        title: "Docs Site",
+    }, {});
+    assert.match(String(invalidScope), /kebab-case/i);
     const implicitScopeRemember = await chapterhouseRemember.handler({
         content: "Implicit active-scope writes should route to chapterhouse.",
         kind: "observation",
@@ -150,7 +176,7 @@ test("memory tools remember, recall, set scope, and enforce orchestrator-only wr
     }, {});
     assert.equal(typeof coderRecalled, "object");
     assert.equal((coderRecalled.hits ?? []).some((hit) => hit.id === row.id), true);
-    assert.ok(memoryRemember && memoryRecall && memorySetScope);
+    assert.ok(memoryRemember && memoryRecall && memorySetScope && memoryCreateScope);
 });
 test("memory_propose queues pending proposals, defaults scope from the active scope, and captures delegated task context", async () => {
     const { toolsModule, agentsModule, dbModule } = await loadModules();
@@ -194,6 +220,97 @@ 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 honors an explicit scope_slug", async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    assert.ok(home, "test home should be set");
+    const { AGENTS_DIR: agentsDir } = await import("../paths.js");
+    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 can explicitly route proposals to another scope when needed.",
+        },
+    }, {}));
+    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, "chapterhouse");
+});
+test("memory_propose ignores a missing subagent bound scope and falls back to the active scope", async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    assert.ok(home, "test home should be set");
+    const { AGENTS_DIR: agentsDir } = await import("../paths.js");
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(join(agentsDir, "hwi.agent.md"), [
+        "---",
+        "name: Hwi",
+        "description: Mentat of Brian's personal scope",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: brian",
+        "---",
+        "",
+        "You are Hwi.",
+    ].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 hwiTools = bindToolsToAgent("hwi", tools, "task-hwi-action-item");
+    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
+    const proposed = await findTool(hwiTools, "memory_propose").handler({
+        kind: "action_item",
+        payload: {
+            title: "Follow up with Brian",
+        },
+    }, {});
+    assert.equal(proposed.status, "queued");
+    const row = dbModule.getDb().prepare(`
+    SELECT source_agent, 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, "hwi");
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.scope_slug, "chapterhouse");
+});
 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({
@@ -318,6 +435,26 @@ test("memory_propose accepts action_item proposals with a resolvable payload sha
     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 action_item proposals with blank titles before queuing", async () => {
+    const { toolsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const memoryPropose = findTool(tools, "memory_propose");
+    const result = await memoryPropose.handler({
+        kind: "action_item",
+        payload: {
+            title: "   ",
+        },
+    }, {});
+    assert.match(String(result), /title/i);
+    const queued = dbModule.getDb().prepare(`
+    SELECT COUNT(*) AS count
+    FROM mem_inbox
+  `).get();
+    assert.equal(queued.count, 0);
+});
 test("memory_propose rejects invalid proposal kinds", async () => {
     const { toolsModule } = await loadModules();
     const tools = toolsModule.createTools({

package/dist/memory/active-scope.js

@@ -1,6 +1,8 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { getDb } from "../store/db.js";
 import { getScope, listScopes } from "./scopes.js";
 const ACTIVE_SCOPE_KEY = "current_scope_slug";
+const activeScopeOverride = new AsyncLocalStorage();
 function setSetting(key, value) {
     getDb().prepare(`
     INSERT INTO mem_settings (key, value)
@@ -20,6 +22,10 @@ function clearSetting(key) {
     getDb().prepare(`DELETE FROM mem_settings WHERE key = ?`).run(key);
 }
 export function getActiveScope() {
+    const override = activeScopeOverride.getStore();
+    if (override !== undefined) {
+        return override === null ? null : (getScope(override) ?? null);
+    }
     const slug = getSetting(ACTIVE_SCOPE_KEY);
     if (!slug)
         return null;
@@ -30,6 +36,9 @@ export function getActiveScope() {
     }
     return scope;
 }
+export function withActiveScope(slug, fn) {
+    return activeScopeOverride.run(slug, fn);
+}
 export function setActiveScope(slug) {
     if (slug === null) {
         clearSetting(ACTIVE_SCOPE_KEY);

package/dist/memory/active-scope.test.js

@@ -38,11 +38,16 @@ test("active scope can be set, read, and cleared without changing scope activati
     const getActiveScope = getFunction(memoryModule, "getActiveScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const deactivateScope = getFunction(memoryModule, "deactivateScope");
+    const createScope = getFunction(memoryModule, "createScope");
     assert.equal(getActiveScope(), null);
     assert.equal(setActiveScope("chapterhouse")?.slug, "chapterhouse");
     assert.equal(getActiveScope()?.slug, "chapterhouse");
-    const team = getScope("team");
-    assert.ok(team);
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     const deactivated = deactivateScope(team.id);
     assert.equal(deactivated.active, false);
     assert.equal(getActiveScope()?.slug, "chapterhouse");

package/dist/memory/eot.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { getAgent, loadAgents } from "../copilot/agents.js";
 import { runOneShotPrompt } from "../copilot/oneshot.js";
 import { childLogger } from "../util/logger.js";
 import { recordDecision } from "./decisions.js";
@@ -6,6 +7,7 @@ import { upsertEntity } from "./entities.js";
 import { listPendingMemoryProposalsForTask, resolveInboxItem } from "./inbox.js";
 import { recordObservation } from "./observations.js";
 import { recordActionItem } from "./action-items.js";
+import { getActiveScope } from "./active-scope.js";
 import { getScope } from "./scopes.js";
 const log = childLogger("memory.eot");
 function isEndOfTaskHookEnabled() {
@@ -119,7 +121,75 @@ function parseReviewerResponse(raw) {
             : [],
     };
 }
-function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isIsoTimestamp(value) {
+    return !Number.isNaN(Date.parse(value));
+}
+function validateActionItemPayload(payload) {
+    const actionItem = payload;
+    if (!isNonEmptyString(actionItem.title)) {
+        throw new Error("Action item proposal payload requires a non-empty title.");
+    }
+    if (actionItem.detail !== undefined && typeof actionItem.detail !== "string") {
+        throw new Error("Action item proposal payload detail must be a string.");
+    }
+    if (actionItem.due_at !== undefined && (typeof actionItem.due_at !== "string" || !isIsoTimestamp(actionItem.due_at))) {
+        throw new Error("Action item proposal payload due_at must be an ISO timestamp.");
+    }
+    if (actionItem.entity_id !== undefined && (!Number.isInteger(actionItem.entity_id) || actionItem.entity_id <= 0)) {
+        throw new Error("Action item proposal payload entity_id must be a positive integer.");
+    }
+    if (actionItem.entity_id !== undefined && actionItem.entity_name !== undefined) {
+        throw new Error("Action item proposal payload must provide either entity_id or entity_name/entity_kind, not both.");
+    }
+    const hasEntityName = actionItem.entity_name !== undefined;
+    const hasEntityKind = actionItem.entity_kind !== undefined;
+    if (hasEntityName !== hasEntityKind) {
+        throw new Error("Action item proposal payload entity_name and entity_kind must be provided together.");
+    }
+    if (hasEntityName && !isNonEmptyString(actionItem.entity_name)) {
+        throw new Error("Action item proposal payload entity_name must be non-empty when provided.");
+    }
+    if (hasEntityKind && !isNonEmptyString(actionItem.entity_kind)) {
+        throw new Error("Action item proposal payload entity_kind must be non-empty when provided.");
+    }
+    return {
+        title: actionItem.title.trim(),
+        detail: actionItem.detail,
+        due_at: actionItem.due_at,
+        source: actionItem.source,
+        entity_id: actionItem.entity_id,
+        entity_name: actionItem.entity_name?.trim(),
+        entity_kind: actionItem.entity_kind?.trim(),
+    };
+}
+function getBoundScopeSlug(sourceAgent) {
+    const agent = getAgent(sourceAgent);
+    return agent?.scope ?? loadAgents().find((entry) => entry.slug === sourceAgent)?.scope;
+}
+function resolveAcceptedProposalScopeSlug(envelope, proposal) {
+    if (isNonEmptyString(envelope.scope_slug)) {
+        return envelope.scope_slug.trim();
+    }
+    const boundScope = getBoundScopeSlug(proposal.sourceAgent);
+    if (boundScope) {
+        return boundScope;
+    }
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    if (proposal.scopeId) {
+        const queuedScope = getScope(proposal.scopeId);
+        if (queuedScope) {
+            return queuedScope.slug;
+        }
+    }
+    throw new Error("No memory scope could be resolved for this proposal.");
+}
+function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, sourceAgent) {
     const scope = getScope(scopeSlug);
     if (!scope) {
         throw new Error(`Unknown memory scope '${scopeSlug}'.`);
@@ -146,14 +216,22 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
         return;
     }
     if (kind === "action_item") {
-        const actionItem = payload;
+        const actionItem = validateActionItemPayload(payload);
+        const entity = actionItem.entity_name && actionItem.entity_kind
+            ? upsertEntity({
+                scope_id: scope.id,
+                kind: actionItem.entity_kind,
+                name: actionItem.entity_name,
+                confidence,
+            })
+            : undefined;
         recordActionItem({
             scope_id: scope.id,
-            entity_id: actionItem.entity_id,
+            entity_id: entity?.id ?? actionItem.entity_id,
             title: actionItem.title,
             detail: actionItem.detail,
             due_at: actionItem.due_at,
-            source: actionItem.source ?? source,
+            source: sourceAgent ? `subagent_proposal:${sourceAgent}` : actionItem.source ?? source,
         });
         return;
     }
@@ -209,11 +287,21 @@ export async function runEndOfTaskMemoryHook(input) {
         }
         reviewedProposalIds.add(proposal.id);
         if (decision.decision === "accept") {
-            summary.accepted++;
-            if (autoAcceptEnabled) {
+            if (!autoAcceptEnabled) {
+                summary.accepted++;
+            }
+            else {
                 const envelope = parseEnvelope(proposal.payload);
-                rememberAcceptedMemory(envelope.kind, envelope.scope_slug ?? getScope(proposal.scopeId).slug, envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence);
-                resolveInboxItem(proposal.id, "accepted", decision.reason);
+                try {
+                    rememberAcceptedMemory(envelope.kind, resolveAcceptedProposalScopeSlug(envelope, proposal), envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence, proposal.sourceAgent);
+                    resolveInboxItem(proposal.id, "accepted", decision.reason);
+                    summary.accepted++;
+                }
+                catch (err) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    resolveInboxItem(proposal.id, "rejected", reason);
+                    summary.rejected++;
+                }
             }
             continue;
         }