hippo-memory 1.63.2 → 1.64.1

package/dist/auth.js

@@ -1,6 +1,7 @@
 import { createHash, randomBytes, scryptSync, timingSafeEqual } from 'node:crypto';
-import { openHippoDb, closeHippoDb } from './db.js';
+import { raiseMinBinary } from './db/meta.js';
 import { keysetAfter } from './keyset.js';
+import { EXPIRING_KEYS_MIN_BINARY } from './version.js';
 /** Every minted API key starts with this, so the server can route a bearer token by shape. */
 export const API_KEY_PREFIX = 'hk_';
 const ID_LEN = 24; // base32 chars after prefix
@@ -42,30 +43,64 @@ export function createApiKey(db, opts) {
     const hash = hashKey(plaintext);
     // openHippoDb runs runMigrations synchronously before returning the db handle,
     // so migration v26 (adds role column) is in place before this INSERT runs.
-    db.prepare(`INSERT INTO api_keys (key_id, key_hash, tenant_id, label, created_at, role) VALUES (?, ?, ?, ?, ?, ?)`).run(keyId, hash, opts.tenantId, opts.label ?? null, new Date().toISOString(), opts.role ?? 'admin');
+    // An older binary ignores expires_at and would honour an expired key, so the store shuts it out before the first one exists.
+    if (opts.expiresAt !== undefined)
+        raiseMinBinary(db, EXPIRING_KEYS_MIN_BINARY);
+    db.prepare(`INSERT INTO api_keys (key_id, key_hash, tenant_id, label, created_at, role, owner_subject, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(keyId, hash, opts.tenantId, opts.label ?? null, new Date().toISOString(), opts.role ?? 'admin', opts.ownerSubject ?? null, opts.expiresAt ?? null);
     return { keyId, plaintext };
 }
-/** One full check against the store: shape, row, revocation, then scrypt. Null for any failure. */
-function lookupApiKey(db, plaintext) {
-    if (!MINTED_KEY_PATTERN.test(plaintext))
-        return null;
-    const keyId = plaintext.slice(0, API_KEY_PREFIX.length + ID_LEN);
+/** The api_keys row for `keyId` with its scope grants; null when no row matches. */
+export function readApiKeyRecord(db, keyId) {
     // SAFETY: row comes from the SELECT above, which projects exactly
-    // key_hash, tenant_id, revoked_at, role; `.get` returns undefined when no
+    // key_hash, tenant_id, revoked_at, role, expires_at, owner_subject; `.get` returns undefined when no
     // row matches key_id.
     const row = db
-        .prepare(`SELECT key_hash, tenant_id, revoked_at, role FROM api_keys WHERE key_id = ?`)
+        .prepare(`SELECT key_hash, tenant_id, revoked_at, role, expires_at, owner_subject FROM api_keys WHERE key_id = ?`)
         .get(keyId);
+    if (!row)
+        return null;
+    return {
+        keyHash: row.key_hash, tenantId: row.tenant_id, revokedAt: row.revoked_at, role: row.role, scopes: listScopeGrants(db, keyId),
+        expiresAt: row.expires_at, ownerSubject: row.owner_subject,
+    };
+}
+/** When a key stops working, in epoch ms: Infinity for null, and already past for a missing field (a store that predates expiry) or a stamp that does not parse, so both fail closed. */
+function keyExpiryMs(expiresAt) {
+    if (expiresAt === null)
+        return Infinity;
+    if (expiresAt === undefined)
+        return -Infinity;
+    const ms = Date.parse(expiresAt);
+    return Number.isNaN(ms) ? -Infinity : ms;
+}
+/** The key id of a minted-key-shaped token, else null. */
+function mintedKeyId(plaintext) {
+    return MINTED_KEY_PATTERN.test(plaintext) ? plaintext.slice(0, API_KEY_PREFIX.length + ID_LEN) : null;
+}
+/** Revocation, expiry, then the secret, against a stored record. Null for any failure. */
+function checkApiKey(keyId, record, now, secretMatches) {
     // Ids are 120 random bits and not secret, so padding the miss path with scrypt hid nothing and let junk tokens burn CPU.
-    if (!row || row.revoked_at || !verifyKey(plaintext, row.key_hash))
+    if (!record)
+        return null;
+    const expiresAtMs = keyExpiryMs(record.expiresAt);
+    if (record.revokedAt || now >= expiresAtMs || !secretMatches(record.keyHash))
         return null;
     // Fail-safe to least privilege: any role value but 'admin' reads as 'member'.
-    const role = row.role === 'admin' ? 'admin' : 'member';
-    return { tenantId: row.tenant_id, keyId, role, scopes: listScopeGrants(db, keyId) };
+    const role = record.role === 'admin' ? 'admin' : 'member';
+    const key = { tenantId: record.tenantId, keyId, role, scopes: [...record.scopes] };
+    // Only a real name counts as an owner; anything else leaves the key keyed on its own id.
+    if (record.ownerSubject)
+        key.ownerSubject = record.ownerSubject;
+    return { key, expiresAtMs, keyHash: record.keyHash };
+}
+/** One full check against the store: shape, row, revocation, expiry, then scrypt. Null for any failure. */
+function lookupApiKey(db, plaintext, now) {
+    const keyId = mintedKeyId(plaintext);
+    return keyId === null ? null : checkApiKey(keyId, readApiKeyRecord(db, keyId), now, (hash) => verifyKey(plaintext, hash));
 }
 export function validateApiKey(db, plaintext) {
-    const key = lookupApiKey(db, plaintext);
-    return key ? { valid: true, ...key } : { valid: false };
+    const found = lookupApiKey(db, plaintext, Date.now());
+    return found ? { valid: true, ...found.key } : { valid: false };
 }
 /** How long a verified key is trusted without a store read; also the ceiling on a revoke made by another process. */
 export const VERIFIED_KEY_TTL_MS = 60_000;
@@ -79,6 +114,7 @@ export class VerifiedKeyCache {
     ttlMs;
     // Map iterates in insertion order, so re-inserting on a hit makes the first key the least recent.
     entries = new Map();
+    deletes = 0;
     constructor(capacity, ttlMs) {
         this.capacity = capacity;
         this.ttlMs = ttlMs;
@@ -86,58 +122,70 @@ export class VerifiedKeyCache {
     get size() {
         return this.entries.size;
     }
-    get(hippoRoot, keyId, plaintext, now) {
+    /** Moves on every delete, so a store read that straddled a revoke or grant is not cached. */
+    get epoch() {
+        return this.deletes;
+    }
+    /** The entry this exact token was verified into, fresh or lapsed. */
+    match(hippoRoot, keyId, plaintext) {
         const entry = this.entries.get(keyId);
         if (!entry || entry.hippoRoot !== hippoRoot)
             return undefined;
-        if (now >= entry.expiresAt) {
-            this.entries.delete(keyId);
-            return undefined;
-        }
         // A wrong secret misses but leaves the entry, so a flood of bad guesses cannot evict a good key.
-        if (!timingSafeEqual(entry.digest, secretDigest(plaintext)))
+        return timingSafeEqual(entry.digest, secretDigest(plaintext)) ? entry : undefined;
+    }
+    get(hippoRoot, keyId, plaintext, now) {
+        const entry = this.match(hippoRoot, keyId, plaintext);
+        if (!entry || now >= entry.expiresAt)
             return undefined;
         this.entries.delete(keyId);
         this.entries.set(keyId, entry);
         return { ...entry.key, scopes: [...entry.key.scopes] };
     }
-    set(hippoRoot, keyId, plaintext, key, now) {
+    /** The key hash this exact token was last verified against, kept past the TTL so a re-check can skip scrypt. */
+    verifiedHash(hippoRoot, keyId, plaintext) {
+        return this.match(hippoRoot, keyId, plaintext)?.keyHash;
+    }
+    set(hippoRoot, keyId, plaintext, found, now) {
         this.entries.delete(keyId);
         if (this.entries.size >= this.capacity) {
             const oldest = this.entries.keys().next();
             if (!oldest.done)
                 this.entries.delete(oldest.value);
         }
-        const frozen = Object.freeze({ ...key, scopes: [...key.scopes] });
-        this.entries.set(keyId, { hippoRoot, digest: secretDigest(plaintext), key: frozen, expiresAt: now + this.ttlMs });
+        const frozen = Object.freeze({ ...found.key, scopes: [...found.key.scopes] });
+        // A key that expires inside the TTL leaves the cache at its expiry, so the cache never extends its life.
+        const expiresAt = Math.min(now + this.ttlMs, found.expiresAtMs);
+        this.entries.set(keyId, { hippoRoot, digest: secretDigest(plaintext), key: frozen, keyHash: found.keyHash, expiresAt });
     }
     delete(keyId) {
+        this.deletes++;
         this.entries.delete(keyId);
     }
 }
 // SHORTCUT: per-process cache, so a revoke or scope change made by another process (the CLI) lands within VERIFIED_KEY_TTL_MS; a shared revocation epoch in the store if that is too slow.
 const verifiedKeys = new VerifiedKeyCache(VERIFIED_KEY_CACHE_CAP, VERIFIED_KEY_TTL_MS);
-/** Verify a bearer API key for `hippoRoot`; a cache hit skips both scrypt and the DB open. Null when invalid. */
-export function verifyApiKeyCached(hippoRoot, plaintext) {
-    if (!MINTED_KEY_PATTERN.test(plaintext))
+/** Verify a bearer API key against `store`, served at `hippoRoot`; a cache hit skips both scrypt and the store. Null when invalid. A token whose cache entry lapsed re-reads its record without scrypt; a throw from `beforeScrypt` refuses before scrypt runs. */
+export async function verifyApiKeyCached(hippoRoot, plaintext, store, beforeScrypt) {
+    const keyId = mintedKeyId(plaintext);
+    if (keyId === null)
         return null;
-    const keyId = plaintext.slice(0, API_KEY_PREFIX.length + ID_LEN);
     const hit = verifiedKeys.get(hippoRoot, keyId, plaintext, Date.now());
     if (hit)
         return hit;
+    const provenHash = verifiedKeys.verifiedHash(hippoRoot, keyId, plaintext);
     verifyStats.storeLookups++;
-    const db = openHippoDb(hippoRoot);
-    let key;
-    try {
-        key = lookupApiKey(db, plaintext);
-    }
-    finally {
-        closeHippoDb(db);
-    }
+    const epoch = verifiedKeys.epoch;
+    const found = checkApiKey(keyId, await store.findApiKey(keyId), Date.now(), (hash) => {
+        if (hash === provenHash)
+            return true;
+        beforeScrypt?.();
+        return verifyKey(plaintext, hash);
+    });
     // Only successes are cached: caching misses would let junk tokens fill the cache and evict real keys.
-    if (key)
-        verifiedKeys.set(hippoRoot, keyId, plaintext, key, Date.now());
-    return key;
+    if (found && verifiedKeys.epoch === epoch)
+        verifiedKeys.set(hippoRoot, keyId, plaintext, found, Date.now());
+    return found?.key ?? null;
 }
 export function revokeApiKey(db, keyId) {
     db.prepare(`UPDATE api_keys SET revoked_at = ? WHERE key_id = ? AND revoked_at IS NULL`)
@@ -167,19 +215,30 @@ export function listScopeGrants(db, keyId) {
 export function listApiKeyRows(db, opts) {
     const where = ['1 = 1'];
     const params = [];
-    if (opts.active)
-        where.push('revoked_at IS NULL');
+    if (opts.active) {
+        // In SQL so a page holds `limit` usable keys; toISOString stamps compare correctly as strings.
+        where.push('revoked_at IS NULL AND (expires_at IS NULL OR expires_at > ?)');
+        params.push(new Date().toISOString());
+    }
     if (opts.tenantId !== undefined) {
         where.push('tenant_id = ?');
         params.push(opts.tenantId);
     }
+    if (opts.ownerSubject !== undefined) {
+        where.push('owner_subject = ?');
+        params.push(opts.ownerSubject);
+    }
+    if (opts.keyId !== undefined) {
+        where.push('key_id = ?');
+        params.push(opts.keyId);
+    }
     const after = keysetAfter('id', 'id', opts.after);
     params.push(...after.params);
     const limitSql = opts.limit === undefined ? '' : ' LIMIT ?';
     if (opts.limit !== undefined)
         params.push(opts.limit);
-    const sql = `SELECT id, key_id, tenant_id, label, created_at, revoked_at, role FROM api_keys WHERE ${where.join(' AND ')}${after.sql} ORDER BY id DESC${limitSql}`;
-    // SAFETY: the SELECT above projects exactly these 7 columns, in this order.
+    const sql = `SELECT id, key_id, tenant_id, label, created_at, revoked_at, role, expires_at, owner_subject FROM api_keys WHERE ${where.join(' AND ')}${after.sql} ORDER BY id DESC${limitSql}`;
+    // SAFETY: the SELECT above projects exactly these 9 columns, in this order.
     const rows = db.prepare(sql).all(...params);
     return rows.map(r => ({
         rowId: r.id,
@@ -188,10 +247,20 @@ export function listApiKeyRows(db, opts) {
             createdAt: r.created_at, revokedAt: r.revoked_at,
             role: r.role === 'admin' ? 'admin' : 'member',
             scopes: listScopeGrants(db, r.key_id),
+            expiresAt: r.expires_at, ownerSubject: r.owner_subject,
         },
     }));
 }
 export function listApiKeys(db, opts) {
     return listApiKeyRows(db, opts).map(r => r.key);
 }
+/** Ids of the unrevoked, unexpired keys `ownerSubject` minted in `tenantId`, oldest first. */
+export function listLiveOwnedKeyIds(db, tenantId, ownerSubject, now) {
+    // SAFETY: the SELECT names exactly these two columns.
+    const rows = db
+        .prepare(`SELECT key_id, expires_at FROM api_keys WHERE tenant_id = ? AND owner_subject = ? AND revoked_at IS NULL ORDER BY id`)
+        .all(tenantId, ownerSubject);
+    // Expiry is filtered here, not in SQL, so it follows the same Date.parse rule the key check uses.
+    return rows.filter((r) => now < keyExpiryMs(r.expires_at)).map((r) => r.key_id);
+}
 //# sourceMappingURL=auth.js.map

package/dist/autolearn.js

@@ -6,7 +6,7 @@ import { execSync, execFileSync, spawn } from 'child_process';
 import { createMemory, Layer, DEFAULT_HALF_LIFE_DAYS } from './memory.js';
 import { loadAllEntries } from './store/entry-reads.js';
 import { textOverlap } from './tokenize.js';
-import { isContentWorthStoring } from './audit.js';
+import { assessAutomaticMemory } from './memory-quality.js';
 import { redactSecretsStrict } from './secret-detect.js';
 import { log } from './log.js';
 /** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; no store is in reach, so `hippo watch` re-derives its half-life from the store's config. */
@@ -87,7 +87,7 @@ export function partitionLessons(lessons) {
     const kept = [];
     const dropped = [];
     for (const lesson of lessons.map((l) => redactSecretsStrict(l))) {
-        if (isContentWorthStoring(lesson)) {
+        if (assessAutomaticMemory(lesson).accepted) {
             kept.push(lesson);
         }
         else {

package/dist/capture/caller-session.d.ts

@@ -0,0 +1,16 @@
+import { type Context } from '../api/types.js';
+import { type DatabaseSyncLike } from '../db.js';
+import { type CallerProject } from '../prompt-hook.js';
+import type { ContinuityKey } from '../store/sessions.js';
+import { type WorkingState } from './working-state.js';
+/** Checks the ids, then binds the session to the caller's owner (a ConflictError when another owner holds it). Returns the key the call's rows go under. */
+export declare function bindCaller(ctx: Context, sessionId: string, project: CallerProject): ContinuityKey;
+/** Read only: the session's first prompt booked its arm, and a holdout session gets nothing from hippo. */
+export declare function callerInHoldout(ctx: Context, sessionId: string): boolean;
+/** Refuses a field past the cap a transcript read gives, naming it; scrubbed again, since the caller's scrub is not trusted, then cut back to the cap. */
+export declare function checkedWorkingState(state: WorkingState | null): WorkingState | null;
+export declare function assertTrigger(trigger: string | null): void;
+export declare function assertRequestId(requestId: string): void;
+/** Opens with the request's own lock wait, so a busy store becomes a 503 rather than a long stall. */
+export declare function withCallerDb<T>(ctx: Context, fn: (db: DatabaseSyncLike) => T): T;
+//# sourceMappingURL=caller-session.d.ts.map

package/dist/capture/caller-session.js

@@ -0,0 +1,58 @@
+// The checks every caller call shares: ids, project, the session's owner and the pilot arm, all from the request, never the server's env or folder.
+import { BadRequestError } from '../api-errors.js';
+import { ownerOrSubject } from '../api/types.js';
+import { closeHippoDb, openHippoDb } from '../db.js';
+import { MAX_ID_LEN } from '../http-util.js';
+import { sessionPilotArm } from '../pilot-arm.js';
+import { assertCallerIds } from '../prompt-hook.js';
+import { assertCallerProject, projectNames } from '../project-identity.js';
+import { maskEmails, redactSecretsStrict } from '../secret-detect.js';
+import { bindSessionOwner } from '../session-owners.js';
+import { fitWorkingState, WORKING_STATE_CAPS } from './working-state.js';
+/** Checks the ids, then binds the session to the caller's owner (a ConflictError when another owner holds it). Returns the key the call's rows go under. */
+export function bindCaller(ctx, sessionId, project) {
+    assertCallerIds(sessionId, project);
+    if (sessionId.trim() === '')
+        throw new BadRequestError('session id: required');
+    // A '' project would stamp user-global rows; a rewritten one would split a project.
+    assertCallerProject(project);
+    bindSessionOwner(ctx, sessionId);
+    return { owner: ownerOrSubject(ctx.actor), project: projectNames(project) };
+}
+/** Read only: the session's first prompt booked its arm, and a holdout session gets nothing from hippo. */
+export function callerInHoldout(ctx, sessionId) {
+    return sessionPilotArm(ctx.hippoRoot, ctx.tenantId, sessionId, false, { sharedStore: true, ownTenantOnly: true }) === 'holdout';
+}
+/** Refuses a field past the cap a transcript read gives, naming it; scrubbed again, since the caller's scrub is not trusted, then cut back to the cap. */
+export function checkedWorkingState(state) {
+    if (state === null)
+        return null;
+    for (const field of ['task', 'summary', 'next_step']) {
+        const cap = WORKING_STATE_CAPS[field];
+        if (state[field].length > cap)
+            throw new BadRequestError(`working state ${field}: at most ${cap} characters`);
+    }
+    const scrub = (text) => maskEmails(redactSecretsStrict(text));
+    return fitWorkingState({ task: scrub(state.task), summary: scrub(state.summary), next_step: scrub(state.next_step) });
+}
+export function assertTrigger(trigger) {
+    if (trigger !== null && trigger.length > MAX_ID_LEN)
+        throw new BadRequestError(`trigger: at most ${MAX_ID_LEN} characters`);
+}
+export function assertRequestId(requestId) {
+    if (requestId.trim() === '')
+        throw new BadRequestError('request id: required');
+    if (requestId.length > MAX_ID_LEN)
+        throw new BadRequestError(`request id: at most ${MAX_ID_LEN} characters`);
+}
+/** Opens with the request's own lock wait, so a busy store becomes a 503 rather than a long stall. */
+export function withCallerDb(ctx, fn) {
+    const db = openHippoDb(ctx.hippoRoot);
+    try {
+        return fn(db);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+//# sourceMappingURL=caller-session.js.map

package/dist/capture/command.d.ts

@@ -1,10 +1,11 @@
 import { type ProjectRef } from '../project-identity.js';
+import { type ExtractedItem } from './extract.js';
 import { type SessionTurn } from './transcript.js';
 export interface CaptureOptions {
     source: 'stdin' | 'file' | 'last-session';
     filePath?: string;
     /** Explicit transcript path for `--last-session`. Without one, `stdinText`
-     * is used, then auto-discovery under `~/.claude/projects/` on a manual run. */
+     * is used, then auto-discovery under `<claude config dir>/projects/` on a manual run. */
     transcriptPath?: string;
     /** Read from stdin by the caller (cli.ts), which owns the bounded wait.
      * `stdinTimedOut` marks an empty read "unknown", not "no payload". */
@@ -31,4 +32,21 @@ export interface CaptureOptions {
     originProject?: ProjectRef;
 }
 export declare function cmdCapture(hippoRoot: string, options: CaptureOptions): void;
+export interface CaptureTally {
+    captured: number;
+    skipped: number;
+    rejected: number;
+}
+/** What a capture's rows carry. The CLI passes no tenant for the global store, so `global` never reaches the writes. */
+export interface CaptureWriteOptions {
+    readonly dryRun: boolean;
+    readonly tenantId: string | undefined;
+    readonly originProject: ProjectRef | undefined;
+    readonly sessionId?: string;
+    /** The audit actor; the CLI's own writes leave it out and audit as `cli`. */
+    readonly actor?: string;
+    /** No stats and no embedding, since embedding runs a model in a server process. */
+    readonly lean: boolean;
+}
+export declare function captureExtractedItems(targetRoot: string, options: CaptureWriteOptions, extracted: readonly ExtractedItem[], keys: Set<string>): CaptureTally;
 //# sourceMappingURL=command.d.ts.map

package/dist/capture/command.js

@@ -17,8 +17,8 @@ import { loadConfig } from '../config.js';
 import { classifyOriginProject, projectId } from '../project-identity.js';
 import { isStringValue } from '../capture-contract.js';
 import { errorMessage, log } from '../log.js';
-import { extractFromText } from './extract.js';
-import { collectSessionTurns, summariseSessionTurns, resolveLastSessionTranscript } from './transcript.js';
+import { extractFromTexts } from './extract.js';
+import { collectSessionTurns, sessionTail, resolveLastSessionTranscript } from './transcript.js';
 export function cmdCapture(hippoRoot, options) {
     // Tee stdout/stderr to a log file when --log-file is set. Used by the
     // SessionEnd hook so output (otherwise swallowed by TUI teardown) surfaces
@@ -102,16 +102,15 @@ function cmdCaptureCore(hippoRoot, options) {
             process.exit(1);
         }
     }
-    // Read input text
-    const text = readCaptureText(options);
-    if (text === null)
+    const texts = readCaptureTexts(options);
+    if (texts === null)
         return;
-    if (!text || text.trim().length === 0) {
+    if (texts.every((text) => text.trim().length === 0)) {
         console.log('No text to capture from.');
         return;
     }
     // Scrub once here, as the snapshot fields are: every source can carry a pasted token (AGENTS.md: no secrets in memories).
-    const extracted = extractFromText(maskEmails(redactSecretsStrict(text)));
+    const extracted = extractFromTexts(texts.map((text) => maskEmails(redactSecretsStrict(text))));
     if (extracted.length === 0) {
         console.log('No actionable items found in the input.');
         return;
@@ -123,19 +122,25 @@ function cmdCaptureCore(hippoRoot, options) {
     const keys = storedTextKeys(origin === undefined
         ? stored
         : stored.filter((e) => classifyOriginProject(e.origin_project, origin) !== 'cross-project'));
-    const { captured, skipped, rejected } = captureExtractedItems(targetRoot, options, extracted, keys);
+    const writeOpts = {
+        dryRun: options.dryRun,
+        tenantId: useGlobal ? undefined : options.tenantId,
+        originProject: origin,
+        lean: false,
+    };
+    const { captured, skipped, rejected } = captureExtractedItems(targetRoot, writeOpts, extracted, keys);
     const prefix = options.dryRun ? '[dry-run] ' : '';
     const globalPrefix = useGlobal ? '[global] ' : '';
     console.log(`\n${prefix}${globalPrefix}Captured ${captured} items (${skipped} skipped as duplicates` +
         (rejected > 0 ? `, ${rejected} rejected` : '') +
         ')');
 }
-/** The raw text for the chosen source; null after printing why a last-session capture has nothing. */
-function readCaptureText(options) {
+/** The raw texts for the chosen source, one per session turn; null after printing why a last-session capture has nothing. */
+function readCaptureTexts(options) {
     switch (options.source) {
         case 'stdin': {
             try {
-                return fs.readFileSync(0, 'utf8');
+                return [fs.readFileSync(0, 'utf8')];
             }
             catch {
                 console.error('No input on stdin. Pipe text in or use --file <path>.');
@@ -151,7 +156,7 @@ function readCaptureText(options) {
                 console.error(`File not found: ${options.filePath}`);
                 process.exit(1);
             }
-            return fs.readFileSync(options.filePath, 'utf8');
+            return [fs.readFileSync(options.filePath, 'utf8')];
         }
         case 'last-session': {
             let turns = options.sessionTurns;
@@ -163,16 +168,16 @@ function readCaptureText(options) {
                 }
                 turns = collectSessionTurns(fs.readFileSync(resolved, 'utf8'));
             }
-            const text = summariseSessionTurns(turns);
-            if (!text) {
+            const { users, assistants } = sessionTail(turns);
+            if (users.length === 0 && assistants.length === 0) {
                 console.log('Transcript had no user/assistant messages to summarise.');
                 return null;
             }
-            return text;
+            return [...users, ...assistants];
         }
     }
 }
-function captureExtractedItems(targetRoot, options, extracted, keys) {
+export function captureExtractedItems(targetRoot, options, extracted, keys) {
     const tally = { captured: 0, skipped: 0, rejected: 0 };
     const baseHalfLifeDays = loadConfig(targetRoot).defaultHalfLifeDays;
     // Dry run probes the same checkRejectionGuard the real write uses, on a read-only handle,
@@ -201,7 +206,6 @@ function captureExtractedItems(targetRoot, options, extracted, keys) {
     return tally;
 }
 function captureEntry(item, options, baseHalfLifeDays) {
-    const useGlobal = options.global;
     // kind stays 'distilled': these are curated items, not raw transcript (see MEMORY_ENVELOPE.md).
     // The write tenant must match the dedup read's, or scoped dedup passes and the row lands in 'default'.
     const created = createMemory(item.content, {
@@ -209,7 +213,8 @@ function captureEntry(item, options, baseHalfLifeDays) {
         tags: item.tags,
         source: 'capture',
         confidence: 'observed',
-        tenantId: useGlobal ? undefined : options.tenantId,
+        tenantId: options.tenantId,
+        source_session_id: options.sessionId,
         baseHalfLifeDays,
     });
     return options.originProject === undefined ? created : { ...created, origin_project: projectId(options.originProject) };
@@ -235,15 +240,17 @@ function captureOne(ctx, item, entry) {
     else if (writeDb !== null) {
         // One rejected item must not abort the rest of this capture's items.
         const stamped = stampOriginProject(targetRoot, entry);
-        const outcome = gatedWrite(writeDb, targetRoot, stamped);
+        const outcome = gatedWrite(writeDb, targetRoot, stamped, { actor: options.actor });
         if (outcome === 'skipped:rejected')
             return 'rejected';
         if (outcome !== 'written')
             return 'skipped';
         writeEntryMirrors(targetRoot, stamped);
-        updateStats(targetRoot, { remembered: 1 });
+        if (!options.lean)
+            updateStats(targetRoot, { remembered: 1 });
         keys.add(duplicateKey(item.content)); // within-batch dedup
-        void embedMemory(targetRoot, entry);
+        if (!options.lean)
+            void embedMemory(targetRoot, entry);
     }
     return 'captured';
 }

package/dist/capture/compact-resume-caller.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from '../api/types.js';
+import type { CallerProject } from '../prompt-hook.js';
+import type { CallerHookOutput } from './pre-compact-caller.js';
+export interface CallerCompactResumeRequest {
+    readonly sessionId: string;
+    readonly project: CallerProject;
+    /** The SessionStart payload's source; only 'compact' restores. */
+    readonly source: string;
+}
+export declare function compactResumeForCaller(ctx: Context, req: CallerCompactResumeRequest): CallerHookOutput;
+//# sourceMappingURL=compact-resume-caller.d.ts.map

package/dist/capture/compact-resume-caller.js

@@ -0,0 +1,35 @@
+import { COMPACT_RESUME_EVENT_CONTENT_CAP, COMPACT_RESUME_MAX_AGE_MS, compactResumeText } from '../context-render.js';
+import { withLedgerDb } from '../ledger-db.js';
+import { errorMessage, log } from '../log.js';
+import { listSessionEvents, loadFreshActiveTaskSnapshot } from '../store/sessions.js';
+import { estimateTokens, recordTokenUse } from '../token-ledger.js';
+import { truncateCodePointSafe } from '../transcript-tail.js';
+import { bindCaller, callerInHoldout } from './caller-session.js';
+export function compactResumeForCaller(ctx, req) {
+    const key = bindCaller(ctx, req.sessionId, req.project);
+    if (req.source !== 'compact' || callerInHoldout(ctx, req.sessionId))
+        return { stdout: '' };
+    const snapshot = loadFreshActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, { maxAgeMs: COMPACT_RESUME_MAX_AGE_MS }, key);
+    // One owner's concurrent sessions must not cross-restore; a snapshot with no session still restores, as on the local path.
+    if (snapshot === null || (snapshot.session_id !== null && snapshot.session_id !== req.sessionId))
+        return { stdout: '' };
+    const text = compactResumeText(snapshot, sessionTrail(ctx, snapshot.session_id));
+    withLedgerDb(ctx.hippoRoot, (db) => recordTokenUse(db, {
+        tenantId: ctx.tenantId, sessionId: req.sessionId, surface: 'compact_resume', event: 'inject', items: 1, tokens: estimateTokens(text),
+    }), { sharedStore: true });
+    return { stdout: text };
+}
+/** A bad trail row costs the trail, not the snapshot. */
+function sessionTrail(ctx, sessionId) {
+    if (!sessionId)
+        return [];
+    try {
+        return listSessionEvents(ctx.hippoRoot, ctx.tenantId, { session_id: sessionId })
+            .map((e) => ({ ...e, content: truncateCodePointSafe(e.content, COMPACT_RESUME_EVENT_CONTENT_CAP) }));
+    }
+    catch (err) {
+        log.warn(`compact-resume: trail skipped: ${errorMessage(err)}`);
+        return [];
+    }
+}
+//# sourceMappingURL=compact-resume-caller.js.map

package/dist/capture/compact.d.ts

@@ -1,15 +1,3 @@
-import { type TaskSnapshot } from '../store/rows.js';
-export declare const PRE_COMPACT_TASK_CAP = 200;
-export declare const PRE_COMPACT_SUMMARY_CAP = 2000;
-export declare const PRE_COMPACT_NEXT_STEP_CAP = 500;
-/**
- * Cap from the RECENT end: summariseTranscript emits user turns oldest-to-
- * newest with assistant responses after them, so a head-first cap keeps
- * stale context and drops exactly the newest working state this feature
- * exists to preserve. Keep the LAST maxChars instead, aligned forward to a
- * nearby line start, with a trim marker.
- */
-export declare function truncateKeepNewest(text: string, maxChars: number): string;
 /**
  * Log-forgery guard: messages here interpolate payload-controlled values
  * (transcript paths, session ids). Strip C0 control chars — newlines above
@@ -19,8 +7,6 @@ export declare function truncateKeepNewest(text: string, maxChars: number): stri
  * guard, not per-file copies.
  */
 export declare function sanitizeLogMessage(message: string): string;
-/** A session's task, summary and next step from its transcript tail, secrets scrubbed and capped, '' where none; null with a logged reason when nothing is derivable. */
-export declare function transcriptWorkingState(transcriptPath: string, log: (message: string) => void): Pick<TaskSnapshot, 'task' | 'summary' | 'next_step'> | null;
 export interface PreCompactOptions {
     stdinText?: string;
     stdinTimedOut?: boolean;