hippo-memory 1.72.0 → 2.0.0

package/dist/cli/decisions.js

@@ -7,7 +7,6 @@ import { nonEmptyStringFlag, flagIsTrue, stringFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { cliApiContext } from './api-context.js';
 import { closeObject, foundOrExit, idArgOrExit, listObjects, printLifecycleTail } from './object-verbs.js';
-import { parseObjectId } from './lenient-id.js';
 import { errorMessage } from '../util/log.js';
 import { CliExit } from './exit.js';
 const DECISION = { cmd: 'decide', noun: 'Decision', idLabel: 'decision' };
@@ -27,7 +26,7 @@ function decideList(hippoRoot, tenantId, flags) {
     });
 }
 function decideGet(hippoRoot, tenantId, args) {
-    const id = idArgOrExit(args, 'Usage: hippo decide get <id>', DECISION.idLabel, parseObjectId);
+    const id = idArgOrExit(args, 'Usage: hippo decide get <id>', DECISION.idLabel);
     const decision = foundOrExit(decisionsModule.loadDecisionById(hippoRoot, tenantId, id), DECISION.noun, id);
     console.log(`Decision #${decision.id}`);
     console.log(`  status: ${decision.status}`);
@@ -37,7 +36,7 @@ function decideGet(hippoRoot, tenantId, args) {
     printLifecycleTail(decision);
 }
 function decideClose(hippoRoot, tenantId, args) {
-    closeObject(args, DECISION, (id) => decisionsModule.closeDecision(hippoRoot, tenantId, id), parseObjectId);
+    closeObject(args, DECISION, (id) => decisionsModule.closeDecision(hippoRoot, tenantId, id));
 }
 export async function handleDecide({ hippoRoot, tenantId, args, flags }) {
     requireInit(hippoRoot);
@@ -83,7 +82,7 @@ async function decideCreate(hippoRoot, tenantId, decisionText, flags) {
         extraTags: decisionPathTags,
     });
     if (oldEntry)
-        weakenSupersededMemory(hippoRoot, oldEntry, supersedesMemId);
+        weakenOrWarn(hippoRoot, oldEntry, supersedesMemId);
     console.log(`Decision recorded: #${created.id}`);
     if (created.memoryId)
         console.log(`  memory: ${created.memoryId}`);
@@ -97,7 +96,7 @@ function exitWithDecideUsage() {
     printError('       hippo decide close <id>');
     throw new CliExit(1);
 }
-function weakenSupersededMemory(hippoRoot, oldEntry, supersedesMemId) {
+function weakenOrWarn(hippoRoot, oldEntry, supersedesMemId) {
     // Best-effort and last: saveDecision already committed. Failing here would make a retry find no active
     // decision for the old memory and create a duplicate active successor, so warn instead.
     try {

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

@@ -25,5 +25,7 @@ export declare function payloadCwdRoot(hippoRoot: string, stdinText: string | un
  * 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. */
-export declare function inPilotHoldout(hippoRoot: string, tenantId: string, sessionId: string | undefined, write: boolean): boolean;
+export declare function inPilotHoldout(hippoRoot: string, tenantId: string, sessionId: string | undefined, opts: {
+    write: boolean;
+}): boolean;
 //# sourceMappingURL=hook-runtime.d.ts.map

package/dist/cli/hook-runtime.js

@@ -106,7 +106,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, write) {
-    return sessionPilotArm(hippoRoot, tenantId, sessionId, write) === 'holdout';
+export function inPilotHoldout(hippoRoot, tenantId, sessionId, opts) {
+    return sessionPilotArm(hippoRoot, tenantId, sessionId, opts.write) === 'holdout';
 }
 //# sourceMappingURL=hook-runtime.js.map

package/dist/cli/init.d.ts

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

package/dist/cli/init.js

@@ -68,12 +68,12 @@ function initScannedRepo(repo, tenantId, globalRoot) {
     return alreadyExists;
 }
 /** Seeds one scanned repo from git history and its agents' notes, unless --no-learn. */
-function learnScannedRepo(repo, tenantId, seedDays, learn, machine, agentImport) {
+async function learnScannedRepo(repo, tenantId, seedDays, learn, machine, agentImport) {
     const repoHippo = path.join(repo, '.hippo');
     let added = 0;
     let lowInfo = 0;
     if (learn && isGitRepo(repo)) {
-        const result = learnFromRepo(repoHippo, tenantId, repo, seedDays, path.basename(repo));
+        const result = await learnFromRepo(repoHippo, tenantId, repo, seedDays, path.basename(repo));
         added = result.added;
         lowInfo = result.lowInfo;
     }
@@ -102,7 +102,7 @@ function printScanSummary(repoCount, totalLessons, totalLowInfo) {
         (totalLowInfo > 0 ? `, ${totalLowInfo} low-information subject(s) dropped` : '') +
         '.');
 }
-function cmdInitScan(scanDir, tenantId, flags) {
+async function cmdInitScan(scanDir, tenantId, flags) {
     const resolved = path.resolve(scanDir);
     console.log(`Scanning ${resolved} for git repositories...\n`);
     const repos = scanForGitRepos(resolved);
@@ -121,7 +121,7 @@ function cmdInitScan(scanDir, tenantId, flags) {
     const learn = !flags['no-learn'];
     for (const repo of repos) {
         const alreadyExists = initScannedRepo(repo, tenantId, globalRoot);
-        const { added, lowInfo } = learnScannedRepo(repo, tenantId, seedDays, learn, machine, agentImport);
+        const { added, lowInfo } = await learnScannedRepo(repo, tenantId, seedDays, learn, machine, agentImport);
         totalLessons += added;
         totalLowInfo += lowInfo;
         const status = alreadyExists ? 'existing' : 'new';
@@ -153,12 +153,12 @@ function initGlobalOnly(flags) {
     if (!flags['no-learn'])
         printAgentImport(importUserMemories(globalRoot, { machine: currentMachine() }));
 }
-function seedFromGitHistory(hippoRoot, tenantId) {
+async function seedFromGitHistory(hippoRoot, tenantId) {
     if (!isGitRepo(process.cwd()))
         return;
     const seedDays = 30;
     console.log(`\n   Seeding memories from last ${seedDays} days of git history...`);
-    const { added, skipped } = learnFromRepo(hippoRoot, tenantId, process.cwd(), seedDays);
+    const { added, skipped } = await learnFromRepo(hippoRoot, tenantId, process.cwd(), seedDays);
     if (added > 0) {
         console.log(`   Learned ${added} lessons from git (${skipped} duplicates skipped).`);
     }
@@ -166,11 +166,11 @@ function seedFromGitHistory(hippoRoot, tenantId) {
         console.log(`   No matching commits found in git history.`);
     }
 }
-export function handleInit({ hippoRoot, tenantId, flags }) {
+export async function handleInit({ hippoRoot, tenantId, flags }) {
     // Handle --scan mode
     if (flags['scan']) {
         const scanDir = stringFlag(flags, 'scan') ?? os.homedir();
-        cmdInitScan(scanDir, tenantId, flags);
+        await cmdInitScan(scanDir, tenantId, flags);
         return;
     }
     if (flags['global']) {
@@ -199,7 +199,7 @@ export function handleInit({ hippoRoot, tenantId, flags }) {
     const learn = !flags['no-learn'] && !skipLearnOnSharedStore(hippoRoot);
     // Seed with git history on first init (unless --no-learn)
     if (!alreadyExists && learn && !flags['global'])
-        seedFromGitHistory(hippoRoot, tenantId);
+        await seedFromGitHistory(hippoRoot, tenantId);
     // Every run, not only the first: an agent's notes change between inits.
     if (learn)
         printAgentImport(importForStore(hippoRoot, { machine: currentMachine() }));

package/dist/cli/object-verbs.d.ts

@@ -14,7 +14,7 @@ export interface ObjectListSpec<O, S extends string> {
 }
 export declare function listObjects<O, S extends string>(flags: CliFlags, spec: ObjectListSpec<O, S>): void;
 /** The `<id>` after the subcommand; prints `usage` and exits 1 when it is missing. */
-export declare function idArgOrExit(args: string[], usage: string, label: string, parseId?: (raw: string, label: string) => number): number;
+export declare function idArgOrExit(args: string[], usage: string, label: string): number;
 export declare function foundOrExit<O>(found: O | null | undefined, noun: string, id: number): O;
 /** How a kind is named in usage lines (`cmd`), in messages (`noun`) and in the invalid-id error (`idLabel`). */
 export interface ObjectNames {
@@ -25,7 +25,7 @@ export interface ObjectNames {
 /** `hippo <cmd> close <id>` for a kind whose close call returns the closed row. */
 export declare function closeObject(args: string[], names: ObjectNames, close: (id: number) => {
     id: number;
-}, parseId?: (raw: string, label: string) => number): void;
+}): void;
 interface LifecycleTail {
     readonly changeSummary?: string | null;
     readonly supersededBy: number | null;

package/dist/cli/object-verbs.js

@@ -29,13 +29,13 @@ export function listObjects(flags, spec) {
         spec.printRow(o);
 }
 /** The `<id>` after the subcommand; prints `usage` and exits 1 when it is missing. */
-export function idArgOrExit(args, usage, label, parseId = parsePositiveId) {
+export function idArgOrExit(args, usage, label) {
     const idRaw = args[1];
     if (!idRaw) {
         printError(usage);
         throw new CliExit(1);
     }
-    return parseId(idRaw, label);
+    return parsePositiveId(idRaw, label);
 }
 export function foundOrExit(found, noun, id) {
     if (!found) {
@@ -45,8 +45,8 @@ export function foundOrExit(found, noun, id) {
     return found;
 }
 /** `hippo <cmd> close <id>` for a kind whose close call returns the closed row. */
-export function closeObject(args, names, close, parseId = parsePositiveId) {
-    const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel, parseId);
+export function closeObject(args, names, close) {
+    const id = idArgOrExit(args, `Usage: hippo ${names.cmd} close <id>`, names.idLabel);
     console.log(`${names.noun} #${close(id).id} closed.`);
 }
 /** The detail lines every `get` ends with. */

package/dist/cli/predictions.js

@@ -6,12 +6,11 @@ import { printError } from './output.js';
 import { parseListLimit, stringFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { foundOrExit, idArgOrExit, requireStatus } from './object-verbs.js';
-import { parseObjectId } from './lenient-id.js';
 import { CliExit } from './exit.js';
 const BASERATE_DECIMALS = 3;
 const PREDICTION_NOUN = 'Prediction';
 async function predictClose(ctx, args, flags) {
-    const id = idArgOrExit(args, 'Usage: hippo predict close <id> --state <closed|closed-unknown> [--actual <v>] [--note "..."]', 'prediction', parseObjectId);
+    const id = idArgOrExit(args, 'Usage: hippo predict close <id> --state <closed|closed-unknown> [--actual <v>] [--note "..."]', 'prediction');
     const stateRaw = (stringFlag(flags, 'state') ?? '').trim();
     // SAFETY: Set.has only compares by value, so a string outside the closure states is a plain miss.
     if (!VALID_CLOSURE_STATES.has(stateRaw) || stateRaw === 'open') {
@@ -77,7 +76,7 @@ async function predictList(ctx, flags) {
     }
 }
 async function predictShow(ctx, args) {
-    const id = idArgOrExit(args, 'Usage: hippo predict show <id>', 'prediction', parseObjectId);
+    const id = idArgOrExit(args, 'Usage: hippo predict show <id>', 'prediction');
     const pred = foundOrExit(await predictionsApi.predictionById(ctx, id), PREDICTION_NOUN, id);
     console.log(`Prediction #${pred.id}`);
     console.log(`  class: ${pred.classTag}`);

package/dist/cli/quality-repair-once.d.ts

@@ -1,3 +1,3 @@
 /** Fault-isolated like the project tag repair: a failure warns, leaves the store unmarked and runs again next time. */
-export declare function repairQualityOnceAt(root: string, tenantId: string): void;
+export declare function repairQualityOnceAt(root: string, tenantId: string): Promise<void>;
 //# sourceMappingURL=quality-repair-once.d.ts.map

package/dist/cli/quality-repair-once.js

@@ -5,9 +5,9 @@ import { getGlobalRoot } from '../sharing/global-store.js';
 import { repairMemoryQualityOnce } from '../api/audit.js';
 import { cliApiContext } from './api-context.js';
 /** Fault-isolated like the project tag repair: a failure warns, leaves the store unmarked and runs again next time. */
-export function repairQualityOnceAt(root, tenantId) {
+export async function repairQualityOnceAt(root, tenantId) {
     try {
-        const result = repairMemoryQualityOnce(cliApiContext(root, tenantId));
+        const result = await repairMemoryQualityOnce(cliApiContext(root, tenantId));
         if (result === null)
             return;
         if (!result.supported) {

package/dist/cli/refine-llm.js

@@ -61,6 +61,7 @@ function describeRefineFailure(failure) {
         case 'request': return `refine: request failed: ${failure.message}`;
         case 'http': return `refine: API answered HTTP ${failure.status}${failure.detail ? `: ${failure.detail}` : ''}`;
         case 'unreadable': return `refine: unreadable response: ${failure.message}`;
+        case 'empty': return 'refine: response held no text';
     }
 }
 function isConsolidated(entry) {
@@ -121,7 +122,7 @@ async function refineOneEntry(ctx, reach, entry, opts, result) {
         result.details.push({ id: entry.id, status: 'refined', reason: 'dry-run (no write)' });
         return;
     }
-    storeRefinement(cliApiContext(ctx.hippoRoot, entry.tenantId), entry, refined);
+    storeRefinement(cliApiContext(ctx.hippoRoot, entry.tenant_id), entry, refined);
     result.refined++;
     result.details.push({ id: entry.id, status: 'refined' });
 }

package/dist/cli/remember.js

@@ -97,7 +97,7 @@ async function cmdRemember(hippoRoot, tenantId, text, flags) {
     const { requested: requestedTags, all: allTags } = rememberTags(flags, process.cwd());
     const envelope = parseRememberEnvelope(flags);
     const ctx = cliApiContext(targetRoot, tenantId);
-    const outcome = api.rememberLocally(ctx, {
+    const outcome = await api.rememberLocally(ctx, {
         content: text,
         kind: envelope.kind,
         scope: envelope.scope ?? undefined,
@@ -173,7 +173,7 @@ async function cmdSupersede(hippoRoot, tenantId, oldId, newContent, flags) {
     };
     let newId;
     try {
-        ({ newId } = api.supersede(cliApiContext(hippoRoot, tenantId), oldId, newContent, overrides));
+        ({ newId } = await api.supersede(cliApiContext(hippoRoot, tenantId), oldId, newContent, overrides));
     }
     catch (err) {
         if (err instanceof NotFoundError)
@@ -205,7 +205,7 @@ function traceTags(flags) {
             ? [String(rawTags)]
             : [];
 }
-function cmdTraceRecord(hippoRoot, tenantId, flags) {
+async function cmdTraceRecord(hippoRoot, tenantId, flags) {
     requireInit(hippoRoot);
     const task = String(flags['task'] ?? '').trim();
     const stepsJson = String(flags['steps'] ?? '').trim();
@@ -227,7 +227,7 @@ function cmdTraceRecord(hippoRoot, tenantId, flags) {
         steps,
         outcome,
     });
-    const { id } = api.remember(cliApiContext(hippoRoot, tenantId), {
+    const { id } = await api.remember(cliApiContext(hippoRoot, tenantId), {
         content,
         tags,
         local: {
@@ -427,7 +427,7 @@ export async function handleSupersede({ hippoRoot, tenantId, args, flags }) {
 export async function handleTrace({ hippoRoot, tenantId, args, flags }) {
     const sub = args[0] ? String(args[0]) : '';
     if (sub === 'record') {
-        cmdTraceRecord(hippoRoot, tenantId, flags);
+        await cmdTraceRecord(hippoRoot, tenantId, flags);
         return;
     }
     if (!sub) {

package/dist/cli/serve.js

@@ -1,10 +1,10 @@
 // Long-running verbs: `hippo dashboard`, `hippo mcp` and `hippo serve`.
 import { installCrashHandlers } from '../util/crash-handlers.js';
-import { envAllowKeylessLocal, envPort, envRequireAuth, envTlsCert, envTlsKey } from '../util/env.js';
+import { envAllowKeylessLocal, envKeylessLocalRole, envPort, envRequireAuth, envTlsCert, envTlsKey } from '../util/env.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { printError } from './output.js';
-import { stringFlagOrExit, stringFlag, numberFlag } from './flag-values.js';
+import { flagIsTrue, stringFlagOrExit, stringFlag, numberFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { errorMessage } from '../util/log.js';
 import { CliExit } from './exit.js';
@@ -52,7 +52,10 @@ function keyRuleLine() {
     if (envRequireAuth())
         return 'every request needs an API key (HIPPO_REQUIRE_AUTH=1)';
     if (envAllowKeylessLocal()) {
-        return 'requests from this machine need no API key and act as host admin (HIPPO_ALLOW_KEYLESS_LOCAL=1); unset it to require a key on every request';
+        const role = envKeylessLocalRole() === 'admin'
+            ? 'act as host admin (HIPPO_ALLOW_KEYLESS_LOCAL=1, HIPPO_KEYLESS_LOCAL_ROLE=admin)'
+            : 'act as a member (HIPPO_ALLOW_KEYLESS_LOCAL=1; HIPPO_KEYLESS_LOCAL_ROLE=admin opens sleep and the quarantine routes)';
+        return `requests from this machine need no API key and ${role}; unset HIPPO_ALLOW_KEYLESS_LOCAL to require a key on every request`;
     }
     return 'every request needs an API key: mint one with `hippo auth create` and send it as "Authorization: Bearer <key>" ' +
         '(the hippo CLI reads HIPPO_API_KEY). To let requests from this machine in without a key, start with HIPPO_ALLOW_KEYLESS_LOCAL=1';
@@ -68,7 +71,9 @@ export async function handleServe({ hippoRoot, flags }) {
     const host = stringFlag(flags, 'host') ?? DEFAULT_SERVER_HOST;
     const tls = readTlsFiles(flags);
     const { serve } = await import('../server.js');
-    const handle = await serve({ hippoRoot, port, host, handleSignals: true, tls });
+    // Unset rather than false without the flag, so HIPPO_ALLOW_CLEARTEXT=1 still applies.
+    const allowCleartext = flagIsTrue(flags, 'allow-cleartext') || undefined;
+    const handle = await serve({ hippoRoot, port, host, handleSignals: true, tls, allowCleartext });
     console.log(`hippo serve listening on ${handle.url} (pid ${process.pid})`);
     console.log(keyRuleLine());
     console.log(`pidfile: ${path.join(hippoRoot, 'server.pid')}`);

package/dist/cli/session-hooks.d.ts

@@ -3,10 +3,6 @@ import { type CliFlags, type CommandContext } from './flag-values.js';
  * The child logs to a file that the next SessionStart reads via `hippo last-sleep`. */
 export declare function handleSessionEnd({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 export declare function handleSessionEndWorker({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
-/** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
-export declare function quoteCmdArg(arg: string): string;
-/** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
-export declare function cmdShimArgs(shimPath: string, forwardArgs: readonly string[]): string[];
 export declare function handleCodexRun({ hippoRoot, tenantId, args }: CommandContext): void;
 export declare function cmdCodexSessionEndWorker(hippoRoot: string, tenantId: string, flags: CliFlags): Promise<void>;
 export declare function handleCodexSessionEndWorker({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;

package/dist/cli/session-hooks.js

@@ -21,9 +21,10 @@ import { isStringValue, readSessionEnd, readVscodeStop } from '../core/capture-c
 import { loadConfig } from '../core/config.js';
 import { autoSleepDue } from '../api/auto-sleep.js';
 import { COMPACTION_DB_WAIT_MS } from '../core/compaction-timing.js';
-import { bookSessionRereads, closeEndedSession, compactResumeBlock } from '../api/session-end.js';
+import { compactResumeBlock, sessionEndWork as runSessionEnd } from '../api/session-end.js';
 import { normaliseHookPayload, readHookStdin, readStdinBounded } from './stdin.js';
 import { errorMessage, log } from '../util/log.js';
+import { cmdShimArgs } from '../util/spawn-argv.js';
 import { bookLedgerTurn } from '../api/ledger-db.js';
 import { flushDeliveryRecorder, startDeliveryRecorder, startToolFailureRecorder } from '../api/prompt-hook.js';
 import { printError } from './output.js';
@@ -52,7 +53,7 @@ function cmdCompactResume(hippoRoot, tenantId, stdinText, stdinTimedOut) {
             });
         }
         // A compaction follows a prompt or SessionStart that booked the arm, so this only reads it.
-        if (!suppressOutput && payloadSessionId !== null && inPilotHoldout(hippoRoot, tenantId, payloadSessionId, false)) {
+        if (!suppressOutput && payloadSessionId !== null && inPilotHoldout(hippoRoot, tenantId, payloadSessionId, { write: false })) {
             suppressOutput = true;
             rec?.disabled();
         }
@@ -75,8 +76,7 @@ function restoreCompactSnapshot(hippoRoot, tenantId, payloadSessionId, rec) {
         return;
     // Printed in one write so the ledger books exactly the text the model is handed.
     console.log(text);
-    rec?.delivered({ state: 'sent', emittedText: `${text}
-` });
+    rec?.delivered({ state: 'sent', emittedText: `${text}\n` });
     bookLedgerTurn(hippoRoot, {
         uses: [{
                 tenantId, sessionId: payloadSessionId, surface: 'compact_resume', event: 'inject', items: 1, tokens: estimateTokens(text),
@@ -111,20 +111,15 @@ export async function handleSessionEnd({ hippoRoot, tenantId, flags }) {
     const named = input?.transcriptPath ?? null;
     const transcriptPath = (named !== null && fs.existsSync(named) ? named : null)
         ?? (runtime === 'copilot' && sessionId ? copilotTranscriptFor(sessionId) : null);
+    const worker = { logFile, transcriptPath, sessionId, turn };
     try {
-        spawnSessionEndWorker(sessionEndWorkerArgs(logFile, transcriptPath, sessionId, turn));
+        spawnSessionEndWorker(sessionEndWorkerArgs(worker));
     }
     catch (err) {
         log.debug(`session-end: the worker did not spawn, running inline: ${errorMessage(err)}`);
         // Inline is the last resort, handed what the child's argv would have carried.
-        if (logFile)
-            flags['log-file'] = logFile;
-        if (transcriptPath)
-            flags['transcript'] = transcriptPath;
-        if (sessionId)
-            flags['session-id'] = sessionId;
         try {
-            await cmdSessionEndWorker(root, tenantId, flags);
+            await cmdSessionEndWorker(root, tenantId, inlineWorkerFlags(flags, worker));
         }
         finally {
             await runHookWithStores(() => flushDeliveryRecorder(rec));
@@ -142,7 +137,8 @@ function sessionEndInput(stdinText, timedOut, runtime) {
     log.debug(`session-end: ${receipt.reason}`);
     return null;
 }
-function sessionEndWorkerArgs(logFile, transcriptPath, sessionId, turn) {
+function sessionEndWorkerArgs(o) {
+    const { logFile, transcriptPath, sessionId, turn } = o;
     const workerArgs = [process.argv[1], '__session-end-worker'];
     if (logFile)
         workerArgs.push('--log-file', logFile);
@@ -154,6 +150,26 @@ function sessionEndWorkerArgs(logFile, transcriptPath, sessionId, turn) {
         workerArgs.push('--turn');
     return workerArgs;
 }
+/** The flags the detached worker would parse from its argv, so the inline run sees what the child would have; the hook's own flags fill the gaps. */
+function inlineWorkerFlags(flags, w) {
+    const out = {};
+    const keep = (name, value) => {
+        if (value)
+            out[name] = value;
+    };
+    keep('log-file', w.logFile ?? flags['log-file']);
+    keep('transcript', w.transcriptPath ?? flags['transcript']);
+    keep('session-id', w.sessionId ?? flags['session-id']);
+    if (flagIsTrue(flags, 'turn'))
+        out['turn'] = true;
+    if (flagIsTrue(flags, 'dry-run'))
+        out['dry-run'] = true;
+    if (flagIsTrue(flags, 'no-learn'))
+        out['no-learn'] = true;
+    if (flagIsTrue(flags, 'no-share'))
+        out['no-share'] = true;
+    return out;
+}
 function spawnSessionEndWorker(workerArgs) {
     const child = spawn(process.execPath, workerArgs, {
         detached: true,
@@ -176,48 +192,37 @@ async function cmdSessionEndWorker(hippoRoot, tenantId, flags) {
 export function handleSessionEndWorker({ hippoRoot, tenantId, flags }) {
     return cmdSessionEndWorker(hippoRoot, tenantId, flags);
 }
-async function sessionEndWork(hippoRoot, tenantId, flags, mode) {
+function sessionEndWork(hippoRoot, tenantId, flags, mode) {
     const transcriptPath = stringFlag(flags, 'transcript');
-    const closeLogFile = stringFlag(flags, 'log-file') ?? null;
-    const closeSessionId = stringFlag(flags, 'session-id') ?? null;
-    const rereadLog = await bookSessionRereads(cliApiContext(hippoRoot, tenantId), transcriptPath, closeSessionId)
-        .catch((err) => [`re-read count failed: ${errorMessage(err)}`]);
-    // Sleep starts the log file afresh, so the lines go in after it; on exit too, in case sleep exits the process.
-    const flushRereadLog = () => { for (const line of rereadLog.splice(0))
-        appendSessionEndCloseLog(closeLogFile, line); };
-    process.once('exit', flushRereadLog);
-    // Like the other hooks: project store, else global; a folder with neither must not get one made.
-    const store = hookStoreRoot(hippoRoot);
-    if (!isInitialized(store)) {
-        appendSessionEndCloseLog(closeLogFile, 'skip: no hippo store for this folder or globally', { startFresh: true });
-        flushRereadLog();
-        return;
-    }
-    if (mode === 'turn' && closeSessionId)
-        await sleepIfDue(hippoRoot, tenantId, flags, closeLogFile, transcriptPath, closeSessionId);
-    else
-        await sleepProjectStore(hippoRoot, tenantId, flags, closeLogFile, transcriptPath);
-    flushRereadLog();
-    const digestLog = (message) => appendSessionEndCloseLog(closeLogFile, message);
-    const scan = transcriptPath ? readSessionScan(transcriptPath, digestLog) : null;
-    const capture = (turns) => captureEndedSession(hippoRoot, tenantId, store, flags, transcriptPath, turns);
-    if (mode === 'turn')
-        captureNewTurns(transcriptPath, closeSessionId, scan, capture, digestLog);
-    else
-        capture(scan?.turns);
-    recordSessionDigest(hippoRoot, scan, {
-        key: closeSessionId || path.basename(transcriptPath ?? '', '.jsonl'),
+    const logFile = stringFlag(flags, 'log-file') ?? null;
+    const sessionId = stringFlag(flags, 'session-id') ?? null;
+    return runSessionEnd({
+        mode,
+        hippoRoot,
         tenantId,
-        log: digestLog,
-    });
-    // Only this session's snapshot, and only after sleep and capture.
-    const closeLog = (line) => appendSessionEndCloseLog(closeLogFile, line);
-    closeEndedSession(cliApiContext(store, tenantId), {
-        sessionId: closeSessionId,
-        turn: mode === 'turn',
-        workingState: () => (transcriptPath ? transcriptWorkingState(transcriptPath, closeLog) : null),
+        sessionId,
+        transcriptPath,
+        contextFor: (root) => cliApiContext(root, tenantId),
+        storeRoot: () => hookStoreRoot(hippoRoot),
+        log: (line, opts) => appendSessionEndCloseLog(logFile, line, opts),
+        sleep: () => (mode === 'turn' && sessionId
+            ? sleepIfDue(hippoRoot, tenantId, flags, logFile, transcriptPath, sessionId)
+            : sleepProjectStore(hippoRoot, tenantId, flags, logFile, transcriptPath)),
+        readScan: (log) => (transcriptPath ? readSessionScan(transcriptPath, log) : null),
+        capture: (store, scan) => {
+            const capture = (turns) => captureEndedSession(hippoRoot, tenantId, store, flags, transcriptPath, turns);
+            if (mode === 'turn')
+                captureNewTurns(transcriptPath, sessionId, scan, capture, (line) => appendSessionEndCloseLog(logFile, line));
+            else
+                capture(scan?.turns);
+        },
+        digest: (scan, log) => recordSessionDigest(hippoRoot, scan, {
+            key: sessionId || path.basename(transcriptPath ?? '', '.jsonl'),
+            tenantId,
+            log,
+        }),
+        workingState: (log) => (transcriptPath ? transcriptWorkingState(transcriptPath, log) : null),
         evidence: () => collectHandoffEvidence(process.cwd(), 'unknown'),
-        log: closeLog,
     });
 }
 async function sleepProjectStore(hippoRoot, tenantId, flags, closeLogFile, transcriptPath) {
@@ -304,20 +309,6 @@ function loadCodexWrapperMetadata() {
     // SAFETY: the file is the one installCodexWrapper wrote; handleCodexRun reads only logFile and realCodexPath from it.
     return JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
 }
-/** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
-export function quoteCmdArg(arg) {
-    if (arg.length === 0)
-        return '""';
-    if (!/[ \t"&()^<>|%!]/.test(arg))
-        return arg;
-    return `"${arg.replace(/"/g, '""').replace(/%/g, '"^%"')}"`;
-}
-/** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
-export function cmdShimArgs(shimPath, forwardArgs) {
-    const command = `"${shimPath}"${forwardArgs.length > 0 ? ` ${forwardArgs.map(quoteCmdArg).join(' ')}` : ''}`;
-    // The line is already quoted for cmd.exe, so Node must not quote it again; /s strips the outer pair.
-    return ['/d', '/v:off', '/s', '/c', `"${command}"`];
-}
 function spawnRealCodex(realCodexPath, forwardArgs, cwd) {
     const ext = path.extname(realCodexPath).toLowerCase();
     if (process.platform === 'win32' && ext === '.ps1') {

package/dist/cli/setup.d.ts

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

package/dist/cli/setup.js

@@ -486,14 +486,14 @@ function dailyStepFailure(err, timeoutMs) {
         return `timed out after ${timeoutMs} ms and was stopped`;
     return errorMessage(err);
 }
-export function handleDailyRunner({ tenantId }) {
+export async function handleDailyRunner({ tenantId }) {
     const globalRoot = getGlobalRoot();
     // No workspace sleep ever opens the global store, yet hooks in folders without a store compact into it.
     if (isInitialized(globalRoot)) {
         const finished = replayCompactionsAt(globalRoot, (message) => log.warn(`compaction replay: ${message}`));
         if (finished > 0)
             console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over in the global store.`);
-        repairQualityOnceAt(globalRoot, tenantId);
+        await repairQualityOnceAt(globalRoot, tenantId);
     }
     printAgentImport(importUserMemories(globalRoot, { machine: currentMachine() }), '');
     const workspaces = listRegisteredWorkspaces(globalRoot);

package/dist/cli/shared.d.ts

@@ -17,7 +17,7 @@ interface LearnFromRepoResult {
     skipped: number;
     lowInfo: number;
 }
-export declare function learnFromRepo(hippoRoot: string, tenantId: string, repoPath: string, days: number, label?: string): LearnFromRepoResult;
+export declare function learnFromRepo(hippoRoot: string, tenantId: string, repoPath: string, days: number, label?: string): Promise<LearnFromRepoResult>;
 export declare function resolveAuthRoot(hippoRoot: string, flags: CliFlags): string;
 export {};
 //# sourceMappingURL=shared.d.ts.map

package/dist/cli/shared.js

@@ -83,9 +83,9 @@ export function skipLearnOnSharedStore(hippoRoot) {
     console.log("Shared store: skipped learning from this account's git commits and coding agents' own memories.");
     return true;
 }
-export function learnFromRepo(hippoRoot, tenantId, repoPath, days, label) {
+export async function learnFromRepo(hippoRoot, tenantId, repoPath, days, label) {
     const prefix = label ? `[${label}] ` : '';
-    const result = learn(cliApiContext(hippoRoot, tenantId), { repoPath, days, profile: CLI_LEARN });
+    const result = await learn(cliApiContext(hippoRoot, tenantId), { repoPath, days, profile: CLI_LEARN });
     if (result.status === 'not-a-repo') {
         console.log(`${prefix}No git history found (or not a git repository).`);
         return { added: 0, skipped: 0, lowInfo: 0 };

package/dist/cli/sleep.js

@@ -80,7 +80,7 @@ async function cmdSleepCore(hippoRoot, tenantId, flags) {
     else if (learn) {
         const config = loadConfig(hippoRoot);
         if (config.autoLearnOnSleep && isGitRepo(process.cwd())) {
-            const { added } = learnFromRepo(hippoRoot, tenantId, process.cwd(), 1);
+            const { added } = await learnFromRepo(hippoRoot, tenantId, process.cwd(), 1);
             if (added > 0)
                 console.log(`Auto-learned ${added} lessons from today's git commits.`);
         }
@@ -101,7 +101,7 @@ async function cmdSleepCore(hippoRoot, tenantId, flags) {
         if (finished > 0)
             console.log(`Finished saving ${finished} compaction${finished === 1 ? '' : 's'} left over from earlier sessions.`);
         repairProjectTagsOnce(hippoRoot, tenantId);
-        repairQualityOnceAt(hippoRoot, tenantId);
+        await repairQualityOnceAt(hippoRoot, tenantId);
     }
     // Phase 2-6: Pure-storage pipeline (consolidate + dedup + audit + share + ambient).
     const ctx = cliApiContext(hippoRoot, tenantId);

package/dist/cli/transfer.d.ts

@@ -1,8 +1,8 @@
 import { type CommandContext } from './flag-values.js';
-export declare function handleLearn({ hippoRoot, tenantId, flags }: CommandContext): void;
-export declare function handleImport({ hippoRoot, tenantId, args, flags }: CommandContext): void;
+export declare function handleLearn({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
+export declare function handleImport({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handleSync({ hippoRoot, flags }: CommandContext): void;
-export declare function handleWatch({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
+export declare function handleWatch({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handlePromote({ hippoRoot, tenantId, args }: CommandContext): Promise<void>;
 export declare function handleShare({ hippoRoot, tenantId, args, flags }: CommandContext): Promise<void>;
 export declare function handlePeers({ tenantId, flags }: CommandContext): void;