hippo-memory 1.70.0 → 1.72.0

package/dist/store/capture-write.js

@@ -0,0 +1,35 @@
+import { closeHippoDb } from '../db/index.js';
+import { duplicateKey } from '../util/same-text.js';
+import { writeEntryMirrors } from './entry-writes.js';
+import { stampOriginProject } from './entry-row.js';
+import { gatedWrite } from './gated-write.js';
+import { updateStatsOn } from './index-and-stats.js';
+import { openStore } from './open.js';
+/** One outcome per item, in order. `keys` holds the texts already stored and gains each one written, so a repeat inside the batch is skipped. */
+export function writeCapturedItems(hippoRoot, items, keys, opts) {
+    const db = openStore(hippoRoot);
+    try {
+        return items.map((item) => {
+            if (keys.has(duplicateKey(item.content)))
+                return 'skipped';
+            const entry = item.makeEntry();
+            // One rejected item must not abort the rest of this capture's items.
+            const stamped = stampOriginProject(hippoRoot, entry);
+            const outcome = gatedWrite(db, hippoRoot, stamped, { actor: opts.actor });
+            if (outcome === 'skipped:rejected')
+                return 'rejected';
+            if (outcome !== 'written')
+                return 'skipped';
+            writeEntryMirrors(hippoRoot, stamped);
+            if (!opts.lean)
+                updateStatsOn(db, hippoRoot, { remembered: 1 });
+            keys.add(duplicateKey(item.content)); // within-batch dedup
+            opts.onCaptured?.(entry);
+            return 'captured';
+        });
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+//# sourceMappingURL=capture-write.js.map

package/dist/store/card-detail.d.ts

@@ -9,6 +9,7 @@ export interface CardDetail {
     comments: CardComment[];
     handoff: SessionHandoff | null;
 }
-/** Loads the detail behind `hippo card show` and `GET /api/cards/:id` (null when the tenant has no such card); five separate reads, so a write landing between them can show a mixed view, as `card show` always could. */
+/** Loads the detail behind `hippo card show` and `GET /api/cards/:id` (null when the tenant has no such card);
+ * five separate reads, so a write landing between them can show a mixed view, as `card show` always could. */
 export declare function loadCardDetail(hippoRoot: string, tenantId: string, id: string): CardDetail | null;
 //# sourceMappingURL=card-detail.d.ts.map

package/dist/store/card-detail.js

@@ -1,5 +1,6 @@
 import { loadCard, loadCardComments, loadCardDeps, loadCardRuns, loadLatestHandoffForCard } from './cards.js';
-/** Loads the detail behind `hippo card show` and `GET /api/cards/:id` (null when the tenant has no such card); five separate reads, so a write landing between them can show a mixed view, as `card show` always could. */
+/** Loads the detail behind `hippo card show` and `GET /api/cards/:id` (null when the tenant has no such card);
+ * five separate reads, so a write landing between them can show a mixed view, as `card show` always could. */
 export function loadCardDetail(hippoRoot, tenantId, id) {
     const card = loadCard(hippoRoot, tenantId, id);
     if (!card)

package/dist/store/cards.d.ts

@@ -1,4 +1,3 @@
-import { type DatabaseSyncLike } from '../db/index.js';
 import { SessionHandoff, HandoffOutcome } from '../core/handoff.js';
 import { Card, CardStatus, CardRun, CardComment } from '../core/card.js';
 export interface TransitionCardOptions {
@@ -10,8 +9,8 @@ export interface TransitionCardOptions {
         params?: unknown[];
     };
 }
-export declare function transitionCard(db: DatabaseSyncLike, tenantId: string, cardId: string, options: TransitionCardOptions): number;
-/** Creates a card; status is ready with no deps or once every dependsOn id is done, else backlog. An unknown dependsOn id throws and commits nothing. A repeated dependsOn id is recorded once. */
+/** Creates a card; status is ready with no deps or once every dependsOn id is done, else backlog.
+ * An unknown dependsOn id throws and commits nothing. A repeated dependsOn id is recorded once. */
 export declare function createCard(hippoRoot: string, tenantId: string, input: {
     title: string;
     repo?: string;
@@ -36,22 +35,28 @@ export declare function loadCardRuns(hippoRoot: string, tenantId: string, id: st
 export declare function loadCardComments(hippoRoot: string, tenantId: string, id: string): CardComment[];
 /** Read side of the card <-> handoff round trip: the newest handoff filed against this card. */
 export declare function loadLatestHandoffForCard(hippoRoot: string, tenantId: string, cardId: string): SessionHandoff | null;
-/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown card id; returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new run's id as runId. */
+/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown card id;
+ * returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new run's id as runId. */
 export declare function claimCard(hippoRoot: string, tenantId: string, id: string, runtime: string, sessionId?: string): (Card & {
     runId: number;
 }) | null;
-/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws on an unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId is its live run. */
+/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws on an
+ * unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId is its live run. */
 export declare function heartbeatCard(hippoRoot: string, tenantId: string, id: string, runId: number): Card | null;
-/** Requires the card be running; closes the live run as blocked and files reason as a comment. Throws on an unknown card id; returns null for a card not running. When runId is given, returns null unless it is the card's live run. */
+/** Requires the card be running; closes the live run as blocked and files reason as a comment. Throws on an unknown
+ * card id; returns null for a card not running. When runId is given, returns null unless it is the card's live run. */
 export declare function blockCard(hippoRoot: string, tenantId: string, id: string, reason: string, runId?: number): Card | null;
-/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When runId is given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card not running. */
+/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When runId is
+ * given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card not running. */
 export declare function reviewCard(hippoRoot: string, tenantId: string, id: string, runId?: number): Card | null;
-/** Requires the card be in review; closes the live run with outcome. Outcome 'success' moves the card to done and, in the same transaction, promotes any child whose parents are now all done; 'failure' or 'partial' moves it to shelved and promotes nothing. Throws on an unknown card id; returns null for a card not in review. When runId is given, returns null unless it is the card's live run. */
+/** Closes the live run of a card in review: 'success' moves it to done and promotes children whose parents are all done; 'failure'/'partial' shelves it.
+ * Throws on an unknown card id; returns null for a card not in review, or when `runId` is given and is not the card's live run. */
 export declare function completeCard(hippoRoot: string, tenantId: string, id: string, outcome: HandoffOutcome, runId?: number): {
     card: Card;
     promotedChildren: string[];
 } | null;
-/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes its live run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card ids in id order. */
+/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes its live
+ * run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card ids in id order. */
 export declare function reclaimExpiredCards(hippoRoot: string, tenantId: string): string[];
 /** Appends a comment to cardId in any card status; throws if cardId is not a card of this tenant. */
 export declare function addCardComment(hippoRoot: string, tenantId: string, cardId: string, author: string, body: string): CardComment;

package/dist/store/cards.js

@@ -1,9 +1,10 @@
 import { generateId } from '../core/memory.js';
-import { closeHippoDb, withWriteScope, withWriteScopeOr } from '../db/index.js';
+import { withWriteScope, withWriteScopeOr } from '../db/index.js';
 import { rowToSessionHandoff, isHandoffOutcome } from '../core/handoff.js';
-import { CARD_TRANSITIONS, CARD_LEASE_MS } from '../core/card.js';
+import { CARD_LEASE_MS, assertCardTransition } from '../core/card.js';
 import { assertTenantId } from './tenant.js';
-import { openStore } from './open.js';
+import { onHandle, openStore } from './open.js';
+import { chunked } from '../util/chunked.js';
 import { HANDOFF_COLUMNS } from './handoffs.js';
 const CARD_COLUMNS = 'id, title, status, assignee_runtime, repo, contract, budget, lease_until, heartbeat_at, created_at, updated_at, tenant_id, scope';
 function rowToCard(row) {
@@ -77,26 +78,27 @@ function closeLiveRun(db, tenantId, cardId, outcome, now) {
     WHERE card = ? AND tenant_id = ? AND ended IS NULL
   `).run(now, outcome, now, cardId, tenantId);
 }
-export function transitionCard(db, tenantId, cardId, options) {
+function transitionCard(db, tenantId, cardId, options) {
+    return transitionCards(db, tenantId, [cardId], options);
+}
+/** transitionCard for every card in `cardIds`, as one statement with one timestamp; returns how many moved. */
+function transitionCards(db, tenantId, cardIds, options) {
     const { from, to, extra } = options;
-    for (const status of from) {
-        if (!CARD_TRANSITIONS[status].includes(to)) {
-            throw new Error(`illegal card transition: ${status} -> ${to}`);
-        }
-    }
+    assertCardTransition(from, to);
     const now = new Date().toISOString();
     // Lease columns follow status: set on the move to running, cleared on every other move (rule 15).
     const lease = to === 'running' ? [leaseUntilFrom(now), now] : [null, null];
     const fromPlaceholders = from.map(() => '?').join(', ');
     const sql = `
     UPDATE cards SET status = ?, updated_at = ?, lease_until = ?, heartbeat_at = ?${extra?.setSql ? `, ${extra.setSql}` : ''}
-    WHERE id = ? AND tenant_id = ? AND status IN (${fromPlaceholders})${extra?.whereSql ? ` AND ${extra.whereSql}` : ''}
+    WHERE id IN (${cardIds.map(() => '?').join(', ')}) AND tenant_id = ? AND status IN (${fromPlaceholders})${extra?.whereSql ? ` AND ${extra.whereSql}` : ''}
   `;
-    const params = [to, now, ...lease, ...(extra?.params ?? []), cardId, tenantId, ...from];
+    const params = [to, now, ...lease, ...(extra?.params ?? []), ...cardIds, tenantId, ...from];
     const result = db.prepare(sql).run(...params);
     return Number(result.changes ?? 0);
 }
-/** Creates a card; status is ready with no deps or once every dependsOn id is done, else backlog. An unknown dependsOn id throws and commits nothing. A repeated dependsOn id is recorded once. */
+/** Creates a card; status is ready with no deps or once every dependsOn id is done, else backlog.
+ * An unknown dependsOn id throws and commits nothing. A repeated dependsOn id is recorded once. */
 export function createCard(hippoRoot, tenantId, input) {
     assertTenantId('createCard', tenantId);
     if (input.title.trim() === '') {
@@ -105,8 +107,7 @@ export function createCard(hippoRoot, tenantId, input) {
     if (input.budget !== undefined && !(Number.isSafeInteger(input.budget) && input.budget > 0)) {
         throw new Error(`Invalid budget: ${input.budget} (expected a positive integer)`);
     }
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const dependsOn = [...new Set(input.dependsOn ?? [])];
         let id = '';
         withWriteScope(db, 'create_card', () => {
@@ -120,17 +121,14 @@ export function createCard(hippoRoot, tenantId, input) {
         INSERT INTO cards (id, title, status, repo, contract, budget, created_at, updated_at, tenant_id)
         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       `).run(id, input.title, status, input.repo ?? null, input.contract ?? null, input.budget ?? null, now, now, tenantId);
-            for (const parentId of dependsOn) {
-                db.prepare(`
-          INSERT INTO card_deps (parent, child, tenant_id, created_at) VALUES (?, ?, ?, ?)
-        `).run(parentId, id, tenantId, now);
-            }
+            const insertDep = db.prepare(`
+        INSERT INTO card_deps (parent, child, tenant_id, created_at) VALUES (?, ?, ?, ?)
+      `);
+            for (const parentId of dependsOn)
+                insertDep.run(parentId, id, tenantId, now);
         });
         return loadCardRow(db, tenantId, id);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Whether every dependsOn card is done, true for none; throws on an id that is no card of the tenant. Call inside the write scope. */
 function everyParentDone(db, tenantId, dependsOn) {
@@ -151,19 +149,14 @@ function everyParentDone(db, tenantId, dependsOn) {
 /** Returns the card row for id, or null if it does not exist under this tenant. */
 export function loadCard(hippoRoot, tenantId, id) {
     assertTenantId('loadCard', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         return loadCardRow(db, tenantId, id);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Lists cards for this tenant, optionally filtered to one status, newest-updated first. */
 export function listCards(hippoRoot, tenantId, opts = {}) {
     assertTenantId('listCards', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const conditions = ['tenant_id = ?'];
         const params = [tenantId];
         if (opts.status) {
@@ -175,82 +168,63 @@ export function listCards(hippoRoot, tenantId, opts = {}) {
       SELECT ${CARD_COLUMNS} FROM cards WHERE ${conditions.join(' AND ')} ORDER BY updated_at DESC, id DESC
     `).all(...params);
         return rows.map(rowToCard);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Returns this card's parent and child ids from card_deps. */
 export function loadCardDeps(hippoRoot, tenantId, id) {
     assertTenantId('loadCardDeps', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         // SAFETY: rows' shape matches the single `parent` column named in the SELECT below.
         const parents = db.prepare(`SELECT parent FROM card_deps WHERE tenant_id = ? AND child = ?`).all(tenantId, id).map((r) => r.parent);
         // SAFETY: rows' shape matches the single `child` column named in the SELECT below.
         const children = db.prepare(`SELECT child FROM card_deps WHERE tenant_id = ? AND parent = ?`).all(tenantId, id).map((r) => r.child);
         return { parents, children };
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Returns this card's run history, most recent first. */
 export function loadCardRuns(hippoRoot, tenantId, id) {
     assertTenantId('loadCardRuns', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         // SAFETY: rows' shape matches CardRunRow.
         const rows = db.prepare(`
       SELECT id, card, runtime, session_id, started, ended, outcome
       FROM card_runs WHERE tenant_id = ? AND card = ? ORDER BY started DESC, id DESC
     `).all(tenantId, id);
         return rows.map(rowToCardRun);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Returns this card's comments, most recent first. */
 export function loadCardComments(hippoRoot, tenantId, id) {
     assertTenantId('loadCardComments', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         // SAFETY: rows' shape matches CardCommentRow.
         const rows = db.prepare(`
       SELECT id, card_id, author, body, created_at
       FROM card_comments WHERE tenant_id = ? AND card_id = ? ORDER BY created_at DESC, id DESC
     `).all(tenantId, id);
         return rows.map(rowToCardComment);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Read side of the card <-> handoff round trip: the newest handoff filed against this card. */
 export function loadLatestHandoffForCard(hippoRoot, tenantId, cardId) {
     assertTenantId('loadLatestHandoffForCard', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         // SAFETY: row's shape matches HANDOFF_COLUMNS.
         const row = db.prepare(`
       SELECT ${HANDOFF_COLUMNS} FROM session_handoffs
       WHERE tenant_id = ? AND card_id = ? ORDER BY created_at DESC, id DESC LIMIT 1
     `).get(tenantId, cardId);
         return row ? rowToSessionHandoff(row) : null;
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
-/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown card id; returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new run's id as runId. */
+/** Atomic claim: WHERE status IN (ready, blocked) AND assignee_runtime IS NULL decides the race. Throws on an unknown card id;
+ * returns null for a card not ready/blocked or already claimed. Sets a CARD_LEASE_MS lease and returns the new run's id as runId. */
 export function claimCard(hippoRoot, tenantId, id, runtime, sessionId) {
     assertTenantId('claimCard', tenantId);
     if (runtime.trim() === '') {
         throw new Error('runtime must not be empty');
     }
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const runId = withWriteScopeOr(db, 'claim_card', (rollback) => {
             const changes = transitionCard(db, tenantId, id, {
                 from: ['ready', 'blocked'],
@@ -271,17 +245,14 @@ export function claimCard(hippoRoot, tenantId, id, runtime, sessionId) {
             return Number(insert.lastInsertRowid ?? 0);
         });
         return runId === null ? null : { ...loadCardRow(db, tenantId, id), runId };
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
-/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws on an unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId is its live run. */
+/** Moves a running card's lease to CARD_LEASE_MS from now and records the heartbeat; updated_at is left alone. Throws on an
+ * unknown card id or a run id that is not a positive integer; returns null unless the card is running and runId is its live run. */
 export function heartbeatCard(hippoRoot, tenantId, id, runId) {
     assertTenantId('heartbeatCard', tenantId);
     assertRunId(runId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const beat = withWriteScopeOr(db, 'heartbeat_card', (rollback) => {
             const card = loadCardRow(db, tenantId, id);
             if (!card) {
@@ -296,12 +267,10 @@ export function heartbeatCard(hippoRoot, tenantId, id, runId) {
             return true;
         });
         return beat ? loadCardRow(db, tenantId, id) : null;
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
-/** Requires the card be running; closes the live run as blocked and files reason as a comment. Throws on an unknown card id; returns null for a card not running. When runId is given, returns null unless it is the card's live run. */
+/** Requires the card be running; closes the live run as blocked and files reason as a comment. Throws on an unknown
+ * card id; returns null for a card not running. When runId is given, returns null unless it is the card's live run. */
 export function blockCard(hippoRoot, tenantId, id, reason, runId) {
     assertTenantId('blockCard', tenantId);
     if (reason.trim() === '') {
@@ -309,8 +278,7 @@ export function blockCard(hippoRoot, tenantId, id, reason, runId) {
     }
     if (runId !== undefined)
         assertRunId(runId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const blocked = withWriteScopeOr(db, 'block_card', (rollback) => {
             const allowed = runId === undefined || isLiveRun(db, tenantId, id, runId);
             const changes = allowed ? transitionCard(db, tenantId, id, { from: ['running'], to: 'blocked', extra: { setSql: 'assignee_runtime = NULL' } }) : 0;
@@ -327,18 +295,15 @@ export function blockCard(hippoRoot, tenantId, id, reason, runId) {
             return true;
         });
         return blocked ? loadCardRow(db, tenantId, id) : null;
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
-/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When runId is given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card not running. */
+/** Requires the card be running; moves it to review, clearing its lease and heartbeat and keeping its live run. When runId is
+ * given, returns null unless it is the card's live run. Throws on an unknown card id; returns null for a card not running. */
 export function reviewCard(hippoRoot, tenantId, id, runId) {
     assertTenantId('reviewCard', tenantId);
     if (runId !== undefined)
         assertRunId(runId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const moved = withWriteScopeOr(db, 'review_card', (rollback) => {
             const allowed = runId === undefined || isLiveRun(db, tenantId, id, runId);
             const changes = allowed ? transitionCard(db, tenantId, id, { from: ['running'], to: 'review' }) : 0;
@@ -351,12 +316,10 @@ export function reviewCard(hippoRoot, tenantId, id, runId) {
             return true;
         });
         return moved ? loadCardRow(db, tenantId, id) : null;
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
-/** Requires the card be in review; closes the live run with outcome. Outcome 'success' moves the card to done and, in the same transaction, promotes any child whose parents are now all done; 'failure' or 'partial' moves it to shelved and promotes nothing. Throws on an unknown card id; returns null for a card not in review. When runId is given, returns null unless it is the card's live run. */
+/** Closes the live run of a card in review: 'success' moves it to done and promotes children whose parents are all done; 'failure'/'partial' shelves it.
+ * Throws on an unknown card id; returns null for a card not in review, or when `runId` is given and is not the card's live run. */
 export function completeCard(hippoRoot, tenantId, id, outcome, runId) {
     assertTenantId('completeCard', tenantId);
     if (!isHandoffOutcome(outcome)) {
@@ -364,8 +327,7 @@ export function completeCard(hippoRoot, tenantId, id, outcome, runId) {
     }
     if (runId !== undefined)
         assertRunId(runId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         const promoted = withWriteScopeOr(db, 'complete_card', (rollback) => {
             const target = outcome === 'success' ? 'done' : 'shelved';
             const allowed = runId === undefined || isLiveRun(db, tenantId, id, runId);
@@ -383,38 +345,29 @@ export function completeCard(hippoRoot, tenantId, id, outcome, runId) {
             return target === 'done' ? promoteUnblockedChildren(db, tenantId, id) : [];
         });
         return promoted === null ? null : { card: loadCardRow(db, tenantId, id), promotedChildren: promoted };
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Moves to ready each backlog child of `parentId` whose parents are all done, and returns their ids. Call inside the write scope. */
 function promoteUnblockedChildren(db, tenantId, parentId) {
-    const promotedChildren = [];
-    // SAFETY: rows' shape matches the single `child` column named in the SELECT below.
-    const children = db.prepare(`SELECT child FROM card_deps WHERE tenant_id = ? AND parent = ?`).all(tenantId, parentId).map((r) => r.child);
-    for (const childId of children) {
-        // SAFETY: row's shape matches the single `status` column named in the SELECT below.
-        const child = db.prepare(`SELECT status FROM cards WHERE tenant_id = ? AND id = ?`).get(tenantId, childId);
-        if (!child || child.status !== 'backlog')
-            continue;
-        // SAFETY: rows' shape matches the single `parent` column named in the SELECT below.
-        const parents = db.prepare(`SELECT parent FROM card_deps WHERE tenant_id = ? AND child = ?`).all(tenantId, childId).map((r) => r.parent);
-        const placeholders = parents.map(() => '?').join(', ');
-        // SAFETY: row's shape matches the single `c` column named in the SELECT below.
-        const doneCount = db.prepare(`SELECT COUNT(*) as c FROM cards WHERE tenant_id = ? AND id IN (${placeholders}) AND status = 'done'`).get(tenantId, ...parents).c;
-        if (doneCount === parents.length) {
-            transitionCard(db, tenantId, childId, { from: ['backlog'], to: 'ready' });
-            promotedChildren.push(childId);
-        }
-    }
-    return promotedChildren;
+    // The child's status and its open parents are result columns, not joins, so the rows keep the order of a plain read of the parent's children.
+    // SAFETY: rows' shape matches the three columns named in the SELECT below.
+    const children = db.prepare(`
+    SELECT d.child AS child,
+      (SELECT c.status FROM cards c WHERE c.tenant_id = ? AND c.id = d.child) AS status,
+      (SELECT COUNT(*) FROM card_deps p WHERE p.tenant_id = ? AND p.child = d.child
+        AND NOT EXISTS (SELECT 1 FROM cards pc WHERE pc.tenant_id = ? AND pc.id = p.parent AND pc.status = 'done')) AS open_parents
+    FROM card_deps d WHERE d.tenant_id = ? AND d.parent = ?
+  `).all(tenantId, tenantId, tenantId, tenantId, parentId);
+    const unblocked = children.filter((r) => r.status === 'backlog' && r.open_parents === 0).map((r) => r.child);
+    for (const ids of chunked(unblocked))
+        transitionCards(db, tenantId, ids, { from: ['backlog'], to: 'ready' });
+    return unblocked;
 }
-/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes its live run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card ids in id order. */
+/** Returns to ready every running card of the tenant whose lease has expired or is missing: clears its assignee, closes its live
+ * run as 'reclaimed' and leaves its handoffs alone, all in one write transaction. Returns the reclaimed card ids in id order. */
 export function reclaimExpiredCards(hippoRoot, tenantId) {
     assertTenantId('reclaimExpiredCards', tenantId);
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         return withWriteScope(db, 'reclaim_expired_cards', () => {
             // Read lease times under the write lock, so a heartbeat that committed while we waited wins.
             const now = new Date().toISOString();
@@ -430,10 +383,7 @@ export function reclaimExpiredCards(hippoRoot, tenantId) {
             }
             return ids;
         });
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 /** Appends a comment to cardId in any card status; throws if cardId is not a card of this tenant. */
 export function addCardComment(hippoRoot, tenantId, cardId, author, body) {
@@ -441,12 +391,8 @@ export function addCardComment(hippoRoot, tenantId, cardId, author, body) {
     if (body.trim() === '') {
         throw new Error('body must not be empty');
     }
-    const db = openStore(hippoRoot);
-    try {
+    return onHandle(hippoRoot, (db) => {
         return insertCardComment(db, tenantId, cardId, author, body);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    }, openStore);
 }
 //# sourceMappingURL=cards.js.map

package/dist/store/compaction-caller.d.ts

@@ -0,0 +1,18 @@
+import { type CompactionStart, type Log } from './compactions-record.js';
+/** {@link startCompaction} on a handle of its own, for a caller's request. */
+export declare function startCompactionAt(hippoRoot: string, tenantId: string, start: CompactionStart): string;
+/** {@link markSnapshotSaved} on a handle of its own, for a caller's request. */
+export declare function markSnapshotSavedAt(hippoRoot: string, tenantId: string, recordId: string): void;
+export interface CallerItems {
+    readonly sessionId: string;
+    readonly trigger: string | null;
+    readonly requestId: string;
+    readonly project: string;
+    readonly items: readonly string[];
+    /** The caller's audit actor and its project's names. */
+    readonly owner: string;
+    readonly origins: readonly string[];
+}
+/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count, and a `summarised` one is reused. */
+export declare function saveCallerItems(hippoRoot: string, tenantId: string, req: CallerItems, log: Log): number;
+//# sourceMappingURL=compaction-caller.d.ts.map

package/dist/store/compaction-caller.js

@@ -0,0 +1,29 @@
+// A caller's compaction calls on a handle of its own, for code that has a folder and no connection.
+import { onHandle } from './open.js';
+import { compactionByRequest, markSnapshotSaved, recordSummary, saveItems, startCompaction, } from './compactions-record.js';
+/** {@link startCompaction} on a handle of its own, for a caller's request. */
+export function startCompactionAt(hippoRoot, tenantId, start) {
+    return onHandle(hippoRoot, (db) => startCompaction(db, tenantId, start));
+}
+/** {@link markSnapshotSaved} on a handle of its own, for a caller's request. */
+export function markSnapshotSavedAt(hippoRoot, tenantId, recordId) {
+    onHandle(hippoRoot, (db) => markSnapshotSaved(db, tenantId, recordId));
+}
+/** A caller's items, already scrubbed, under its record: a retry of a finished request answers with the first count, and a `summarised` one is reused. */
+export function saveCallerItems(hippoRoot, tenantId, req, log) {
+    return onHandle(hippoRoot, (db) => {
+        const earlier = compactionByRequest(db, tenantId, req.requestId, req.sessionId);
+        if (earlier !== null && earlier.status !== 'summarised')
+            return earlier.itemsWritten;
+        const meta = { sessionId: req.sessionId, trigger: req.trigger, cwd: null, transcriptPath: null };
+        const text = { summary: '', items: [...req.items] };
+        const record = earlier ?? recordSummary(db, hippoRoot, tenantId, {
+            meta, text, at: new Date(), caller: { originProject: req.project, requestId: req.requestId },
+        });
+        return saveItems(db, hippoRoot, {
+            tenantId, recordId: record.id, sessionId: req.sessionId, originProject: record.originProject, cwd: null,
+            items: record.items, caller: { actor: req.owner, origins: req.origins },
+        }, log);
+    });
+}
+//# sourceMappingURL=compaction-caller.js.map