hippo-memory 1.56.0 → 1.58.0

package/dist/session-digest.js

@@ -2,7 +2,8 @@
 import { createHash } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
-import { collectSessionTurns, errorMessage, isObjectLike, isStringValue, readTranscriptTail, splitSentences, } from './capture.js';
+import { collectSessionTurns, errorMessage, readTranscriptTail, splitSentences, } from './capture.js';
+import { isObjectLike, isStringValue } from './capture-contract.js';
 import { PATCH_SUCCESS_LINE, patchPaths, shellPatch } from './codex-patch.js';
 import { loadConfig } from './config.js';
 import { createMemory, Layer } from './memory.js';

package/dist/shared.js

@@ -4,6 +4,7 @@
  * Resolution: $HIPPO_HOME > $XDG_DATA_HOME/hippo > ~/.hippo/
  * Local .hippo/ stores are per-project.
  */
+import { BadRequestError, NotFoundError } from './api-errors.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { generateId, COMPACTION_MEMORY_TAG } from './memory.js';
@@ -48,16 +49,16 @@ export function initGlobal() {
 export function promoteToGlobal(localRoot, id, opts) {
     const entry = readEntry(localRoot, id, opts?.tenantId);
     if (!entry)
-        throw new Error(`Memory not found: ${id}`);
+        throw new NotFoundError(`Memory not found: ${id}`);
     // CD5: same veto as shareMemory; a promoted copy would have no quarantine record to review.
     if (isQuarantineScope(entry.scope)) {
-        throw new Error(`Refusing to promote ${id}: it is quarantined pending review. Approve it first via 'hippo quarantine approve ${id}'.`);
+        throw new BadRequestError(`Refusing to promote ${id}: it is quarantined pending review. Approve it first via 'hippo quarantine approve ${id}'.`);
     }
     // v39 S4 producer veto: promote is a producer path to the global store
     // exactly like shareMemory - same hard rule (codex gating review P2).
     const promoteSecret = detectSecret(entry);
     if (promoteSecret.flagged) {
-        throw new Error(`Refusing to promote ${id} to the global store: content matches secret material (${promoteSecret.reason}). ` +
+        throw new BadRequestError(`Refusing to promote ${id} to the global store: content matches secret material (${promoteSecret.reason}). ` +
             `Secrets stay in their owning project's store.`);
     }
     initGlobal();
@@ -273,18 +274,18 @@ export function shareMemory(localRoot, id, options = {}) {
     // when tenantId is provided.
     const entry = readEntry(localRoot, id, options.tenantId);
     if (!entry)
-        throw new Error(`Memory not found: ${id}`);
+        throw new NotFoundError(`Memory not found: ${id}`);
     // v39 S4 producer veto: secrets never go to the global store, not even
     // with --force. Explicit and loud - a silent null would read as "low
     // transfer score" and invite retries.
     const secret = detectSecret(entry);
     if (secret.flagged) {
-        throw new Error(`Refusing to share ${id} to the global store: content matches secret material (${secret.reason}). ` +
+        throw new BadRequestError(`Refusing to share ${id} to the global store: content matches secret material (${secret.reason}). ` +
             `Secrets stay in their owning project's store.`);
     }
     // CD5: a quarantined row is unreviewed input, not a lesson; sharing it would spread poison globally.
     if (isQuarantineScope(entry.scope)) {
-        throw new Error(`Refusing to share ${id}: it is quarantined pending review. Approve it first via 'hippo quarantine approve ${id}'.`);
+        throw new BadRequestError(`Refusing to share ${id}: it is quarantined pending review. Approve it first via 'hippo quarantine approve ${id}'.`);
     }
     const score = transferScore(entry);
     if (score < 0.3 && !options.force)

package/dist/skills.js

@@ -21,8 +21,10 @@
  * Lifecycle: active -> superseded (a newer version replaces it) or active ->
  * closed (retired). Export renders ACTIVE skills only.
  */
+import { BadRequestError, ConflictError, NotFoundError } from './api-errors.js';
 import { openHippoDb, closeHippoDb } from './db.js';
-import { writeEntry, assertTenantId } from './store.js';
+import { writeEntry } from './store.js';
+import { assertTenantId } from './tenant.js';
 import { createMemory, Layer } from './memory.js';
 import { appendAuditEvent } from './audit.js';
 import { objectHalfLifeDays } from './half-life-migration.js';
@@ -48,28 +50,28 @@ export const MAX_EXPORT_SKILLS = 1000;
 function validateSkillFields(skillName, instructions, trigger) {
     const name = (skillName ?? '').trim();
     if (name.length === 0)
-        throw new Error('saveSkill: skillName is required');
+        throw new BadRequestError('saveSkill: skillName is required');
     if (/[\r\n]/.test(name))
-        throw new Error('saveSkill: skillName must be a single line (no newlines)');
+        throw new BadRequestError('saveSkill: skillName must be a single line (no newlines)');
     if (name.length > MAX_SKILL_NAME_LEN) {
-        throw new Error(`saveSkill: skillName exceeds the ${MAX_SKILL_NAME_LEN}-char cap`);
+        throw new BadRequestError(`saveSkill: skillName exceeds the ${MAX_SKILL_NAME_LEN}-char cap`);
     }
     if (!instructions || instructions.trim().length === 0) {
-        throw new Error('saveSkill: instructions are required');
+        throw new BadRequestError('saveSkill: instructions are required');
     }
     if (instructions.length > MAX_SKILL_INSTRUCTIONS_LEN) {
-        throw new Error(`saveSkill: instructions exceed the ${MAX_SKILL_INSTRUCTIONS_LEN}-char cap`);
+        throw new BadRequestError(`saveSkill: instructions exceed the ${MAX_SKILL_INSTRUCTIONS_LEN}-char cap`);
     }
     let triggerVal = null;
     if (trigger !== undefined && trigger !== null && trigger.trim().length > 0) {
         if (trigger.length > MAX_SKILL_TRIGGER_LEN) {
-            throw new Error(`saveSkill: trigger exceeds the ${MAX_SKILL_TRIGGER_LEN}-char cap`);
+            throw new BadRequestError(`saveSkill: trigger exceeds the ${MAX_SKILL_TRIGGER_LEN}-char cap`);
         }
         // Single-line, like skill_name: a trigger is a short "when to apply" phrase,
         // and a newline would let it forge a heading inside the export **When:** line
         // (independent-review 2026-05-30). Reject rather than emit a multi-line trigger.
         if (/[\r\n]/.test(trigger)) {
-            throw new Error('saveSkill: trigger must be a single line (no newlines)');
+            throw new BadRequestError('saveSkill: trigger must be a single line (no newlines)');
         }
         triggerVal = trigger;
     }
@@ -147,10 +149,10 @@ export function saveSkill(hippoRoot, tenantId, opts, actor = 'cli') {
                 // SAFETY: row shape matches the `status, version` columns named in the SELECT below.
                 const pred = db.prepare(`SELECT status, version FROM skills WHERE id = ? AND tenant_id = ?`).get(opts.supersedesSkillId, tenantId);
                 if (!pred) {
-                    throw new Error(`saveSkill: skill ${opts.supersedesSkillId} to supersede not found for tenant ${tenantId}`);
+                    throw new NotFoundError(`saveSkill: skill ${opts.supersedesSkillId} to supersede not found for tenant ${tenantId}`);
                 }
                 if (pred.status !== 'active') {
-                    throw new Error(`saveSkill: skill ${opts.supersedesSkillId} is not active (status='${pred.status}'); only active skills can be superseded.`);
+                    throw new ConflictError(`saveSkill: skill ${opts.supersedesSkillId} is not active (status='${pred.status}'); only active skills can be superseded.`);
                 }
                 version = pred.version + 1;
             }
@@ -168,7 +170,7 @@ export function saveSkill(hippoRoot, tenantId, opts, actor = 'cli') {
           WHERE id = ? AND tenant_id = ? AND status = 'active' AND id != ?
         `).run(skillId, now, opts.supersedesSkillId, tenantId, skillId);
                 if (sup.changes === 0) {
-                    throw new Error(`saveSkill: skill ${opts.supersedesSkillId} could not be superseded (no longer active or self-reference).`);
+                    throw new ConflictError(`saveSkill: skill ${opts.supersedesSkillId} could not be superseded (no longer active or self-reference).`);
                 }
                 appendAuditEvent(db, {
                     tenantId,
@@ -227,15 +229,15 @@ export function closeSkill(hippoRoot, tenantId, id, actor = 'cli') {
                 // SAFETY: row shape matches the single `status` column named in the SELECT above.
                 const existing = db.prepare(`SELECT status FROM skills WHERE id = ? AND tenant_id = ?`).get(id, tenantId);
                 if (!existing) {
-                    throw new Error(`closeSkill: skill ${id} not found for tenant ${tenantId}`);
+                    throw new NotFoundError(`closeSkill: skill ${id} not found for tenant ${tenantId}`);
                 }
-                throw new Error(`closeSkill: skill ${id} is not active (status='${existing.status}'); only active skills can be closed.`);
+                throw new ConflictError(`closeSkill: skill ${id} is not active (status='${existing.status}'); only active skills can be closed.`);
             }
             // SAFETY: row's shape matches the columns named in SKILL_COLS above.
             const row = db.prepare(`SELECT ${SKILL_COLS} FROM skills WHERE id = ? AND tenant_id = ?`)
                 .get(id, tenantId);
             if (!row)
-                throw new Error(`closeSkill: skill ${id} not found after UPDATE`);
+                throw new NotFoundError(`closeSkill: skill ${id} not found after UPDATE`);
             appendAuditEvent(db, {
                 tenantId,
                 actor,
@@ -281,7 +283,7 @@ export function loadSkills(hippoRoot, tenantId, opts = {}) {
         let rows;
         if (opts.status) {
             if (!VALID_SKILL_STATES.has(opts.status)) {
-                throw new Error(`loadSkills: status must be one of ${Array.from(VALID_SKILL_STATES).join('|')}; got ${opts.status}`);
+                throw new BadRequestError(`loadSkills: status must be one of ${Array.from(VALID_SKILL_STATES).join('|')}; got ${opts.status}`);
             }
             // SAFETY: rows' shape matches the columns named in SKILL_COLS above.
             rows = db.prepare(`

package/dist/store-cards.d.ts

@@ -0,0 +1,53 @@
+import { type DatabaseSyncLike } from './db.js';
+import { SessionHandoff, HandoffOutcome } from './handoff.js';
+import { Card, CardStatus, CardRun, CardComment } from './card.js';
+export declare function transitionCard(db: DatabaseSyncLike, tenantId: string, cardId: string, from: CardStatus[], to: CardStatus, extra?: {
+    setSql?: string;
+    whereSql?: string;
+    params?: unknown[];
+}): 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. */
+export declare function createCard(hippoRoot: string, tenantId: string, input: {
+    title: string;
+    repo?: string;
+    contract?: string;
+    budget?: number;
+    dependsOn?: string[];
+}): Card;
+/** Returns the card row for id, or null if it does not exist under this tenant. */
+export declare function loadCard(hippoRoot: string, tenantId: string, id: string): Card | null;
+/** Lists cards for this tenant, optionally filtered to one status, newest-updated first. */
+export declare function listCards(hippoRoot: string, tenantId: string, opts?: {
+    status?: CardStatus;
+}): Card[];
+/** Returns this card's parent and child ids from card_deps. */
+export declare function loadCardDeps(hippoRoot: string, tenantId: string, id: string): {
+    parents: string[];
+    children: string[];
+};
+/** Returns this card's run history, most recent first. */
+export declare function loadCardRuns(hippoRoot: string, tenantId: string, id: string): CardRun[];
+/** Returns this card's comments, most recent first. */
+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. */
+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. */
+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. */
+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. */
+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. */
+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. */
+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;
+//# sourceMappingURL=store-cards.d.ts.map