chapterhouse 0.4.2 → 0.5.0

package/dist/memory/action-items.js

@@ -0,0 +1,100 @@
+import { getDb } from "../store/db.js";
+function toActionItem(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        title: row.title,
+        detail: row.detail ?? undefined,
+        status: row.status,
+        dueAt: row.due_at ?? undefined,
+        snoozeUntil: row.snooze_until ?? undefined,
+        source: row.source ?? undefined,
+        tier: row.tier,
+        tierPinnedAt: row.tier_pinned_at ?? undefined,
+        tierReason: row.tier_reason ?? undefined,
+        lastRecalledAt: row.last_recalled_at ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        resolvedAt: row.resolved_at ?? undefined,
+        resolutionReason: row.resolution_reason ?? undefined,
+    };
+}
+const ACTION_ITEM_COLUMNS = `
+  id, scope_id, entity_id, title, detail, status, due_at, snooze_until, source,
+  created_at, updated_at, resolved_at, resolution_reason, tier, tier_pinned_at,
+  tier_reason, last_recalled_at
+`;
+export function recordActionItem(input) {
+    const result = getDb().prepare(`
+    INSERT INTO mem_action_items (
+      scope_id, entity_id, title, detail, due_at, source, tier, created_at, updated_at
+    )
+    VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.entity_id ?? null, input.title, input.detail ?? null, input.due_at ?? null, input.source ?? null, input.tier ?? "warm");
+    return getActionItem(Number(result.lastInsertRowid));
+}
+export function getActionItem(id) {
+    const row = getDb().prepare(`
+    SELECT ${ACTION_ITEM_COLUMNS}
+    FROM mem_action_items
+    WHERE id = ?
+  `).get(id);
+    return row ? toActionItem(row) : undefined;
+}
+export function listActionItems(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT ${ACTION_ITEM_COLUMNS}
+    FROM mem_action_items
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (
+        ? IS NOT NULL
+        OR status = 'open'
+        OR (status = 'snoozed' AND snooze_until IS NOT NULL AND datetime(snooze_until) <= datetime('now'))
+      )
+      AND (? IS NULL OR status = ?)
+      AND (? IS NULL OR due_at IS NOT NULL AND datetime(due_at) <= datetime(?))
+      AND (? = 1 OR tier != 'cold')
+    ORDER BY
+      CASE WHEN due_at IS NULL THEN 1 ELSE 0 END ASC,
+      datetime(due_at) ASC,
+      datetime(created_at) DESC,
+      id DESC
+    LIMIT ? OFFSET ?
+  `).all(input.scope_id ?? null, input.scope_id ?? null, input.status ?? null, input.status ?? null, input.status ?? null, input.due_before ?? null, input.due_before ?? null, input.includeArchived ? 1 : 0, input.limit ?? 50, input.offset ?? 0);
+    return rows.map(toActionItem);
+}
+function resolveActionItem(id, status, reason) {
+    const result = getDb().prepare(`
+    UPDATE mem_action_items
+    SET status = ?,
+      resolved_at = CURRENT_TIMESTAMP,
+      resolution_reason = ?,
+      updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(status, reason ?? null, id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown action item id '${id}'.`);
+    }
+    return getActionItem(id);
+}
+export function completeActionItem(id, resolutionReason) {
+    return resolveActionItem(id, "done", resolutionReason);
+}
+export function dropActionItem(id, reason) {
+    return resolveActionItem(id, "dropped", reason);
+}
+export function snoozeActionItem(id, snoozeUntil) {
+    const result = getDb().prepare(`
+    UPDATE mem_action_items
+    SET status = 'snoozed',
+      snooze_until = ?,
+      updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `).run(snoozeUntil, id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown action item id '${id}'.`);
+    }
+    return getActionItem(id);
+}
+//# sourceMappingURL=action-items.js.map

package/dist/memory/action-items.test.js

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-action-items-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("action items round-trip through add, list, and complete with done hidden by default", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordActionItem = getFunction(memoryModule, "recordActionItem");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const completeActionItem = getFunction(memoryModule, "completeActionItem");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const added = recordActionItem({
+        scope_id: chapterhouse.id,
+        title: "Migrate feature ideas into memory",
+        detail: "Move feature-ideas.md into mem_action_items once the schema exists.",
+        due_at: "2026-05-15T12:00:00.000Z",
+        source: "test",
+    });
+    assert.equal(added.status, "open");
+    assert.equal(added.title, "Migrate feature ideas into memory");
+    assert.equal(added.detail, "Move feature-ideas.md into mem_action_items once the schema exists.");
+    assert.equal(added.dueAt, "2026-05-15T12:00:00.000Z");
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.id), [added.id]);
+    const completed = completeActionItem(added.id, "Migrated successfully.");
+    assert.equal(completed.status, "done");
+    assert.ok(completed.resolvedAt);
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.id), []);
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id, status: "done" }).map((item) => item.id), [added.id]);
+});
+test("snoozed action items are hidden by default until snooze_until passes", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordActionItem = getFunction(memoryModule, "recordActionItem");
+    const snoozeActionItem = getFunction(memoryModule, "snoozeActionItem");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const future = recordActionItem({ scope_id: chapterhouse.id, title: "Remind infra later", source: "test" });
+    const expired = recordActionItem({ scope_id: chapterhouse.id, title: "Reappears now", source: "test" });
+    assert.equal(snoozeActionItem(future.id, "2999-01-01T00:00:00.000Z").status, "snoozed");
+    assert.equal(snoozeActionItem(expired.id, "2000-01-01T00:00:00.000Z").status, "snoozed");
+    const defaults = listActionItems({ scope_id: chapterhouse.id });
+    assert.equal(defaults.some((item) => item.id === future.id), false);
+    assert.equal(defaults.some((item) => item.id === expired.id), true);
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id, status: "snoozed" }).map((item) => item.id).sort(), [
+        expired.id,
+        future.id,
+    ].sort());
+});
+//# sourceMappingURL=action-items.test.js.map

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/eot.js

@@ -5,6 +5,7 @@ import { recordDecision } from "./decisions.js";
 import { upsertEntity } from "./entities.js";
 import { listPendingMemoryProposalsForTask, resolveInboxItem } from "./inbox.js";
 import { recordObservation } from "./observations.js";
+import { recordActionItem } from "./action-items.js";
 import { getScope } from "./scopes.js";
 const log = childLogger("memory.eot");
 function isEndOfTaskHookEnabled() {
@@ -30,6 +31,8 @@ function buildReviewerSystemPrompt() {
         "Optionally extract additional implicit durable memories from the task summary.",
         "Return JSON only with keys: decisions, implicit_memories.",
         "Each decision must include proposal_id, decision, reason.",
+        "Supported kinds are observation, decision, entity, and action_item.",
+        "Entity payloads must include name and entity_kind.",
         "Each implicit memory must include kind, scope_slug, payload, and may include confidence/reason.",
     ].join("\n");
 }
@@ -48,7 +51,10 @@ function parseEnvelope(raw) {
     if (!parsed || typeof parsed !== "object") {
         throw new Error("Invalid memory proposal payload.");
     }
-    if (parsed.kind !== "observation" && parsed.kind !== "decision" && parsed.kind !== "entity") {
+    if (parsed.kind !== "observation"
+        && parsed.kind !== "decision"
+        && parsed.kind !== "entity"
+        && parsed.kind !== "action_item") {
         throw new Error("Invalid proposal kind.");
     }
     if (!parsed.payload || typeof parsed.payload !== "object") {
@@ -93,7 +99,10 @@ function parseReviewerResponse(raw) {
                     return [];
                 }
                 const candidate = entry;
-                if (candidate.kind !== "observation" && candidate.kind !== "decision" && candidate.kind !== "entity") {
+                if (candidate.kind !== "observation"
+                    && candidate.kind !== "decision"
+                    && candidate.kind !== "entity"
+                    && candidate.kind !== "action_item") {
                     return [];
                 }
                 if (typeof candidate.scope_slug !== "string" || !candidate.payload || typeof candidate.payload !== "object") {
@@ -136,10 +145,26 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
         });
         return;
     }
+    if (kind === "action_item") {
+        const actionItem = payload;
+        recordActionItem({
+            scope_id: scope.id,
+            entity_id: actionItem.entity_id,
+            title: actionItem.title,
+            detail: actionItem.detail,
+            due_at: actionItem.due_at,
+            source: actionItem.source ?? source,
+        });
+        return;
+    }
     const entity = payload;
+    const entityKind = entity.entity_kind ?? entity.kind;
+    if (!entityKind) {
+        throw new Error("Entity proposal payload requires entity_kind.");
+    }
     upsertEntity({
         scope_id: scope.id,
-        kind: entity.kind,
+        kind: entityKind,
         name: entity.name,
         summary: entity.summary,
         confidence,

package/dist/memory/eot.test.js

@@ -155,6 +155,85 @@ test("runEndOfTaskMemoryHook accepts matching proposals, rejects others from the
             auto_accept: true,
         }]);
 });
+test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-accept");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    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', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Migrate feature ideas",
+            detail: "Move feature-ideas.md into mem_action_items.",
+            source: "subagent_proposal",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item",
+        finalResult: "Completed and proposed a follow-up action item.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    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 inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "accepted");
+});
+test("runEndOfTaskMemoryHook accepts entity proposals with entity_kind into mem_entities", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("entity-accept");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    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-entity', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "entity",
+        payload: {
+            name: "truenas",
+            entity_kind: "host",
+            summary: "NAS host used by Bellonda.",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-entity",
+        finalResult: "Completed and proposed a durable host entity.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Durable entity.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const entities = listEntities({ scope_id: chapterhouse.id, kind: "host" });
+    assert.equal(entities.some((entity) => entity.name === "truenas"
+        && entity.kind === "host"
+        && entity.summary === "NAS host used by Bellonda."), true);
+    const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "accepted");
+});
 test("runEndOfTaskMemoryHook leaves reviewed proposals pending when CHAPTERHOUSE_MEMORY_AUTO_ACCEPT=0", async () => {
     process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT = "0";
     const { dbModule, memoryModule, eotModule } = await loadModules("pending");
@@ -260,4 +339,33 @@ test("runEndOfTaskMemoryHook can persist implicit extracted memories that were n
             auto_accept: true,
         }]);
 });
+test("runEndOfTaskMemoryHook accepts implicit entity memories with entity_kind", async () => {
+    const { memoryModule, eotModule } = await loadModules("implicit-entity");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-entity",
+        finalResult: "The subagent discovered a durable host entity while finishing the task.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "entity",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        name: "synology",
+                        entity_kind: "host",
+                        summary: "NAS host used by Bellonda.",
+                    },
+                }],
+        }),
+    });
+    const entities = listEntities({ scope_id: chapterhouse.id, kind: "host" });
+    assert.equal(entities.some((entity) => entity.name === "synology"
+        && entity.kind === "host"
+        && entity.summary === "NAS host used by Bellonda."), true);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/memory/hot-tier.js

@@ -2,6 +2,7 @@ import { getDb } from "../store/db.js";
 import { getActiveScope } from "./active-scope.js";
 import { getScope } from "./scopes.js";
 const HOT_TIER_LIMIT = 30;
+const HOT_TIER_ACTION_ITEM_LIMIT = 10;
 function toEntity(row) {
     return {
         id: row.id,
@@ -44,6 +45,27 @@ function toDecision(row) {
         createdAt: row.created_at,
     };
 }
+function toActionItem(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        title: row.title,
+        detail: row.detail ?? undefined,
+        status: row.status,
+        dueAt: row.due_at ?? undefined,
+        snoozeUntil: row.snooze_until ?? undefined,
+        source: row.source ?? undefined,
+        tier: row.tier,
+        tierPinnedAt: row.tier_pinned_at ?? undefined,
+        tierReason: row.tier_reason ?? undefined,
+        lastRecalledAt: row.last_recalled_at ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        resolvedAt: row.resolved_at ?? undefined,
+        resolutionReason: row.resolution_reason ?? undefined,
+    };
+}
 function escapeXmlText(value) {
     return value
         .replaceAll("&", "&")
@@ -108,6 +130,27 @@ function loadHotDecisions(scopeId, options) {
   `).all(scopeId, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0, HOT_TIER_LIMIT);
     return rows.map((row) => ({ ...toDecision(row), sortKey: row.decided_at }));
 }
+function loadOpenActionItems(scopeId) {
+    const rows = getDb().prepare(`
+    SELECT
+      id, scope_id, entity_id, title, detail, status, due_at, snooze_until, source,
+      created_at, updated_at, resolved_at, resolution_reason, tier, tier_pinned_at,
+      tier_reason, last_recalled_at
+    FROM mem_action_items
+    WHERE scope_id = ?
+      AND (
+        status = 'open'
+        OR (status = 'snoozed' AND snooze_until IS NOT NULL AND datetime(snooze_until) <= datetime('now'))
+      )
+    ORDER BY
+      CASE WHEN due_at IS NULL THEN 1 ELSE 0 END ASC,
+      datetime(due_at) ASC,
+      datetime(created_at) DESC,
+      id DESC
+    LIMIT ?
+  `).all(scopeId, HOT_TIER_ACTION_ITEM_LIMIT);
+    return rows.map(toActionItem);
+}
 export function getHotTierEntries(scope_id, options = {}) {
     const scope = getHotTierScope(scope_id);
     if (!scope) {
@@ -116,6 +159,7 @@ export function getHotTierEntries(scope_id, options = {}) {
             entities: [],
             observations: [],
             decisions: [],
+            actionItems: [],
         };
     }
     const merged = [
@@ -130,13 +174,17 @@ export function getHotTierEntries(scope_id, options = {}) {
         entities: merged.filter((entry) => entry.type === "entity"),
         observations: merged.filter((entry) => entry.type === "observation"),
         decisions: merged.filter((entry) => entry.type === "decision"),
+        actionItems: loadOpenActionItems(scope.id),
     };
 }
 export function renderHotTierXML(entries) {
     if (!entries.scope) {
         return "";
     }
-    if (entries.entities.length === 0 && entries.observations.length === 0 && entries.decisions.length === 0) {
+    if (entries.entities.length === 0
+        && entries.observations.length === 0
+        && entries.decisions.length === 0
+        && entries.actionItems.length === 0) {
         return "";
     }
     const observationsByEntity = new Map();
@@ -174,6 +222,17 @@ export function renderHotTierXML(entries) {
         const truncated = truncateObservation(observation.content);
         lines.push(`  <observation id="observation-${observation.id}" tier="${escapeXmlAttr(observation.tier)}" confidence="${observation.confidence}" created_at="${escapeXmlAttr(observation.createdAt)}"${truncated.truncated ? ` truncated="true"` : ""}>`, `    ${escapeXmlText(truncated.content)}`, "  </observation>");
     }
+    if (entries.actionItems.length > 0) {
+        lines.push("  <action_items>");
+        for (const item of entries.actionItems) {
+            lines.push(`    <action_item id="action-item-${item.id}" status="${escapeXmlAttr(item.status)}" created_at="${escapeXmlAttr(item.createdAt)}"${item.dueAt ? ` due_at="${escapeXmlAttr(item.dueAt)}"` : ""}>`, `      <title>${escapeXmlText(item.title)}</title>`);
+            if (item.detail) {
+                lines.push(`      <detail>${escapeXmlText(item.detail)}</detail>`);
+            }
+            lines.push("    </action_item>");
+        }
+        lines.push("  </action_items>");
+    }
     lines.push("</memory_context>");
     return `${lines.join("\n")}\n`;
 }

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

@@ -41,6 +41,7 @@ test("renderHotTierForActiveScope returns an empty string when no active scope i
         entities: [],
         observations: [],
         decisions: [],
+        actionItems: [],
     });
 });
 test("renderHotTierXML escapes content, merges recency across stores, and enforces the 30-entry cap", async () => {
@@ -130,6 +131,43 @@ test("active-scope hot-tier queries do not leak rows from other scopes", async (
     assert.match(xml, /Chapterhouse hot entry/);
     assert.doesNotMatch(xml, /Team-only hot entry/);
 });
+test("renderHotTierXML includes open active-scope action items in a bounded action_items block", async () => {
+    const { dbModule, memoryModule, hotTierModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordActionItem = getFunction(memoryModule, "recordActionItem");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse);
+    assert.ok(team);
+    const urgent = recordActionItem({
+        scope_id: chapterhouse.id,
+        title: "Migrate <feature ideas>",
+        detail: "Move feature-ideas.md into memory & keep source links.",
+        due_at: "2026-05-14T12:00:00.000Z",
+        source: "test",
+    });
+    recordActionItem({
+        scope_id: chapterhouse.id,
+        title: "Undated backlog item",
+        detail: "Should appear after dated items.",
+        source: "test",
+    });
+    recordActionItem({
+        scope_id: team.id,
+        title: "Other scope action",
+        source: "test",
+    });
+    const entries = hotTierModule.getHotTierEntries(chapterhouse.id);
+    const xml = hotTierModule.renderHotTierXML(entries);
+    assert.equal(entries.actionItems.length, 2);
+    assert.match(xml, /<action_items>/);
+    assert.match(xml, new RegExp(`<action_item[^>]*id="action-item-${urgent.id}"[^>]*status="open"`));
+    assert.match(xml, /<title>Migrate &lt;feature ideas&gt;<\/title>/);
+    assert.match(xml, /<detail>Move feature-ideas\.md into memory &amp; keep source links\.<\/detail>/);
+    assert.ok(xml.indexOf("Migrate &lt;feature ideas&gt;") < xml.indexOf("Undated backlog item"));
+    assert.doesNotMatch(xml, /Other scope action/);
+});
 test("hot-tier entries exclude superseded and archived observations and decisions by default with opt-in inclusion", async () => {
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     const db = dbModule.getDb();