hippo-memory 2.0.0 → 2.1.0

package/dist/cli/graph.js

@@ -5,10 +5,13 @@ import { buildGraphModel, renderGraphHtml, renderGraphCanvas, DEFAULT_VIEW_LIMIT
 import { printError } from './output.js';
 import { stringFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
+import { objectsOf } from '../api/objects/objects.js';
+import { cliApiContext } from './api-context.js';
 import { openInBrowser } from './open-browser.js';
-function graphExtract(hippoRoot, tenantId) {
-    const result = extractGraph(hippoRoot, tenantId);
+async function graphExtract(hippoRoot, tenantId) {
+    const ctx = cliApiContext(hippoRoot, tenantId);
+    const result = await extractGraph(objectsOf(ctx), hippoRoot, tenantId);
     const byType = Object.entries(result.byType)
         .map(([t, n]) => `${t} ${n}`)
         .join(', ');
@@ -16,7 +19,8 @@ function graphExtract(hippoRoot, tenantId) {
     const relations = `${result.relations} relations (${supersedes} supersedes, ${result.references} references)`;
     console.log(`Graph extracted: ${result.entities} entities (${byType}) + ${relations}.`);
     if (result.truncated.length > 0) {
-        printError(`WARNING: under-extracted (hit the per-type cap): ${result.truncated.join(', ')}. The graph is incomplete for those types.`);
+        printError(`WARNING: under-extracted (hit the per-type cap): ${result.truncated.join(', ')}. ` +
+            'The graph is incomplete for those types.');
     }
 }
 function graphShow(hippoRoot, tenantId, entity, flags) {
@@ -52,19 +56,19 @@ function graphShow(hippoRoot, tenantId, entity, flags) {
 function graphView(hippoRoot, tenantId, entity, flags) {
     const format = stringFlag(flags, 'format') ?? 'html';
     if (format !== 'html' && format !== 'canvas') {
-        printError("graph view: --format must be 'html' or 'canvas'");
-        throw new CliExit(1);
+        fail("graph view: --format must be 'html' or 'canvas'");
     }
     const model = buildGraphModel(hippoRoot, tenantId, { entity, limit: DEFAULT_VIEW_LIMIT });
     const content = format === 'canvas' ? renderGraphCanvas(model) : renderGraphHtml(model);
     const defaultOut = format === 'canvas' ? 'hippo-graph.canvas' : 'hippo-graph.html';
     const out = stringFlag(flags, 'out') ?? defaultOut;
     fs.writeFileSync(out, content, 'utf8');
-    console.log(`Wrote ${model.nodes.length} entities + ${model.edges.length} relations to ${out}${model.truncated ? ' (truncated)' : ''}`);
+    const truncated = model.truncated ? ' (truncated)' : '';
+    console.log(`Wrote ${model.nodes.length} entities + ${model.edges.length} relations to ${out}${truncated}`);
     if (flags['open'] && format === 'html')
         openInBrowser(out);
 }
-export function handleGraph({ hippoRoot, tenantId, args, flags }) {
+export async function handleGraph({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? '';
     if (subcommand === 'extract')
@@ -74,10 +78,10 @@ export function handleGraph({ hippoRoot, tenantId, args, flags }) {
         return graphShow(hippoRoot, tenantId, entity, flags);
     if (subcommand === 'view')
         return graphView(hippoRoot, tenantId, entity, flags);
-    printError('Usage:\n' +
+    fail('Usage:\n' +
         '  hippo graph extract                     Rebuild the entity/relation graph from consolidated objects\n' +
         '  hippo graph show [--entity NAME] [--json]   Inspect entities + their edges (text or JSON)\n' +
-        '  hippo graph view [--out FILE] [--open] [--format html|canvas] [--entity NAME]   Generate an interactive node-link diagram');
-    throw new CliExit(1);
+        '  hippo graph view [--out FILE] [--open] [--format html|canvas] [--entity NAME]   ' +
+        'Generate an interactive node-link diagram');
 }
 //# sourceMappingURL=graph.js.map

package/dist/cli/hook-runtime.d.ts

@@ -1,27 +1,49 @@
 import type { HookRuntime } from '../core/capture-contract.js';
 import type { CliFlags } from './flag-values.js';
-/** Detached worker (internal `__session-end-worker`): counts re-reads, runs sleep, then capture; one stage failing does not block the other. */
-/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
+/**
+ * Detached worker (internal `__session-end-worker`): counts re-reads, runs sleep, then capture; one stage failing does
+ * not block the other.
+ */
+/**
+ * A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here.
+ */
 export declare function logSessionEndImport(logFile: string | null, transcriptPath: string | undefined): void;
-/** Best-effort log line for the cmdSessionEndWorker snapshot-close step: cmdSleep/cmdCapture restore their console tee before this runs,
+/**
+ * Best-effort log line for the cmdSessionEndWorker snapshot-close step: cmdSleep/cmdCapture restore their console tee
+ * before this runs,
  * so console.log would be lost under the worker's `stdio: 'ignore'`; write to the file directly. */
 export declare function appendSessionEndCloseLog(logFile: string | null, message: string, opts?: {
     startFresh?: boolean;
 }): void;
-/** A session-end step that failed: one warn line, and the same text in the session log, the only place a detached worker's output survives. */
+/**
+ * A session-end step that failed: one warn line, and the same text in the session log, the only place a detached
+ * worker's output survives.
+ */
 export declare function reportSessionEndFailure<E>(logFile: string | null, step: string, err: E): void;
 export declare function hostSessionId(): string | undefined;
-/** Compaction drops the pinned blocks the per-prompt hook injected, so record a `reset` for the payload's session and the next prompt injects again.
+/**
+ * Compaction drops the pinned blocks the per-prompt hook injected, so record a `reset` for the payload's session and
+ * the next prompt injects again.
  * `requiredSource` limits it to payloads with that `source`; best-effort and silent on a malformed payload. */
 export declare function resetHookInjection(hippoRoot: string, tenantId: string, stdinText: string | undefined, requiredSource: string | null): void;
-/** Store a hook writes to: the project store, else an existing global one, else the project path (skipped: hooks must not create a store).
+/**
+ * Store a hook writes to: the project store, else an existing global one, else the project path (skipped: hooks must
+ * not create a store).
  * Pre-compact and compact-resume must agree, or a snapshot is looked for in the other store. */
 export declare function hookStoreRoot(hippoRoot: string): string;
-/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
+/**
+ * `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the
+ * payload.
+ */
 export declare function hookRuntime(flags: CliFlags): HookRuntime;
-/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
+/**
+ * A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder;
+ * other runtimes keep `hippoRoot`.
+ */
 export declare function payloadCwdRoot(hippoRoot: string, stdinText: string | undefined, runtime: HookRuntime): string;
-/** Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that skips the hook's
+/**
+ * Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that
+ * skips the hook's
  * work with one warning, exit 0. */
 export declare function runHookWithStores<T>(fn: () => T | Promise<T>): Promise<T | undefined>;
 /** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */

package/dist/cli/hook-runtime.js

@@ -5,15 +5,21 @@ import * as fs from 'fs';
 import { isSqliteBusy, noteStoreBusy, runWithRequestStores, HOOK_DB_WAIT_MS } from '../db/index.js';
 import { bookTokenUse } from '../api/ledger-db.js';
 import { sessionPilotArm } from '../api/pilot-arm.js';
+import { cliLedgerReach } from './api-context.js';
 import { hookPayloadSessionId, hookPayloadString, isSubagentPayload } from '../util/hook-payload.js';
 import { importAtSessionEnd, currentMachine } from '../agent-memories/sync.js';
 import { summaryLine } from '../agent-memories/report.js';
 import { getHippoRoot, isInitialized } from '../core/project-identity.js';
 import { getGlobalRoot } from '../sharing/global-store.js';
 import { sanitizeLogMessage } from '../capture/compact.js';
-import { errorMessage, log } from '../util/log.js';
-/** Detached worker (internal `__session-end-worker`): counts re-reads, runs sleep, then capture; one stage failing does not block the other. */
-/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
+import { errorMessage, log, errorFields } from '../util/log.js';
+/**
+ * Detached worker (internal `__session-end-worker`): counts re-reads, runs sleep, then capture; one stage failing does
+ * not block the other.
+ */
+/**
+ * A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here.
+ */
 export function logSessionEndImport(logFile, transcriptPath) {
     try {
         const report = importAtSessionEnd(process.cwd(), transcriptPath, { machine: currentMachine() });
@@ -27,7 +33,9 @@ export function logSessionEndImport(logFile, transcriptPath) {
         appendSessionEndCloseLog(logFile, `agent memory import failed: ${errorMessage(err)}`);
     }
 }
-/** Best-effort log line for the cmdSessionEndWorker snapshot-close step: cmdSleep/cmdCapture restore their console tee before this runs,
+/**
+ * Best-effort log line for the cmdSessionEndWorker snapshot-close step: cmdSleep/cmdCapture restore their console tee
+ * before this runs,
  * so console.log would be lost under the worker's `stdio: 'ignore'`; write to the file directly. */
 export function appendSessionEndCloseLog(logFile, message, opts = {}) {
     if (!logFile)
@@ -41,10 +49,13 @@ export function appendSessionEndCloseLog(logFile, message, opts = {}) {
     }
     catch (err) {
         // Best-effort only: a log-write failure must never fail the hook.
-        log.debug(`session-end log not written: ${errorMessage(err)}`);
+        log.debug(`session-end log not written: ${errorMessage(err)}`, errorFields(err));
     }
 }
-/** A session-end step that failed: one warn line, and the same text in the session log, the only place a detached worker's output survives. */
+/**
+ * A session-end step that failed: one warn line, and the same text in the session log, the only place a detached
+ * worker's output survives.
+ */
 export function reportSessionEndFailure(logFile, step, err) {
     const line = `${step} failed: ${errorMessage(err)}`;
     log.warn(line);
@@ -54,7 +65,9 @@ export function reportSessionEndFailure(logFile, step, err) {
 export function hostSessionId() {
     return envHippoSessionId() ?? envClaudeCodeSessionId();
 }
-/** Compaction drops the pinned blocks the per-prompt hook injected, so record a `reset` for the payload's session and the next prompt injects again.
+/**
+ * Compaction drops the pinned blocks the per-prompt hook injected, so record a `reset` for the payload's session and
+ * the next prompt injects again.
  * `requiredSource` limits it to payloads with that `source`; best-effort and silent on a malformed payload. */
 export function resetHookInjection(hippoRoot, tenantId, stdinText, requiredSource) {
     const sessionId = hookPayloadSessionId(stdinText, requiredSource);
@@ -63,9 +76,11 @@ export function resetHookInjection(hippoRoot, tenantId, stdinText, requiredSourc
         return;
     bookTokenUse(hippoRoot, {
         tenantId, sessionId, surface: 'hook', event: 'reset', items: 0, tokens: 0,
-    });
+    }, cliLedgerReach(hippoRoot));
 }
-/** Store a hook writes to: the project store, else an existing global one, else the project path (skipped: hooks must not create a store).
+/**
+ * Store a hook writes to: the project store, else an existing global one, else the project path (skipped: hooks must
+ * not create a store).
  * Pre-compact and compact-resume must agree, or a snapshot is looked for in the other store. */
 export function hookStoreRoot(hippoRoot) {
     if (isInitialized(hippoRoot))
@@ -73,26 +88,35 @@ export function hookStoreRoot(hippoRoot) {
     const globalRoot = getGlobalRoot();
     return isInitialized(globalRoot) ? globalRoot : hippoRoot;
 }
-/** `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the payload. */
+/**
+ * `--runtime copilot`, or `--format copilot` on `hippo context`, marks a Copilot hook: the flag decides, never the
+ * payload.
+ */
 export function hookRuntime(flags) {
     return flags['runtime'] === 'copilot' || flags['format'] === 'copilot' ? 'copilot' : 'claude-code';
 }
-/** A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder; other runtimes keep `hippoRoot`. */
+/**
+ * A Copilot hook's project root, from the payload's `cwd`, since VS Code runs user-level hooks in the home folder;
+ * other runtimes keep `hippoRoot`.
+ */
 export function payloadCwdRoot(hippoRoot, stdinText, runtime) {
     const cwd = runtime === 'copilot' ? hookPayloadString(stdinText, 'cwd') : null;
     if (cwd === null || cwd.trim() === '')
         return hippoRoot;
     try {
-        // Moving, not just re-rooting, keeps project identity, scope, handoff evidence and the session-end worker on that folder too.
+        // Moving, not just re-rooting, keeps project identity, scope, handoff evidence and the session-end worker on that
+        // folder too.
         process.chdir(cwd);
     }
     catch (err) {
-        log.warn(`hippo: payload cwd ${cwd} is not usable, so the hook stays in ${process.cwd()}: ${errorMessage(err)}`);
+        log.warn(`hippo: payload cwd ${cwd} is not usable, so the hook stays in ${process.cwd()}: ${errorMessage(err)}`, errorFields(err));
         return hippoRoot;
     }
     return getHippoRoot(process.cwd());
 }
-/** Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that skips the hook's
+/**
+ * Hook commands share one handle per store and wait at most HOOK_DB_WAIT_MS for a lock; a store still busy after that
+ * skips the hook's
  * work with one warning, exit 0. */
 export async function runHookWithStores(fn) {
     try {
@@ -107,6 +131,7 @@ export async function runHookWithStores(fn) {
 }
 /** Whether this session sits in the pilot's holdout arm; off at rate 0 and with no session id. */
 export function inPilotHoldout(hippoRoot, tenantId, sessionId, opts) {
-    return sessionPilotArm(hippoRoot, tenantId, sessionId, opts.write) === 'holdout';
+    const reach = cliLedgerReach(hippoRoot);
+    return sessionPilotArm(hippoRoot, tenantId, sessionId, opts.write, { reach }) === 'holdout';
 }
 //# sourceMappingURL=hook-runtime.js.map

package/dist/cli/incidents.d.ts

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

package/dist/cli/incidents.js

@@ -1,11 +1,13 @@
 // First-class object verbs for incidents: open one, resolve it, close it.
 import { extractPathTags } from '../search/path-context.js';
 import * as incidentsModule from '../objects/incidents.js';
+import { objectsOf } from '../api/objects/objects.js';
+import { cliApiContext } from './api-context.js';
 import { printError } from './output.js';
 import { nonEmptyStringFlag, isStringFlag, stringFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { closeObject, foundOrExit, idArgOrExit, listObjects } from './object-verbs.js';
-import { CliExit } from './exit.js';
+import { fail } from './exit.js';
 const INCIDENT = { cmd: 'incident', noun: 'Incident', idLabel: 'incident' };
 function printIncidentRow(inc) {
     const linkPart = inc.linkedMemoryIds.length > 0 ? ` links=${inc.linkedMemoryIds.length}` : '';
@@ -14,17 +16,17 @@ function printIncidentRow(inc) {
     if (inc.context)
         console.log(`    context: ${inc.context}`);
 }
-function incidentList(hippoRoot, tenantId, flags) {
-    listObjects(flags, {
+function incidentList(objects, tenantId, flags) {
+    return listObjects(flags, {
         plural: 'incidents',
         states: incidentsModule.VALID_INCIDENT_STATES,
-        load: (opts) => incidentsModule.loadIncidents(hippoRoot, tenantId, opts),
+        load: (opts) => incidentsModule.loadIncidents(objects, tenantId, opts),
         printRow: printIncidentRow,
     });
 }
-function incidentGet(hippoRoot, tenantId, args) {
+async function incidentGet(objects, tenantId, args) {
     const id = idArgOrExit(args, 'Usage: hippo incident get <id>', INCIDENT.idLabel);
-    const incident = foundOrExit(incidentsModule.loadIncidentById(hippoRoot, tenantId, id), INCIDENT.noun, id);
+    const incident = foundOrExit(await incidentsModule.loadIncidentById(objects, tenantId, id), INCIDENT.noun, id);
     console.log(`Incident #${incident.id}`);
     console.log(`  status: ${incident.status}`);
     console.log(`  text: ${incident.incidentText}`);
@@ -43,42 +45,41 @@ function incidentGet(hippoRoot, tenantId, args) {
         console.log(`  memory: ${incident.memoryId}`);
     console.log(`  created: ${incident.createdAt}`);
 }
-function incidentResolve(hippoRoot, tenantId, args, flags) {
+async function incidentResolve(objects, tenantId, args, flags) {
     const id = idArgOrExit(args, 'Usage: hippo incident resolve <id> --resolution "<text>"', INCIDENT.idLabel);
     const resolutionRaw = stringFlag(flags, 'resolution');
     if (!resolutionRaw?.trim()) {
-        printError('--resolution requires a non-empty value, e.g. hippo incident resolve <id> --resolution "root cause fixed".');
-        throw new CliExit(1);
+        fail('--resolution requires a non-empty value, e.g. hippo incident resolve <id> --resolution "root cause fixed".');
     }
-    const resolved = incidentsModule.resolveIncident(hippoRoot, tenantId, id, resolutionRaw);
+    const resolved = await incidentsModule.resolveOpenIncident(objects, tenantId, id, resolutionRaw, 'cli');
     console.log(`Incident #${resolved.id} resolved.`);
 }
-function incidentClose(hippoRoot, tenantId, args) {
-    closeObject(args, INCIDENT, (id) => incidentsModule.closeIncident(hippoRoot, tenantId, id));
+function incidentClose(objects, tenantId, args) {
+    return closeObject(args, INCIDENT, (id) => incidentsModule.closeIncident(objects, tenantId, id));
 }
-export function handleIncident({ hippoRoot, tenantId, args, flags }) {
+export async function handleIncident({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
     const subcommand = args[0] ?? '';
+    const objects = objectsOf(cliApiContext(hippoRoot, tenantId));
     if (subcommand === 'list')
-        return incidentList(hippoRoot, tenantId, flags);
+        return incidentList(objects, tenantId, flags);
     if (subcommand === 'get')
-        return incidentGet(hippoRoot, tenantId, args);
+        return incidentGet(objects, tenantId, args);
     if (subcommand === 'resolve')
-        return incidentResolve(hippoRoot, tenantId, args, flags);
+        return incidentResolve(objects, tenantId, args, flags);
     if (subcommand === 'close')
-        return incidentClose(hippoRoot, tenantId, args);
+        return incidentClose(objects, tenantId, args);
     // Default subcommand is open (create): accept both `incident open "<text>"` and bare `incident "<text>"`;
     // for the `open` keyword the text is args[1], otherwise args[0] is the text.
-    incidentCreate(hippoRoot, tenantId, subcommand === 'open' ? (args[1] ?? '') : subcommand, flags);
+    await incidentCreate(objects, hippoRoot, tenantId, subcommand === 'open' ? (args[1] ?? '') : subcommand, flags);
 }
-function incidentCreate(hippoRoot, tenantId, incidentText, flags) {
+async function incidentCreate(objects, hippoRoot, tenantId, incidentText, flags) {
     if (!incidentText) {
         printError('Usage: hippo incident "<incident>" [--context "<details>"] [--link <memory-id>]...');
         printError('       hippo incident list [--status open|resolved|closed|all] [--limit N]');
         printError('       hippo incident get <id>');
         printError('       hippo incident resolve <id> --resolution "<text>"');
-        printError('       hippo incident close <id>');
-        throw new CliExit(1);
+        fail('       hippo incident close <id>');
     }
     const context = nonEmptyStringFlag(flags, 'context');
     // --link is a repeatable flag (collected into an array by parseArgs). A
@@ -92,16 +93,15 @@ function incidentCreate(hippoRoot, tenantId, incidentText, flags) {
         linkedMemoryIds = [linkRaw];
     }
     else if (linkRaw === true) {
-        printError('--link requires a memory id, e.g. hippo incident "<text>" --link mem_abc123.');
-        throw new CliExit(1);
+        fail('--link requires a memory id, e.g. hippo incident "<text>" --link mem_abc123.');
     }
     const incidentPathTags = extractPathTags(process.cwd());
-    const created = incidentsModule.saveIncident(hippoRoot, tenantId, {
+    const created = await incidentsModule.openIncident(objects, hippoRoot, tenantId, {
         incidentText,
         context,
         linkedMemoryIds,
         extraTags: incidentPathTags,
-    });
+    }, 'cli');
     console.log(`Incident recorded: #${created.id}`);
     if (created.memoryId)
         console.log(`  memory: ${created.memoryId}`);

package/dist/cli/init.js

@@ -10,7 +10,7 @@ import { isCodexWrapperInstalled } from '../hooks/codex-wrapper.js';
 import { installOpencodePlugin } from '../hooks/opencode.js';
 import { initMemoryStore } from '../api/store-init.js';
 import { isInitialized } from '../core/project-identity.js';
-import { listMemories } from '../api/memories.js';
+import { listMemories } from '../api/memories/memories.js';
 import { cliApiContext } from './api-context.js';
 import { isGitRepo } from '../learn/autolearn.js';
 import { currentMachine, importForStore, importProjectMemories, importUserMemories } from '../agent-memories/sync.js';
@@ -19,7 +19,7 @@ import { getGlobalRoot, initGlobal } from '../sharing/global-store.js';
 import { registerWorkspace } from './scheduler.js';
 import { numberFlag, stringFlag } from './flag-values.js';
 import { printAgentImport } from './print.js';
-import { errorCode, errorMessage, log } from '../util/log.js';
+import { errorCode, errorFields, errorMessage, log } from '../util/log.js';
 import { installCodexMemoryHooks, setupDailySchedule, warnClaudeSettingsUnusable } from './install-steps.js';
 import { learnFromRepo, skipLearnOnSharedStore } from './shared.js';
 import { HOOK_MARKERS, HOOKS, hippoBlock } from '../hooks/hook-blocks.js';
@@ -47,8 +47,13 @@ function scanForGitRepos(rootDir, maxDepth = 2) {
         }
         catch (err) {
             const code = errorCode(err);
-            if (!QUIET_SCAN_ERRORS.has(code))
-                log.warn(`repo scan skipped ${dir}`, { code: code || 'unknown', reason: errorMessage(err) });
+            if (!QUIET_SCAN_ERRORS.has(code)) {
+                log.warn(`repo scan skipped ${dir}`, {
+                    code: code || 'unknown',
+                    reason: errorMessage(err),
+                    ...errorFields(err),
+                });
+            }
         }
     }
     // Check if rootDir itself is a git repo
@@ -125,8 +130,9 @@ async function cmdInitScan(scanDir, tenantId, flags) {
         totalLessons += added;
         totalLowInfo += lowInfo;
         const status = alreadyExists ? 'existing' : 'new';
-        const entries = listMemories(cliApiContext(path.join(repo, '.hippo'), tenantId), { everyTenant: true });
-        console.log(`  ${path.basename(repo).padEnd(25)} ${status.padEnd(10)} ${entries.length} memories${added > 0 ? ` (+${added} from git)` : ''}`);
+        const entries = await listMemories(cliApiContext(path.join(repo, '.hippo'), tenantId), { everyTenant: true });
+        console.log(`  ${path.basename(repo).padEnd(25)} ${status.padEnd(10)} ${entries.length} ` +
+            `memories${added > 0 ? ` (+${added} from git)` : ''}`);
     }
     printScanSummary(repos.length, totalLessons, totalLowInfo);
     if (learn) {
@@ -204,7 +210,10 @@ export async function handleInit({ hippoRoot, tenantId, flags }) {
     if (learn)
         printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }));
 }
-/** Every write init makes into agent config (instruction blocks, hooks, plugins) is an automatic integration, so one switch skips them all. */
+/**
+ * Every write init makes into agent config (instruction blocks, hooks, plugins) is an automatic integration, so one
+ * switch skips them all.
+ */
 function initInstallsIntegrations(flags) {
     if (flags['no-hooks'])
         return false;
@@ -246,7 +255,8 @@ function patchInstructionFiles(dir, agents) {
         if (!hookDef)
             continue;
         const targetPath = path.resolve(dir, hookDef.file);
-        // Never create the file: a marker such as .codex or .claude/settings.json does not ask for a new AGENTS.md or CLAUDE.md.
+        // Never create the file: a marker such as .codex or .claude/settings.json does not ask for a new AGENTS.md or
+        // CLAUDE.md.
         if (!fs.existsSync(targetPath) || seen.has(targetPath))
             continue;
         seen.add(targetPath);
@@ -310,7 +320,8 @@ function installClaudeCodeSettingsHooks(hook) {
     }
 }
 function installOpencodeUserPlugin() {
-    // opencode uses a TS plugin, not Claude Code's JSON-hook schema (see OPENCODE_PLUGIN_SOURCE in src/hooks/opencode.ts).
+    // opencode uses a TS plugin, not Claude Code's JSON-hook schema (see OPENCODE_PLUGIN_SOURCE in
+    // src/hooks/opencode.ts).
     const result = installOpencodePlugin();
     if (result.installed) {
         console.log(`   Auto-installed hippo opencode plugin -> ${result.pluginPath}`);
@@ -322,7 +333,10 @@ function installOpencodeUserPlugin() {
         console.log(`   WARNING: opencode.json is unparseable; legacy hooks block could not be auto-removed. Fix the file manually.`);
     }
 }
-/** Claude Code settings hooks, Codex's hooks.json and the OpenCode plugin, under the home directory; idempotent, so re-running init adds newer hooks. */
+/**
+ * Claude Code settings hooks, Codex's hooks.json and the OpenCode plugin, under the home directory; idempotent, so
+ * re-running init adds newer hooks.
+ */
 function installUserLevelHooks(agents, codexHint) {
     for (const hook of agents) {
         // The Codex capture wrapper swaps the codex launcher binary, so init only points at the opt-in.
@@ -332,7 +346,8 @@ function installUserLevelHooks(agents, codexHint) {
         // Checked first so init never creates ~/.codex on a machine without Codex.
         if (hook === 'codex' && isCodexPresent())
             installCodexMemoryHooks('   ');
-        // For Claude Code, also install SessionEnd+SessionStart entries in settings.json, keeping `hippo init` in lockstep with
+        // For Claude Code, also install SessionEnd+SessionStart entries in settings.json, keeping `hippo init` in lockstep
+        // with
         // `hippo hook install claude-code` and `hippo setup`.
         if (hook === 'claude-code')
             installClaudeCodeSettingsHooks(hook);

package/dist/cli/install-steps.d.ts

@@ -1,8 +1,17 @@
+import { type ExecFileSyncOptionsWithStringEncoding } from 'child_process';
 import { type InstallResult } from '../hooks/json-hooks.js';
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
+/**
+ * Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an
+ * untrusted hook.
+ */
 export declare function installCodexMemoryHooks(indent: string): void;
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was
+/**
+ * The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo
+ * can edit and so was
  * left unchanged; true when it printed. */
 export declare function warnClaudeSettingsUnusable(result: Pick<InstallResult, 'settingsPath' | 'invalidJson'>, indent: string, action?: 'install' | 'uninstall'): boolean;
-export declare function setupDailySchedule(globalRoot: string): void;
+/** Runs one scheduler program from argv with no shell; tests hand in a stand-in so no real schtasks or crontab runs. */
+type RunScheduler = (file: string, args: readonly string[], opts: ExecFileSyncOptionsWithStringEncoding) => string;
+export declare function setupDailySchedule(globalRoot: string, run?: RunScheduler): void;
+export {};
 //# sourceMappingURL=install-steps.d.ts.map

package/dist/cli/install-steps.js

@@ -1,15 +1,19 @@
 // The init and setup steps that touch the machine: Codex hooks, the settings.json warning and the daily schedule.
 import * as path from 'path';
-import { execFileSync, execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 import { installJsonHooks } from '../hooks/json-hooks.js';
 import { CODEX_TRUST_LINE } from '../hooks/shared.js';
 import { envSkipSchedule } from '../util/env.js';
 import { DAILY_TASK_NAME, buildDailyRunnerCommand, hasUnsafeRunnerPathChars, buildSchtasksCreateArgs, buildWindowsTaskRun, quoteInsideWindowsArg, } from './scheduler.js';
-/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
+/**
+ * Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an
+ * untrusted hook.
+ */
 export function installCodexMemoryHooks(indent) {
     const result = installJsonHooks('codex');
     if (result.invalidJson) {
-        console.log(`${indent}WARNING: ${result.settingsPath} is not a hooks file hippo can merge into; fix it, then run \`hippo hook install codex\`.`);
+        console.log(`${indent}WARNING: ${result.settingsPath} is not a hooks file hippo can merge into; fix it, then run \`hippo ` +
+            `hook install codex\`.`);
         return;
     }
     const added = [
@@ -21,7 +25,9 @@ export function installCodexMemoryHooks(indent) {
         : `${indent}hippo's Codex memory hooks already in ${result.settingsPath}`);
     console.log(`${indent}${CODEX_TRUST_LINE}`);
 }
-/** The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo can edit and so was
+/**
+ * The one line init, hook install, hook uninstall and setup print when Claude Code's settings.json is not JSON hippo
+ * can edit and so was
  * left unchanged; true when it printed. */
 export function warnClaudeSettingsUnusable(result, indent, action = 'install') {
     if (!result.invalidJson)
@@ -30,17 +36,34 @@ export function warnClaudeSettingsUnusable(result, indent, action = 'install') {
         `fix it, then run \`hippo hook ${action} claude-code\`.`);
     return true;
 }
-/** Machine-level daily runner sweeping all registered workspaces: user crontab on Linux/macOS, a scheduled task on Windows; skips if installed. */
-/** Bound on each schtasks and crontab call, so a scheduler that never answers cannot hang `hippo init` or `hippo setup`. */
+/**
+ * Machine-level daily runner sweeping all registered workspaces: user crontab on Linux/macOS, a scheduled task on
+ * Windows; skips if installed.
+ */
+/**
+ * Bound on each schtasks and crontab call, so a scheduler that never answers cannot hang `hippo init` or `hippo setup`.
+ */
 const SCHEDULER_CALL_TIMEOUT_MS = 30_000;
-/** Node kills a child at its timeout and reports ETIMEDOUT; every other failure here means the scheduler refused or is missing. */
+// Piped stderr stands in for `2>nul` and `2>/dev/null`, so no shell is needed to keep the scheduler's complaints off
+// the terminal.
+const SCHEDULER_CALL = {
+    encoding: 'utf-8',
+    stdio: 'pipe',
+    windowsHide: true,
+    timeout: SCHEDULER_CALL_TIMEOUT_MS,
+};
+/**
+ * Node kills a child at its timeout and reports ETIMEDOUT; every other failure here means the scheduler refused or is
+ * missing.
+ */
 function schedulerTimedOut(err) {
     return err instanceof Error && 'code' in err && err.code === 'ETIMEDOUT';
 }
 function warnSchedulerTimedOut(command) {
-    console.log(`   ${command} did not answer within ${SCHEDULER_CALL_TIMEOUT_MS / 1000} s and was stopped, so the daily runner is not scheduled.`);
+    console.log(`   ${command} did not answer within ${SCHEDULER_CALL_TIMEOUT_MS / 1000} s and was stopped, so the daily runner ` +
+        `is not scheduled.`);
 }
-export function setupDailySchedule(globalRoot) {
+export function setupDailySchedule(globalRoot, run = execFileSync) {
     // Checked here, not per caller, so init, init --scan and setup all honour it.
     if (envSkipSchedule()) {
         console.log('   HIPPO_SKIP_SCHEDULE=1, so the machine-level daily runner was not scheduled.');
@@ -55,14 +78,14 @@ export function setupDailySchedule(globalRoot) {
     const taskName = DAILY_TASK_NAME;
     const cmd = buildDailyRunnerCommand(runnerDir);
     if (isWindows)
-        scheduleOnWindows(taskName, cmd);
+        scheduleOnWindows(taskName, cmd, run);
     else
-        scheduleOnCrontab(taskName, cmd);
+        scheduleOnCrontab(taskName, cmd, run);
 }
-function scheduleOnWindows(taskName, cmd) {
+function scheduleOnWindows(taskName, cmd, run) {
     // Check if task already exists
     try {
-        const existing = execSync(`schtasks /query /tn "${taskName}" 2>nul`, { encoding: 'utf-8', windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        const existing = run('schtasks', ['/query', '/tn', taskName], SCHEDULER_CALL);
         if (existing.includes(taskName)) {
             return; // already scheduled
         }
@@ -73,7 +96,7 @@ function scheduleOnWindows(taskName, cmd) {
             warnSchedulerTimedOut('schtasks /query');
     }
     try {
-        execFileSync('schtasks', buildSchtasksCreateArgs(taskName, cmd), { stdio: 'pipe', windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        run('schtasks', buildSchtasksCreateArgs(taskName, cmd), SCHEDULER_CALL);
         console.log(`   Scheduled machine-level daily runner (6:15am) via Task Scheduler: ${taskName}`);
     }
     catch (err) {
@@ -81,20 +104,21 @@ function scheduleOnWindows(taskName, cmd) {
             warnSchedulerTimedOut('schtasks /create');
         // No admin rights or schtasks unavailable, fall back to printing instructions
         console.log(`   To schedule the machine-level daily runner, run:`);
-        console.log(`   schtasks /create /tn "${taskName}" /tr "${quoteInsideWindowsArg(buildWindowsTaskRun(cmd))}" /sc daily /st 06:15`);
+        console.log(`   schtasks /create /tn "${taskName}" /tr "${quoteInsideWindowsArg(buildWindowsTaskRun(cmd))}" /sc daily /st ` +
+            `06:15`);
     }
 }
-function scheduleOnCrontab(taskName, cmd) {
+function scheduleOnCrontab(taskName, cmd, run) {
     // Unix: check crontab for existing entry
     const marker = `# hippo:${taskName}`;
     try {
-        const existing = execSync('crontab -l 2>/dev/null', { encoding: 'utf-8', windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        const existing = run('crontab', ['-l'], SCHEDULER_CALL);
         if (existing.includes(marker)) {
             return; // already scheduled
         }
         const cronLine = `15 6 * * * ${cmd} ${marker}`;
         const newCrontab = existing.trimEnd() + '\n' + cronLine + '\n';
-        execSync('crontab -', { input: newCrontab, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, timeout: SCHEDULER_CALL_TIMEOUT_MS });
+        run('crontab', ['-'], { ...SCHEDULER_CALL, input: newCrontab });
         console.log(`   Scheduled machine-level daily runner (6:15am) via crontab`);
     }
     catch (err) {

package/dist/cli/last-sleep.d.ts

@@ -1,5 +1,8 @@
 import { type CliFlags, type CommandContext } from './flag-values.js';
-/** The line the user sees when the last sleep failed, a spool step hit an unexpected error, or the spool holds `.bad` files; null when none did. */
+/**
+ * The line the user sees when the last sleep failed, a spool step hit an unexpected error, or the spool holds `.bad`
+ * files; null when none did.
+ */
 export declare function sleepProblems(logText: string, bad: number): string | null;
 /** Prints the SessionEnd sleep log on stderr, then clears it. In a hook, stdout carries only `systemMessage`,
  *  because Claude Code shows that to the user and adds any other SessionStart stdout to the model's context. */