hippo-memory 1.71.0 → 2.0.0

package/dist/cli/client.js

@@ -3,6 +3,7 @@
 import { fetchWithRetry } from '../util/http-retry.js';
 import { readCappedJson } from '../util/capped-json.js';
 import { isJsonObject, isJsonString } from '../util/json.js';
+import { isObjectLike } from '../core/capture-contract.js';
 /** A write the local server has not answered in this long is stuck; the caller treats it as delivery-unknown. */
 const SERVER_TIMEOUT_MS = 30_000;
 /** Five tries at the server's 1 s Retry-After keeps the roughly 5 s wait the CLI had before the server answered busy with 503. */
@@ -13,7 +14,8 @@ const MAX_REPLY_BYTES = 1024 * 1024;
 function isStoreBusy(res) {
     return res.status === 503 && res.headers.has('retry-after');
 }
-/** Replaying is safe because each routed write commits in one transaction and anything after it is best-effort, so a busy 503 means nothing landed; a sleep is safe too, as a re-run finishes a partial one. */
+/** Replaying is safe because each routed write commits in one transaction and anything after it is best-effort, so a busy 503 means
+ * nothing landed; a sleep is safe too, as a re-run finishes a partial one. */
 function sendWrite(url, init) {
     return fetchWithRetry(url, init, { timeoutMs: SERVER_TIMEOUT_MS, attempts: STORE_BUSY_ATTEMPTS, retryOn: isStoreBusy });
 }
@@ -25,8 +27,7 @@ function buildHeaders(apiKey, withBody) {
         headers['authorization'] = `Bearer ${apiKey}`;
     return headers;
 }
-/** An error the server answered with, not one the transport raised: the refused-connection classifier sniffs message text,
- *  and a server message quotes the caller's own id or content back verbatim. */
+/** An error the server answered with, not one the transport raised, so the transport classifier can skip it by class. */
 export class HttpResponseError extends Error {
     status;
     constructor(message, status) {
@@ -50,10 +51,25 @@ async function throwForStatus(res) {
     }
     throw new HttpResponseError(message, res.status);
 }
-/** A 2xx reply's body, read under the cap. */
-async function readReply(res) {
+/** A 2xx reply that is not the JSON object the route promises: another process may now own the pidfile's port. */
+export class MalformedReplyError extends Error {
+    route;
+    constructor(route, detail) {
+        super(`the hippo server's reply to ${route} was not the expected JSON object (${detail})`);
+        this.route = route;
+        this.name = 'MalformedReplyError';
+    }
+}
+/** A 2xx reply's body, read under the cap; it must be a JSON object, and `guard` narrows it further where the shape is known. */
+async function readReply(res, route, guard) {
+    const body = await readCappedJson(res, MAX_REPLY_BYTES);
+    if (!isJsonObject(body))
+        throw new MalformedReplyError(route, body === null ? 'null' : Array.isArray(body) ? 'array' : 'a scalar');
+    if (guard && !guard(body))
+        throw new MalformedReplyError(route, 'unexpected fields');
+    const reply = body;
     // SAFETY: the reply comes from hippo's own server, whose route returns this api result as JSON.
-    return (await readCappedJson(res, MAX_REPLY_BYTES));
+    return reply;
 }
 export async function remember(serverUrl, apiKey, opts) {
     const res = await sendWrite(`${serverUrl}/v1/memories`, {
@@ -63,7 +79,7 @@ export async function remember(serverUrl, apiKey, opts) {
     });
     if (!res.ok)
         await throwForStatus(res);
-    return readReply(res);
+    return readReply(res, 'POST /v1/memories');
 }
 export async function forget(serverUrl, apiKey, id) {
     const res = await sendWrite(`${serverUrl}/v1/memories/${encodeURIComponent(id)}`, {
@@ -72,7 +88,7 @@ export async function forget(serverUrl, apiKey, id) {
     });
     if (!res.ok)
         await throwForStatus(res);
-    return readReply(res);
+    return readReply(res, 'DELETE /v1/memories/:id', (b) => isJsonString(b.id));
 }
 export async function promote(serverUrl, apiKey, id) {
     const res = await sendWrite(`${serverUrl}/v1/memories/${encodeURIComponent(id)}/promote`, {
@@ -81,7 +97,7 @@ export async function promote(serverUrl, apiKey, id) {
     });
     if (!res.ok)
         await throwForStatus(res);
-    return readReply(res);
+    return readReply(res, 'POST /v1/memories/:id/promote', (b) => isJsonString(b.sourceId) && isJsonString(b.globalId));
 }
 export async function archiveRaw(serverUrl, apiKey, id, reason) {
     const res = await sendWrite(`${serverUrl}/v1/memories/${encodeURIComponent(id)}/archive`, {
@@ -91,31 +107,31 @@ export async function archiveRaw(serverUrl, apiKey, id, reason) {
     });
     if (!res.ok)
         await throwForStatus(res);
-    return readReply(res);
+    return readReply(res, 'POST /v1/memories/:id/archive', (b) => isJsonString(b.archivedAt));
 }
-function hasObjectCause(e) {
-    // Node's fs/net system errors (ECONNREFUSED, ECONNRESET) attach the syscall code on a non-null object `cause`;
-    // the strict-equality checks below validate it before use.
-    return typeof e.cause === 'object' && e.cause !== null;
+/** The syscall code Node puts on a system error itself (`http` errors) or on the `cause` of a fetch `TypeError`; '' when there is none. */
+function transportCode(err) {
+    if ('code' in err)
+        return String(err.code);
+    // Node's fetch attaches the syscall code (ECONNREFUSED, ECONNRESET) on a non-null object `cause`.
+    const cause = err.cause;
+    return isObjectLike(cause) && 'code' in cause ? String(cause.code) : '';
 }
 export function classifyTransportFailure(err) {
     // The server answered, so the transport worked, whatever the message says.
     if (err instanceof HttpResponseError)
         return 'none';
-    const message = err.message.toLowerCase();
-    const code = hasObjectCause(err) ? err.cause.code : undefined;
+    const code = transportCode(err);
     // Connect-phase failures: no request bytes ever left the client, so a stale
     // pidfile can be healed and the call replayed on the direct path.
     if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'EAI_AGAIN')
         return 'never-sent';
-    if (message.includes('econnrefused'))
-        return 'never-sent';
-    // The socket died mid-exchange. Node fetch surfaces this as a bare
-    // 'fetch failed' with the syscall code on the cause, so check both shapes.
+    // The socket died mid-exchange.
     if (code === 'ECONNRESET' || code === 'ECONNABORTED' || code === 'EPIPE' || code === 'UND_ERR_SOCKET') {
         return 'delivery-unknown';
     }
-    if (message.includes('socket hang up') || message.includes('fetch failed'))
+    // Fetch rejects every network failure as a TypeError, with a cause only when the syscall is known, so no code means the conservative answer.
+    if (err instanceof TypeError)
         return 'delivery-unknown';
     // The request was sent and the server went quiet, so it may have committed.
     if (err.name === 'TimeoutError')

package/dist/cli/compact-resume-payload.js

@@ -1,5 +1,5 @@
 // The payload gate for `hippo compact-resume`.
-import { isSubagentPayload } from '../store/token-ledger.js';
+import { isSubagentPayload } from '../util/hook-payload.js';
 import { isJsonObject, isJsonString } from '../util/json.js';
 /** Fail-closed read of the SessionStart payload: only a manual run or a main-session `source: 'compact'` payload may print. */
 export function readCompactResumePayload(stdinText, stdinTimedOut) {

package/dist/cli/context.d.ts

@@ -1,3 +1,3 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleContext({ hippoRoot, args, flags }: CommandContext): Promise<void>;
+export declare function handleContext({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=context.d.ts.map

package/dist/cli/context.js

@@ -1,26 +1,27 @@
 // The `hippo context` verb, which the per-prompt hook also runs; main() loads it lazily from the command table.
-import { isSubagentPayload } from '../store/token-ledger.js';
+import { isSubagentPayload } from '../util/hook-payload.js';
 import { estimateTokens } from '../util/token-text.js';
 import { autoDetectContext } from '../api/context-auto.js';
-import { detectScope } from '../sharing/scope.js';
+import { detectScope } from '../core/active-scope.js';
 import { bookLedgerTurn } from '../api/ledger-db.js';
 import { readHookStdin } from './stdin.js';
 import { isJsonObject, isJsonString } from '../util/json.js';
 import * as api from '../api/index.js';
 import { DEFAULT_CONTEXT_BUDGET } from '../api/context.js';
-import { resolveTenantId } from '../store/tenant.js';
 import { cliApiContext } from './api-context.js';
 import { renderAmbientSummary } from '../core/ambient.js';
 import { contextBlockLines, contextCost, crossProjectLines, settleTokens } from '../api/context-render.js';
-import { additionalContextOutput, flushDeliveryRecorder, hasContextData, sessionStartEnvelope, toRenderItems, } from '../api/prompt-hook.js';
+import { additionalContextOutput, flushDeliveryRecorder, hasContextData, startDeliveryRecorder, sessionStartEnvelope, toRenderItems, } from '../api/prompt-hook.js';
 import { parseLimitFlag, parseCountFlag, parseBudgetFlag, flagIsTrue } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { printActiveTaskSnapshot, printSessionEvents, printHandoff, captureConsole } from './print.js';
-import { hostSessionId, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout, startDeliveryRecorder } from './hook-runtime.js';
-async function cmdContext(hippoRoot, args, flags, stdinText) {
-    const rec = startDeliveryRecorder(hippoRoot, stdinText, hookRuntime(flags), flagIsTrue(flags, 'pinned-only') ? undefined : 'context');
+import { hostSessionId, hookStoreRoot, hookRuntime, payloadCwdRoot, runHookWithStores, inPilotHoldout } from './hook-runtime.js';
+async function cmdContext(hippoRoot, tenantId, args, flags, stdinText) {
+    const rec = startDeliveryRecorder(cliApiContext(hippoRoot, tenantId), {
+        stdinText, runtime: hookRuntime(flags), eventType: flagIsTrue(flags, 'pinned-only') ? undefined : 'context', envSessionId: hostSessionId(),
+    });
     // No try/finally: a render throw keeps its own exit code and writes no event.
-    await renderContext(hippoRoot, args, flags, stdinText, rec);
+    await renderContext(hippoRoot, tenantId, args, flags, stdinText, rec);
     flushDeliveryRecorder(rec);
 }
 /** The hook payload's session id and raw prompt; a malformed or empty payload yields neither. */
@@ -43,7 +44,7 @@ function readHookPayload(stdinText) {
     }
     return { sessionId, prompt };
 }
-async function renderContext(hippoRoot, args, flags, stdinText, rec) {
+async function renderContext(hippoRoot, resolvedTenant, args, flags, stdinText, rec) {
     // --pinned-only fires on every prompt, even where no local .hippo exists, so it skips requireInit
     // and api.getContext falls back to global-only.
     const pinnedOnly = flagIsTrue(flags, 'pinned-only');
@@ -53,8 +54,7 @@ async function renderContext(hippoRoot, args, flags, stdinText, rec) {
     const session = resolveContextSession(stdinText);
     const { currentSessionId, ledgerSessionId, payloadSessionId } = session;
     // The pilot arm is booked at the first hook call whatever the flags, so the holdout sees no budget or content branch.
-    const resolvedTenant = resolveTenantId({});
-    if (inPilotHoldout(hippoRoot, resolvedTenant, currentSessionId, payloadSessionId !== undefined)) {
+    if (inPilotHoldout(hippoRoot, resolvedTenant, currentSessionId, { write: payloadSessionId !== undefined })) {
         rec?.disabled();
         return;
     }
@@ -199,10 +199,10 @@ function printCrossProjectSection(items) {
     for (const line of crossProjectLines(items))
         console.log(line);
 }
-export async function handleContext({ hippoRoot, args, flags }) {
+export async function handleContext({ hippoRoot, tenantId, args, flags }) {
     // Bounded, not a TTY guard: the hot stdin path and a manual run share this one command.
     const { text: stdinText } = await readHookStdin();
     const root = payloadCwdRoot(hippoRoot, stdinText, hookRuntime(flags));
-    await runHookWithStores(() => cmdContext(hookStoreRoot(root), args, flags, stdinText));
+    await runHookWithStores(() => cmdContext(hookStoreRoot(root), tenantId, args, flags, stdinText));
 }
 //# sourceMappingURL=context.js.map

package/dist/cli/continuity.d.ts

@@ -3,5 +3,5 @@ export declare function handleSnapshot({ hippoRoot, tenantId, args, flags }: Com
 export declare function handleSession({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 export declare function handleHandoff({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 export declare function handleCurrent({ hippoRoot, tenantId, args, flags }: CommandContext): void;
-export declare function handleWm({ hippoRoot, args, flags }: CommandContext): void;
+export declare function handleWm({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 //# sourceMappingURL=continuity.d.ts.map

package/dist/cli/continuity.js

@@ -1,13 +1,12 @@
 // Where-you-left-off verbs: snapshot, session, handoff, current and working memory.
-import { saveActiveTaskSnapshot, loadActiveTaskSnapshot, clearActiveTaskSnapshot, appendSessionEvent, listSessionEvents, } from '../store/sessions.js';
-import { saveSessionHandoff, loadLatestHandoff, loadHandoffById, stampHandoffOutcome } from '../store/handoffs.js';
+import { snapshotSave as apiSnapshotSave, snapshotClear as apiSnapshotClear, snapshotLoad, sessionEventAppend, sessionEventList, continuityLatest, handoffStampOutcome, handoffSave, handoffLatest as apiHandoffLatest, handoffById, workingMemoryPush, workingMemoryRead, workingMemoryClear, workingMemoryFlush, } from '../api/continuity.js';
+import { cliApiContext } from './api-context.js';
 import { isHandoffOutcome, formatHandoffEvidenceLine } from '../core/handoff.js';
-import { wmPush, wmRead, wmClear, wmFlush } from '../store/working-memory.js';
 import { collectHandoffEvidence } from '../capture/handoff-evidence.js';
 import { printError } from './output.js';
 import { requireInit } from './shared.js';
 import { printActiveTaskSnapshot, printSessionEvents, printHandoff } from './print.js';
-import { boolFlag, isStringFlag } from './flag-values.js';
+import { boolFlag, isStringFlag, numberFlag } from './flag-values.js';
 import { CliExit } from './exit.js';
 const ISO_DATETIME_CHARS = 19;
 function snapshotSave(hippoRoot, tenantId, flags) {
@@ -19,7 +18,7 @@ function snapshotSave(hippoRoot, tenantId, flags) {
         printError('Usage: hippo snapshot save --task <task> --summary <summary> --next-step <step> [--source <source>] [--session <session-id>]');
         throw new CliExit(1);
     }
-    const snapshot = saveActiveTaskSnapshot(hippoRoot, tenantId, {
+    const snapshot = apiSnapshotSave(cliApiContext(hippoRoot, tenantId), {
         task,
         summary,
         next_step: nextStep,
@@ -34,7 +33,7 @@ function snapshotSave(hippoRoot, tenantId, flags) {
     }
 }
 function snapshotClear(hippoRoot, tenantId, flags) {
-    const cleared = clearActiveTaskSnapshot(hippoRoot, tenantId, String(flags['status'] ?? 'cleared'));
+    const cleared = apiSnapshotClear(cliApiContext(hippoRoot, tenantId), String(flags['status'] ?? 'cleared'));
     if (!cleared) {
         console.log('No active task snapshot to clear.');
         return;
@@ -42,7 +41,7 @@ function snapshotClear(hippoRoot, tenantId, flags) {
     console.log('Cleared active task snapshot.');
 }
 function snapshotShow(hippoRoot, tenantId, flags) {
-    const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
+    const snapshot = snapshotLoad(cliApiContext(hippoRoot, tenantId));
     if (!snapshot) {
         if (flags['json']) {
             console.log(JSON.stringify({ snapshot: null }));
@@ -77,7 +76,7 @@ function sessionLog(hippoRoot, tenantId, s, flags) {
         printError('Usage: hippo session log --id <session-id> --content <text> [--type <type>] [--task <task>] [--source <source>]');
         throw new CliExit(1);
     }
-    const event = appendSessionEvent(hippoRoot, tenantId, {
+    const event = sessionEventAppend(cliApiContext(hippoRoot, tenantId), {
         session_id: s.sessionId,
         task: s.task || null,
         event_type: eventType || 'note',
@@ -89,7 +88,7 @@ function sessionLog(hippoRoot, tenantId, s, flags) {
     console.log(`   Type: ${event.event_type}`);
 }
 function sessionShow(hippoRoot, tenantId, s, flags) {
-    const events = listSessionEvents(hippoRoot, tenantId, {
+    const events = sessionEventList(cliApiContext(hippoRoot, tenantId), {
         session_id: s.sessionId || undefined,
         task: s.task || undefined,
         limit: s.limit,
@@ -101,9 +100,8 @@ function sessionShow(hippoRoot, tenantId, s, flags) {
     printSessionEvents(events);
 }
 function sessionLatest(hippoRoot, tenantId, s, flags) {
-    const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
-    const events = listSessionEvents(hippoRoot, tenantId, {
-        session_id: s.sessionId || snapshot?.session_id || undefined,
+    const { snapshot, events } = continuityLatest(cliApiContext(hippoRoot, tenantId), {
+        sessionId: s.sessionId,
         limit: s.limit,
     });
     if (flags['json']) {
@@ -135,7 +133,7 @@ function sessionComplete(hippoRoot, tenantId, s, flags) {
     const metadata = { ended_at: new Date().toISOString() };
     if (summary)
         metadata.summary = summary;
-    const event = appendSessionEvent(hippoRoot, tenantId, {
+    const event = sessionEventAppend(cliApiContext(hippoRoot, tenantId), {
         session_id: sessionId,
         task: task || null,
         event_type: 'session_complete',
@@ -144,7 +142,7 @@ function sessionComplete(hippoRoot, tenantId, s, flags) {
         metadata,
     });
     console.log(`Completed session ${event.session_id} with outcome=${outcome} (event #${event.id})`);
-    const stamped = stampHandoffOutcome(hippoRoot, tenantId, sessionId, outcome);
+    const stamped = handoffStampOutcome(cliApiContext(hippoRoot, tenantId), sessionId, outcome);
     if (stamped > 0) {
         console.log(`Stamped outcome on handoff for session ${sessionId}`);
     }
@@ -154,7 +152,7 @@ export function handleSession({ hippoRoot, tenantId, args, flags }) {
     const subcommand = args[0] ?? 'show';
     const sessionId = String(flags['id'] ?? flags['session'] ?? '').trim();
     const task = String(flags['task'] ?? '').trim();
-    const limit = Math.max(1, parseInt(String(flags['limit'] ?? '8'), 10) || 8);
+    const limit = Math.max(1, numberFlag(flags, 'limit') || 8);
     const s = { sessionId, task, limit };
     if (subcommand === 'log')
         return sessionLog(hippoRoot, tenantId, s, flags);
@@ -170,7 +168,7 @@ export function handleSession({ hippoRoot, tenantId, args, flags }) {
     throw new CliExit(1);
 }
 function sessionResume(hippoRoot, tenantId, sessionId) {
-    const handoff = loadLatestHandoff(hippoRoot, tenantId, sessionId || undefined);
+    const handoff = apiHandoffLatest(cliApiContext(hippoRoot, tenantId), sessionId || undefined);
     if (!handoff) {
         console.log('No handoff to resume from.');
         return;
@@ -217,10 +215,13 @@ function sessionResume(hippoRoot, tenantId, sessionId) {
 function flagList(value) {
     return Array.isArray(value) ? value : (isStringFlag(value) ? [value] : []);
 }
+const HANDOFF_CREATE_USAGE = 'Usage: hippo handoff create --summary "..." [--next "..."] [--session <id>] [--task <id>] [--artifact <path>...] ' +
+    '[--constraint <text>...] [--outcome <success|failure|partial>] [--target-runtime <name>] [--card-id <id>] ' +
+    '[--tests <pass|fail|unknown>]';
 function handoffCreate(hippoRoot, tenantId, flags) {
     const summary = String(flags['summary'] ?? '').trim();
     if (!summary) {
-        printError('Usage: hippo handoff create --summary "..." [--next "..."] [--session <id>] [--task <id>] [--artifact <path>...] [--constraint <text>...] [--outcome <success|failure|partial>] [--target-runtime <name>] [--card-id <id>] [--tests <pass|fail|unknown>]');
+        printError(HANDOFF_CREATE_USAGE);
         throw new CliExit(1);
     }
     const outcomeRaw = flags['outcome'];
@@ -244,7 +245,7 @@ function handoffCreate(hippoRoot, tenantId, flags) {
     const cardId = String(flags['card-id'] ?? '').trim() || undefined;
     const testStatus = String(flags['tests'] ?? '').trim();
     const evidence = collectHandoffEvidence(process.cwd(), testStatus === 'pass' || testStatus === 'fail' ? testStatus : 'unknown');
-    const handoff = saveSessionHandoff(hippoRoot, tenantId, {
+    const handoff = handoffSave(cliApiContext(hippoRoot, tenantId), {
         version: 1,
         sessionId,
         repoRoot: process.cwd(),
@@ -283,7 +284,7 @@ function printCreatedHandoff(handoff) {
 }
 function handoffLatest(hippoRoot, tenantId, flags) {
     const sessionId = String(flags['session'] ?? flags['id'] ?? '').trim() || undefined;
-    const handoff = loadLatestHandoff(hippoRoot, tenantId, sessionId);
+    const handoff = apiHandoffLatest(cliApiContext(hippoRoot, tenantId), sessionId);
     if (!handoff) {
         if (flags['json']) {
             console.log(JSON.stringify({ handoff: null }));
@@ -310,7 +311,7 @@ function handoffShow(hippoRoot, tenantId, args, flags) {
         printError(`Invalid handoff ID: ${idArg}`);
         throw new CliExit(1);
     }
-    const handoff = loadHandoffById(hippoRoot, tenantId, handoffId);
+    const handoff = handoffById(cliApiContext(hippoRoot, tenantId), handoffId);
     if (!handoff) {
         if (flags['json']) {
             console.log(JSON.stringify({ handoff: null }));
@@ -363,12 +364,7 @@ function printCurrentState(snapshot, events) {
 }
 function currentShow(hippoRoot, tenantId, flags) {
     const asJson = boolFlag(flags, 'json');
-    const snapshot = loadActiveTaskSnapshot(hippoRoot, tenantId);
-    const sessionId = snapshot?.session_id ?? undefined;
-    const events = listSessionEvents(hippoRoot, tenantId, {
-        session_id: sessionId,
-        limit: 5,
-    });
+    const { snapshot, events } = continuityLatest(cliApiContext(hippoRoot, tenantId), { limit: 5 });
     if (asJson) {
         console.log(JSON.stringify({
             snapshot: snapshot ?? null,
@@ -397,54 +393,55 @@ export function handleCurrent({ hippoRoot, tenantId, args, flags }) {
     throw new CliExit(1);
 }
 // Working Memory
-export function handleWm({ hippoRoot, args, flags }) {
+export function handleWm({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? '';
     if (subcommand === 'push')
-        return wmPushCmd(hippoRoot, flags);
+        return wmPushCmd(hippoRoot, tenantId, flags);
     if (subcommand === 'read')
-        return wmReadCmd(hippoRoot, flags);
+        return wmReadCmd(hippoRoot, tenantId, flags);
     if (subcommand === 'clear') {
         const scope = flags['scope'] ? String(flags['scope']).trim() : undefined;
         const sessionId = flags['session'] ? String(flags['session']).trim() : undefined;
-        const count = wmClear(hippoRoot, { scope, sessionId });
+        const count = workingMemoryClear(cliApiContext(hippoRoot, tenantId), { scope, sessionId });
         console.log(`Cleared ${count} working memory entries.`);
         return;
     }
     if (subcommand === 'flush') {
         const scope = flags['scope'] ? String(flags['scope']).trim() : undefined;
         const sessionId = flags['session'] ? String(flags['session']).trim() : undefined;
-        const count = wmFlush(hippoRoot, { scope, sessionId });
+        const count = workingMemoryFlush(cliApiContext(hippoRoot, tenantId), { scope, sessionId });
         console.log(`Flushed ${count} working memory entries.`);
         return;
     }
     printError('Usage: hippo wm <push|read|clear|flush>');
     throw new CliExit(1);
 }
-function wmPushCmd(hippoRoot, flags) {
+const WM_DEFAULT_IMPORTANCE = 0.5;
+function wmPushCmd(hippoRoot, tenantId, flags) {
     const scope = String(flags['scope'] ?? 'default').trim();
     const content = String(flags['content'] ?? '').trim();
-    const importance = parseFloat(String(flags['importance'] ?? '0.5'));
+    const importance = numberFlag(flags, 'importance') ?? WM_DEFAULT_IMPORTANCE;
     const sessionId = flags['session'] ? String(flags['session']).trim() : undefined;
     const taskId = flags['task'] ? String(flags['task']).trim() : undefined;
     if (!content) {
         printError('Usage: hippo wm push --scope <scope> --content "..." [--importance 0.8] [--session <id>] [--task <id>]');
         throw new CliExit(1);
     }
-    const id = wmPush(hippoRoot, {
+    const id = workingMemoryPush(cliApiContext(hippoRoot, tenantId), {
         scope,
         content,
-        importance: Number.isFinite(importance) ? importance : 0.5,
+        importance,
         sessionId,
         taskId,
     });
-    console.log(`Pushed working memory #${id} (scope=${scope}, importance=${Number.isFinite(importance) ? importance : 0.5})`);
+    console.log(`Pushed working memory #${id} (scope=${scope}, importance=${importance})`);
 }
-function wmReadCmd(hippoRoot, flags) {
+function wmReadCmd(hippoRoot, tenantId, flags) {
     const scope = flags['scope'] ? String(flags['scope']).trim() : undefined;
     const sessionId = flags['session'] ? String(flags['session']).trim() : undefined;
-    const limit = parseInt(String(flags['limit'] ?? '20'), 10) || 20;
-    const items = wmRead(hippoRoot, { scope, sessionId, limit });
+    const limit = numberFlag(flags, 'limit') || 20;
+    const items = workingMemoryRead(cliApiContext(hippoRoot, tenantId), { scope, sessionId, limit });
     if (flags['json']) {
         console.log(JSON.stringify({ items }, null, 2));
         return;

package/dist/cli/curate.d.ts

@@ -1,6 +1,6 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleOutcome({ hippoRoot, tenantId, flags }: CommandContext): void;
-export declare function handleConflicts({ hippoRoot, flags }: CommandContext): void;
+export declare function handleOutcome({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
+export declare function handleConflicts({ hippoRoot, tenantId, flags }: CommandContext): void;
 export declare function handleResolve({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handleReject({ hippoRoot, tenantId, args, flags }: CommandContext): void;
 export declare function handleRejections({ hippoRoot, tenantId, flags }: CommandContext): void;