chapterhouse 0.4.3 → 0.5.1

package/dist/memory/eot.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
 const repoRoot = process.cwd();
@@ -15,7 +15,8 @@ async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
     const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
     const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, eotModule };
+    const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, eotModule, agentsModule };
 }
 function getFunction(module, name) {
     const value = module[name];
@@ -171,7 +172,6 @@ test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items
         payload: {
             title: "Migrate feature ideas",
             detail: "Move feature-ideas.md into mem_action_items.",
-            source: "subagent_proposal",
         },
         confidence: 0.9,
     }));
@@ -189,11 +189,192 @@ test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items
         }),
     });
     const actionItems = listActionItems({ scope_id: chapterhouse.id });
-    assert.equal(actionItems.some((item) => item.title === "Migrate feature ideas"
-        && item.detail === "Move feature-ideas.md into mem_action_items."), true);
+    const actionItem = actionItems.find((item) => item.title === "Migrate feature ideas");
+    assert.ok(actionItem);
+    assert.equal(actionItem.detail, "Move feature-ideas.md into mem_action_items.");
+    assert.equal(actionItem.status, "open");
+    assert.equal(actionItem.source, "subagent_proposal:coder");
     const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(inbox.status, "accepted");
 });
+test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear reason", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-invalid");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item-invalid', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            detail: "A title is required before this can become an action item.",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-invalid",
+        finalResult: "Completed and proposed a malformed follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason, resolved_at
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /title/i);
+    assert.ok(inbox.resolved_at);
+});
+test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item-ambiguous-entity', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Resolve ambiguous entity link",
+            entity_id: 1,
+            entity_name: "Bellonda",
+            entity_kind: "agent",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-ambiguous-entity",
+        finalResult: "Completed and proposed an ambiguous follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /entity_id.*entity_name|entity_name.*entity_id/i);
+});
+test("runEndOfTaskMemoryHook falls back to the source agent bound scope for action_item proposals without 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 { dbModule, memoryModule, eotModule, agentsModule } = await loadModules("action-item-bound-scope");
+    agentsModule.loadAgents();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    const infra = createScope({
+        slug: "infra",
+        title: "Infra",
+        description: "Infra test scope",
+        keywords: ["infra"],
+    });
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'bellonda', 'task-eot-action-item-bound-scope', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Review NAS disk alerts",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-bound-scope",
+        finalResult: "Bellonda proposed an infra follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete infra follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.equal(listActionItems({ scope_id: infra.id }).some((item) => item.title === "Review NAS disk alerts"), true);
+    assert.equal(listActionItems({ scope_id: chapterhouse.id }).some((item) => item.title === "Review NAS disk alerts"), false);
+});
+test("runEndOfTaskMemoryHook still accepts observation, decision, and entity proposals", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("existing-proposal-kinds");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const proposals = [
+        { kind: "observation", payload: { content: "Existing observation proposals still persist." } },
+        { kind: "decision", payload: { title: "Keep auto-accept", rationale: "It is required for EOT memory promotion." } },
+        { kind: "entity", payload: { name: "Bellonda", entity_kind: "agent", summary: "Infrastructure mentat." } },
+    ].map((envelope) => db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-existing-kinds', 'pending')
+  `).run(chapterhouse.id, JSON.stringify(envelope)));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-existing-kinds",
+        finalResult: "Completed with several proposal kinds.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: proposals.map((proposal) => ({
+                proposal_id: Number(proposal.lastInsertRowid),
+                decision: "accept",
+                reason: "Valid durable memory.",
+            })),
+            implicit_memories: [],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Existing observation proposals still persist."), true);
+    assert.equal(listDecisions({ scope_id: chapterhouse.id }).some((row) => row.title === "Keep auto-accept" && row.rationale === "It is required for EOT memory promotion."), true);
+    assert.equal(listEntities({ scope_id: chapterhouse.id, kind: "agent" }).some((row) => row.name === "Bellonda"), true);
+});
 test("runEndOfTaskMemoryHook accepts entity proposals with entity_kind into mem_entities", async () => {
     const { dbModule, memoryModule, eotModule } = await loadModules("entity-accept");
     const db = dbModule.getDb();

package/dist/memory/hot-tier.test.js

@@ -108,12 +108,17 @@ test("active-scope hot-tier queries do not leak rows from other scopes", async (
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     assert.ok(chapterhouse);
-    assert.ok(team);
     recordObservation({
         scope_id: chapterhouse.id,
         content: "Chapterhouse hot entry",
@@ -135,11 +140,16 @@ test("renderHotTierXML includes open active-scope action items in a bounded acti
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
     const recordActionItem = getFunction(memoryModule, "recordActionItem");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     assert.ok(chapterhouse);
-    assert.ok(team);
     const urgent = recordActionItem({
         scope_id: chapterhouse.id,
         title: "Migrate <feature ideas>",

package/dist/memory/housekeeping.test.js

@@ -24,6 +24,15 @@ function getFunction(module, name) {
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
     return value;
 }
+function createTestScope(memoryModule, slug) {
+    const createScope = getFunction(memoryModule, "createScope");
+    return createScope({
+        slug,
+        title: slug.split("-").map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" "),
+        description: `${slug} test scope`,
+        keywords: [slug],
+    });
+}
 test.beforeEach(async () => {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
     dbModule.closeDb();
@@ -42,8 +51,8 @@ test("dedupObservationsPass supersedes similar observations in scope determinist
     const getScope = getFunction(memoryModule, "getScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const first = recordObservation({
         scope_id: team.id,
         content: "The worker event stream uses server sent events for live task output.",
@@ -88,9 +97,8 @@ test("dedupDecisionsPass supersedes similar active decisions within scope and ke
     const getScope = getFunction(memoryModule, "getScope");
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = getScope("team");
-    const infra = getScope("infra");
-    assert.ok(team && infra);
+    const team = createTestScope(memoryModule, "team");
+    const infra = createTestScope(memoryModule, "infra");
     const api = upsertEntity({ scope_id: team.id, kind: "component", name: "api" });
     const web = upsertEntity({ scope_id: team.id, kind: "component", name: "web" });
     const oldDecision = recordDecision({
@@ -139,8 +147,8 @@ test("orphanCleanupPass clears missing observation entity references without tou
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const entity = upsertEntity({ scope_id: chapterhouse.id, kind: "tool", name: "sqlite" });
     const valid = recordObservation({ scope_id: chapterhouse.id, entity_id: entity.id, content: "Valid entity reference", source: "test" });
     const orphan = recordObservation({ scope_id: chapterhouse.id, content: "Will become orphaned", source: "test" });
@@ -164,8 +172,8 @@ test("decayPass archives old low-confidence observations only in scope and compa
     const getScope = getFunction(memoryModule, "getScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const archiveMe = recordObservation({ scope_id: chapterhouse.id, content: "Old low confidence", source: "test", confidence: 0.2 });
     const highConfidence = recordObservation({ scope_id: chapterhouse.id, content: "Old high confidence", source: "test", confidence: 0.9 });
     const fresh = recordObservation({ scope_id: chapterhouse.id, content: "Fresh low confidence", source: "test", confidence: 0.2 });
@@ -201,8 +209,8 @@ test("runHousekeeping defaults to the active scope and can target all active sco
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const chapterhouseOld = recordObservation({ scope_id: chapterhouse.id, content: "Chapterhouse old low", source: "test", confidence: 0.1 });
     const teamOld = recordObservation({ scope_id: team.id, content: "Team old low", source: "test", confidence: 0.1 });
     db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-31 days') WHERE id IN (?, ?)`).run(chapterhouseOld.id, teamOld.id);
@@ -225,8 +233,7 @@ test("tieringPass promotes and demotes rows from lifecycle signals and is idempo
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = getScope("team");
-    assert.ok(team);
+    const team = createTestScope(memoryModule, "team");
     const entity = upsertEntity({ scope_id: team.id, kind: "component", name: "memory", tier: "warm" });
     const referencedObservation = recordObservation({
         scope_id: team.id,

package/dist/memory/index.js

@@ -1,5 +1,5 @@
 export { completeActionItem, dropActionItem, getActionItem, listActionItems, recordActionItem, snoozeActionItem, } from "./action-items.js";
-export { getActiveScope, inferScopeFromText, setActiveScope } from "./active-scope.js";
+export { getActiveScope, inferScopeFromText, setActiveScope, withActiveScope } from "./active-scope.js";
 export { recordDecision, getDecision, listDecisions, supersedeDecision } from "./decisions.js";
 export { getEntity, findEntityByName, listEntities, upsertEntity } from "./entities.js";
 export { getHotTierEntries, renderHotTierForActiveScope, renderHotTierXML } from "./hot-tier.js";

package/dist/memory/scopes.test.js

@@ -68,13 +68,6 @@ test("getDb seeds canonical memory scopes on first run", async () => {
       ORDER BY slug
     `).all();
         assert.deepEqual(rows, [
-            {
-                slug: "brian",
-                title: "Brian",
-                description: "Brian's preferences, context, working style",
-                keywords: JSON.stringify(["brian"]),
-                active: 1,
-            },
             {
                 slug: "chapterhouse",
                 title: "Chapterhouse",
@@ -89,20 +82,6 @@ test("getDb seeds canonical memory scopes on first run", async () => {
                 keywords: JSON.stringify(["everywhere", "general"]),
                 active: 1,
             },
-            {
-                slug: "infra",
-                title: "Infra",
-                description: "Infrastructure, hosting, deployment, CI/CD",
-                keywords: JSON.stringify(["infra"]),
-                active: 1,
-            },
-            {
-                slug: "team",
-                title: "Team",
-                description: "Team processes, rituals, OKRs",
-                keywords: JSON.stringify(["team"]),
-                active: 1,
-            },
         ]);
     }
     finally {
@@ -123,11 +102,8 @@ test("memory schema initialization is idempotent", async () => {
       ORDER BY slug
     `).all();
         assert.deepEqual(counts, [
-            { slug: "brian", count: 1 },
             { slug: "chapterhouse", count: 1 },
             { slug: "global", count: 1 },
-            { slug: "infra", count: 1 },
-            { slug: "team", count: 1 },
         ]);
         reopened.dbModule.closeDb();
     }

package/dist/store/db.js

@@ -216,24 +216,6 @@ const MEMORY_SCOPE_SEEDS = [
         description: "Chapterhouse codebase, conventions, decisions, gotchas",
         keywords: ["chapterhouse", "this repo", "this project", "the daemon"],
     },
-    {
-        slug: "infra",
-        title: "Infra",
-        description: "Infrastructure, hosting, deployment, CI/CD",
-        keywords: ["infra"],
-    },
-    {
-        slug: "team",
-        title: "Team",
-        description: "Team processes, rituals, OKRs",
-        keywords: ["team"],
-    },
-    {
-        slug: "brian",
-        title: "Brian",
-        description: "Brian's preferences, context, working style",
-        keywords: ["brian"],
-    },
 ];
 const CHAPTERHOUSE_WIKI_INDEX_SOURCE = "wiki:pages/projects/chapterhouse/index.md";
 const CHAPTERHOUSE_WIKI_HOT_TIER_REASON = "P6 PR1 wiki migration hot-tier candidate";
@@ -628,13 +610,39 @@ export function getDb() {
         db.exec(`
       CREATE TABLE IF NOT EXISTS copilot_sessions (
         session_key TEXT PRIMARY KEY,
-        mode TEXT NOT NULL CHECK(mode IN ('default', 'project')),
+        mode TEXT NOT NULL CHECK(mode IN ('default', 'project', 'agent')),
         project_root TEXT,
         copilot_session_id TEXT NOT NULL,
         model TEXT,
         updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
       )
     `);
+        try {
+            db.prepare(`
+        INSERT INTO copilot_sessions (session_key, mode, copilot_session_id)
+        VALUES ('__mode_probe__', 'agent', '__probe__')
+      `).run();
+            db.prepare(`DELETE FROM copilot_sessions WHERE session_key = '__mode_probe__'`).run();
+        }
+        catch {
+            db.exec(`ALTER TABLE copilot_sessions RENAME TO copilot_sessions_old`);
+            db.exec(`
+        CREATE TABLE copilot_sessions (
+          session_key TEXT PRIMARY KEY,
+          mode TEXT NOT NULL CHECK(mode IN ('default', 'project', 'agent')),
+          project_root TEXT,
+          copilot_session_id TEXT NOT NULL,
+          model TEXT,
+          updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            db.exec(`
+        INSERT INTO copilot_sessions (session_key, mode, project_root, copilot_session_id, model, updated_at)
+        SELECT session_key, mode, project_root, copilot_session_id, model, updated_at
+        FROM copilot_sessions_old
+      `);
+            db.exec(`DROP TABLE copilot_sessions_old`);
+        }
         // Migrate: add metadata columns to conversation_log if not present
         const convCols = db.prepare(`PRAGMA table_info(conversation_log)`).all();
         if (!convCols.some((c) => c.name === 'session_key')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.4.3",
+  "version": "0.5.1",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"