hippo-memory 1.72.0 → 2.1.0

package/dist/capture/failure-reading.d.ts

@@ -1,6 +1,9 @@
 import { type JsonValue } from '../util/json.js';
 import type { CaptureErrorOutcome, RoutineRule } from '../store/failure-log.js';
-/** What {@link lessonFromFailure} read from a payload; `detail` is the finer failure-log key (untruncated, command head). */
+/**
+ * What {@link lessonFromFailure} read from a payload; `detail`
+ * is the finer failure-log key (untruncated, command head).
+ */
 export type FailureReading = {
     text: string;
     detail: string;
@@ -22,10 +25,14 @@ export declare function payloadString(payload: JsonValue, key: 'session_id' | 't
 export declare function failureSignature(text: string): string;
 /** The hash the failure log stores for a lesson text or a detail; one function so every writer counts repeats alike. */
 export declare function failureHash(text: string): string;
-/** The memory text for a failure payload, or why it is not stored; a routine skip keeps its text for the log. `scrub` runs before the
+/**
+ * The memory text for a failure payload, or why it is not stored; a routine skip keeps its text for the log. `scrub`
+ * runs before the
  * cap, as a mask can be longer than what it hides. Pure. */
 export declare function lessonFromFailure(payload: JsonValue, scrub?: (text: string) => string): FailureReading;
-/** A failure as it may leave the machine: the capped lesson text and the detail's hash, never the untruncated detail. */
+/**
+ * A failure as it may leave the machine: the capped lesson text and the detail's hash, never the untruncated detail.
+ */
 export interface FailureReport {
     /** The payload's tool name; null when it named none. */
     tool: string | null;

package/dist/capture/failure-reading.js

@@ -1,4 +1,5 @@
-// What a PostToolUseFailure payload says, read with no store, so a hook with no store sends the same reading the local log keeps.
+// What a PostToolUseFailure payload says, read with no store, so a
+// hook with no store sends the same reading the local log keeps.
 import { redactSecretsStrict } from '../util/secret-detect.js';
 import { scrubForSharing } from './share-scrub.js';
 import { blockHash } from '../util/token-text.js';
@@ -8,7 +9,8 @@ const COMMAND_HEAD_WORDS = 2;
 /** The longest lesson text a reading gives, so a check of a sent one imports it instead of copying it. */
 export const FAILURE_TEXT_MAX_CHARS = 200;
 /** The user, a permission prompt or a hook said no: routine, not a lesson. */
-const DECLINED = /user (?:doesn't|does not) want|denied by (?:the )?user|user (?:rejected|declined|denied)|permission to use|was blocked by (?:a )?hook/i;
+const DECLINED = new RegExp(String.raw `user (?:doesn't|does not) want|denied by (?:the )?user|user (?:rejected|declined|denied)|` +
+    String.raw `permission to use|was blocked by (?:a )?hook`, 'i');
 /** The OS or a remote host refused access (EACCES, SSH publickey): routine too, but nobody declined anything. */
 const OS_PERMISSION = /permission denied/i;
 /** Leading `cd` or `pushd` steps say where a command ran, not what it ran. */
@@ -16,8 +18,18 @@ const LEADING_CD = /^\s*(?:(?:cd|pushd)\b[^;&|]*(?:&&|\|\||;)\s*)+/;
 const NO_MATCH = /\bno (?:matches|files|results) found\b/i;
 /** Shell commands whose exit code 1 means "nothing found" or "differs", not an error. */
 const QUIET_EXIT_1 = /^\s*(?:grep|rg|egrep|fgrep|find|test|\[|diff|cmp|git diff|git grep)\b/;
-// Claude Code's tool names, then the Copilot CLI's and VS Code's; tests/copilot-failure-reading.test.ts cites where each comes from.
-const SEARCH_TOOLS = new Set(['Grep', 'Glob', 'grep', 'glob', 'rg', 'grep_search', 'file_search', 'semantic_search']);
+// Claude Code's tool names, then the Copilot CLI's and VS Code's; tests/copilot-failure-reading.test.ts cites where
+// each comes from.
+const SEARCH_TOOLS = new Set([
+    'Grep',
+    'Glob',
+    'grep',
+    'glob',
+    'rg',
+    'grep_search',
+    'file_search',
+    'semantic_search',
+]);
 const SHELL_TOOLS = new Set(['Bash', 'bash', 'powershell', 'run_in_terminal']);
 /** A non-blank string field of the payload, or null. */
 export function payloadString(payload, key) {
@@ -34,7 +46,9 @@ export function failureSignature(text) {
 export function failureHash(text) {
     return blockHash(failureSignature(text));
 }
-/** The memory text for a failure payload, or why it is not stored; a routine skip keeps its text for the log. `scrub` runs before the
+/**
+ * The memory text for a failure payload, or why it is not stored; a routine skip keeps its text for the log. `scrub`
+ * runs before the
  * cap, as a mask can be longer than what it hides. Pure. */
 export function lessonFromFailure(payload, scrub = (text) => text) {
     if (!isJsonObjectLiteral(payload))
@@ -43,12 +57,15 @@ export function lessonFromFailure(payload, scrub = (text) => text) {
     const p = payload;
     if (p.is_interrupt === true)
         return { skip: 'skipped-interrupt', text: null, detail: null };
-    if (!isJsonString(p.error) || p.error.trim().length < 12)
+    if (!isJsonString(p.error) || p.error.trim().length < 12) {
         return { skip: 'skipped-invalid', text: null, detail: null };
+    }
     const tool = isJsonString(p.tool_name) ? p.tool_name : 'tool';
     const error = redactSecretsStrict(p.error.replace(/\s+/g, ' ').trim());
     const text = truncateCodePointSafe(scrub(`${tool}: ${error}`), FAILURE_TEXT_MAX_CHARS);
-    const command = isJsonObjectLiteral(p.tool_input) && isJsonString(p.tool_input['command']) ? p.tool_input['command'].replace(LEADING_CD, '') : '';
+    const command = isJsonObjectLiteral(p.tool_input) && isJsonString(p.tool_input['command'])
+        ? p.tool_input['command'].replace(LEADING_CD, '')
+        : '';
     const head = command.trim().split(/\s+/).slice(0, COMMAND_HEAD_WORDS).join(' ');
     const detail = `${tool}${head ? ` ${head}` : ''}: ${error}`;
     const routine = (rule) => ({ skip: 'skipped-routine', rule, text, detail });

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

@@ -1,6 +1,6 @@
 import { PRE_COMPACT_INSTRUCTION } from './compaction-record.js';
 import { markSnapshotSavedAt, startCompactionAt } from '../store/compaction-caller.js';
-import { errorMessage, log } from '../util/log.js';
+import { errorMessage, log, errorFields } from '../util/log.js';
 import { loadActiveTaskSnapshot, saveActiveTaskSnapshot } from '../store/sessions.js';
 import { assertTrigger, bindCaller, callerInHoldout, checkedWorkingState } from './caller-session.js';
 import { mergeWorkingState } from './working-state.js';
@@ -10,7 +10,7 @@ function logged(what, fn) {
         return fn();
     }
     catch (err) {
-        log.warn(`pre-compact: ${what}: ${errorMessage(err)}`);
+        log.warn(`pre-compact: ${what}: ${errorMessage(err)}`, errorFields(err));
         return null;
     }
 }
@@ -20,7 +20,13 @@ export function preCompactForCaller(ctx, req) {
     const key = bindCaller(ctx, req.sessionId, req.project);
     if (callerInHoldout(ctx, req.sessionId))
         return { stdout: '' };
-    const start = { sessionId: req.sessionId, originProject: req.project.name, trigger: req.trigger, cwd: null, transcriptPath: null };
+    const start = {
+        sessionId: req.sessionId,
+        originProject: req.project.name,
+        trigger: req.trigger,
+        cwd: null,
+        transcriptPath: null,
+    };
     const recordId = logged('compaction record not started', () => startCompactionAt(ctx.hippoRoot, ctx.tenantId, start));
     if (state !== null && saveOwnerSnapshot(ctx, req.sessionId, key, state) && recordId !== null) {
         // Marked under ctx.tenantId, which the environment's tenant may not be.
@@ -35,6 +41,7 @@ function saveOwnerSnapshot(ctx, sessionId, key, state) {
     if (merged === null)
         return false;
     const snapshot = { ...merged, source: 'pre-compact', session_id: sessionId };
-    return logged('snapshot not saved', () => saveActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, snapshot, key)) !== null;
+    const saved = logged('snapshot not saved', () => saveActiveTaskSnapshot(ctx.hippoRoot, ctx.tenantId, snapshot, key));
+    return saved !== null;
 }
 //# sourceMappingURL=pre-compact-caller.js.map

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

@@ -24,16 +24,27 @@ export interface SessionScan {
     /** Edits that landed, in call order. */
     edits: DigestEdit[];
 }
-/** One pass over a Claude Code or Codex transcript: the turns capture reads, the closing message, and the edits that landed. */
+/**
+ * One pass over a Claude Code or Codex transcript: the turns capture reads, the closing message, and the edits that
+ * landed.
+ */
 export declare function scanSessionTranscript(jsonl: string): SessionScan;
 export declare function readSessionTranscript(transcriptPath: string, log: (message: string) => void): string;
 /** The transcript, read once and scanned, or null with the reason logged. */
 export declare function readSessionScan(transcriptPath: string, log: (message: string) => void): SessionScan | null;
-/** Test-only seam, the scheduler's pattern: lets a test prove a network path never reaches the probe. Null restores it. */
+/**
+ * Test-only seam, the scheduler's pattern: lets a test prove a network path never reaches the probe. Null restores it.
+ */
 export declare function _setDigestExistsProbeForTests(probe: ((p: string) => boolean) | null): void;
-/** The store root is realpath'd; transcript paths are not, and a deleted file has no realpath of its own. Null for a network path. */
+/**
+ * The store root is realpath'd; transcript paths are not, and a deleted file has no realpath of its own. Null for a
+ * network path.
+ */
 export declare function realFsPath(p: string): string | null;
-/** Repo-relative with forward slashes, '' for the root itself, null outside the repo or when the path cannot be resolved. */
+/**
+ * Repo-relative with forward slashes, '' for the root itself, null outside the repo or when the path cannot be
+ * resolved.
+ */
 export declare function repoRelative(p: string, repoRoot: string): string | null;
 /** Sentences of the reply; code spans and "e.g." are held out of the split so their dots never end a sentence. */
 export declare function digestSentences(text: string): string[];

package/dist/capture/session-digest.js

@@ -50,20 +50,26 @@ function editTarget(block) {
     const input = block.input;
     if (!isObjectLike(input))
         return null;
-    if (block.name === 'NotebookEdit')
+    if (block.name === 'NotebookEdit') {
         return 'notebook_path' in input && isStringValue(input.notebook_path) ? input.notebook_path : null;
+    }
     return 'file_path' in input && isStringValue(input.file_path) ? input.file_path : null;
 }
 function readClaudeAssistant(record, state) {
     const blocks = messageItems(record);
     for (const block of blocks) {
-        if (block.type !== 'tool_use' || !isStringValue(block.name) || !CLAUDE_EDIT_TOOLS.has(block.name) || !isStringValue(block.id))
+        if (block.type !== 'tool_use' ||
+            !isStringValue(block.name) ||
+            !CLAUDE_EDIT_TOOLS.has(block.name) ||
+            !isStringValue(block.id)) {
             continue;
+        }
         const target = editTarget(block);
         if (target)
             state.pending.push({ callId: block.id, filePath: target, base: state.cwd });
     }
-    // Sidechain edits changed files, but a sub-agent's reply is not this session's closing message, nor is Claude Code's own notice.
+    // Sidechain edits changed files, but a sub-agent's reply is not this session's closing message, nor is Claude Code's
+    // own notice.
     if (record.isMeta === true || record.isSidechain === true || isSynthetic(record))
         return;
     for (let i = blocks.length - 1; i >= 0; i--) {
@@ -80,8 +86,9 @@ function isSynthetic(record) {
 }
 function readClaudeResults(record, state) {
     for (const block of messageItems(record)) {
-        if (block.type === 'tool_result' && isStringValue(block.tool_use_id) && block.is_error !== true)
+        if (block.type === 'tool_result' && isStringValue(block.tool_use_id) && block.is_error !== true) {
             state.landed.add(block.tool_use_id);
+        }
     }
 }
 function readCodexMessage(item, state) {
@@ -166,8 +173,9 @@ function readCodexItem(item, state) {
             readCodexMessage(item, state);
             return;
         case 'custom_tool_call':
-            if (item.name === 'apply_patch' && isStringValue(item.call_id) && isStringValue(item.input))
+            if (item.name === 'apply_patch' && isStringValue(item.call_id) && isStringValue(item.input)) {
                 addPatch(state, item.call_id, item.input, state.cwd);
+            }
             return;
         case 'function_call':
             readCodexFunctionCall(item, state);
@@ -182,8 +190,9 @@ function readCodexItem(item, state) {
         }
         case 'function_call_output':
         case 'custom_tool_call_output':
-            if (isStringValue(item.call_id) && outputText(item.output).includes(PATCH_SUCCESS_LINE))
+            if (isStringValue(item.call_id) && outputText(item.output).includes(PATCH_SUCCESS_LINE)) {
                 state.landed.add(item.call_id);
+            }
             return;
     }
 }
@@ -207,11 +216,17 @@ function visitRecord(record, state) {
     if (record.type === 'response_item') {
         readCodexItem(payload, state);
     }
-    else if (record.type === 'event_msg' && payload.type === 'patch_apply_end' && payload.success === true && isStringValue(payload.call_id)) {
+    else if (record.type === 'event_msg' &&
+        payload.type === 'patch_apply_end' &&
+        payload.success === true &&
+        isStringValue(payload.call_id)) {
         state.landed.add(payload.call_id);
     }
 }
-/** One pass over a Claude Code or Codex transcript: the turns capture reads, the closing message, and the edits that landed. */
+/**
+ * One pass over a Claude Code or Codex transcript: the turns capture reads, the closing message, and the edits that
+ * landed.
+ */
 export function scanSessionTranscript(jsonl) {
     const state = {
         cwd: null, firstCwd: null, pending: [], landed: new Set(), claudeFinal: '', codexFinal: '', codexUnphased: '',
@@ -251,7 +266,9 @@ export function readSessionScan(transcriptPath, log) {
     }
 }
 let existsProbe = fs.existsSync;
-/** Test-only seam, the scheduler's pattern: lets a test prove a network path never reaches the probe. Null restores it. */
+/**
+ * Test-only seam, the scheduler's pattern: lets a test prove a network path never reaches the probe. Null restores it.
+ */
 export function _setDigestExistsProbeForTests(probe) {
     existsProbe = probe ?? fs.existsSync;
 }
@@ -259,7 +276,10 @@ export function _setDigestExistsProbeForTests(probe) {
 function isNetworkPath(p) {
     return /^[\\/]{2}(?:(?![?.][\\/])|[?.][\\/]UNC[\\/])/i.test(p);
 }
-/** The store root is realpath'd; transcript paths are not, and a deleted file has no realpath of its own. Null for a network path. */
+/**
+ * The store root is realpath'd; transcript paths are not, and a deleted file has no realpath of its own. Null for a
+ * network path.
+ */
 export function realFsPath(p) {
     if (isNetworkPath(p))
         return null;
@@ -277,7 +297,10 @@ export function realFsPath(p) {
     }
     return path.join(fs.realpathSync.native(head), ...rest);
 }
-/** Repo-relative with forward slashes, '' for the root itself, null outside the repo or when the path cannot be resolved. */
+/**
+ * Repo-relative with forward slashes, '' for the root itself, null outside the repo or when the path cannot be
+ * resolved.
+ */
 export function repoRelative(p, repoRoot) {
     let rel;
     try {
@@ -441,7 +464,10 @@ export function buildSessionDigest(sources) {
 export function sessionDigestId(tenantId, key) {
     return `mem_${createHash('sha256').update(`${SESSION_DIGEST_TAG}\n${tenantId}\n${key}`).digest('hex').slice(0, 12)}`;
 }
-/** What hippo could have injected into the session: any live digest (prompt recall reaches old ones) and the ambient handoff, never this session's own. */
+/**
+ * What hippo could have injected into the session: any live digest (prompt recall reaches old ones) and the ambient
+ * handoff, never this session's own.
+ */
 function injectedTexts(hippoRoot, opts) {
     const digests = loadLiveContentsBySourceAndTag(hippoRoot, opts.tenantId, SESSION_DIGEST_TAG, SESSION_DIGEST_TAG, opts.key);
     const handoff = loadLatestHandoff(hippoRoot, opts.tenantId, undefined, {
@@ -484,7 +510,7 @@ export function writeSessionDigest(hippoRoot, scan, opts) {
             tags: [SESSION_DIGEST_TAG],
             source: SESSION_DIGEST_TAG,
             confidence: 'observed',
-            source_session_id: opts.key,
+            sourceSessionId: opts.key,
             tenantId: opts.tenantId,
             baseHalfLifeDays: loadConfig(hippoRoot).defaultHalfLifeDays,
         }),

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

@@ -16,6 +16,9 @@ export interface CallerSessionEndResult {
     readonly handoffWritten: boolean;
     readonly snapshotsClosed: number;
 }
-/** Call on a session's final end only, since it closes the snapshot. A failed close throws so the sender retries, and the retry writes no second handoff. */
+/**
+ * Call on a session's final end only, since it closes the snapshot. A failed close throws so the sender retries, and
+ * the retry writes no second handoff.
+ */
 export declare function sessionEndHandoffForCaller(ctx: Context, req: CallerSessionEndRequest): CallerSessionEndResult;
 //# sourceMappingURL=session-end-caller.d.ts.map

package/dist/capture/session-end-caller.js

@@ -1,4 +1,5 @@
-// SessionEnd for a caller on another machine: the owner's handoff, then the owner's snapshot for the session closed, both under its tenant and project.
+// SessionEnd for a caller on another machine: the owner's handoff, then the owner's snapshot for the session closed,
+// both under its tenant and project.
 import { BadRequestError } from '../core/api-errors.js';
 import { writeSessionEndHandoff } from '../store/handoffs.js';
 import { closeTaskSnapshotsForSession } from '../store/sessions.js';
@@ -10,21 +11,32 @@ function checkedEvidence(evidence) {
         return null;
     const { gitRef = null, dirtyTree = null, testStatus = null } = evidence;
     // `git rev-parse HEAD` gives 40 hex, or 64 in a SHA-256 repository.
-    if (gitRef !== null && !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(gitRef))
-        throw new BadRequestError('evidence gitRef: 40 or 64 lowercase hex characters or ' +
-            'null');
-    if (dirtyTree !== null && dirtyTree !== true && dirtyTree !== false)
+    if (gitRef !== null && !/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(gitRef)) {
+        throw new BadRequestError('evidence gitRef: 40 or 64 lowercase hex characters or ' + 'null');
+    }
+    if (dirtyTree !== null && dirtyTree !== true && dirtyTree !== false) {
         throw new BadRequestError('evidence dirtyTree: true, false or null');
-    if (testStatus !== null && !TEST_STATUSES.has(testStatus))
+    }
+    if (testStatus !== null && !TEST_STATUSES.has(testStatus)) {
         throw new BadRequestError('evidence testStatus: pass, fail, unknown or null');
+    }
     return { gitRef, dirtyTree, testStatus };
 }
-/** Call on a session's final end only, since it closes the snapshot. A failed close throws so the sender retries, and the retry writes no second handoff. */
+/**
+ * Call on a session's final end only, since it closes the snapshot. A failed close throws so the sender retries, and
+ * the retry writes no second handoff.
+ */
 export function sessionEndHandoffForCaller(ctx, req) {
     const state = checkedWorkingState(req.workingState);
     const evidence = checkedEvidence(req.evidence);
     const key = bindCaller(ctx, req.sessionId, req.project);
-    const handoff = writeSessionEndHandoff(ctx.hippoRoot, ctx.tenantId, req.sessionId, evidence, state, key);
+    const handoff = writeSessionEndHandoff(ctx.hippoRoot, {
+        tenantId: ctx.tenantId,
+        sessionId: req.sessionId,
+        evidence,
+        derived: state,
+        key,
+    });
     const snapshotsClosed = closeTaskSnapshotsForSession(ctx.hippoRoot, ctx.tenantId, req.sessionId, 'session-ended', key);
     return { handoffWritten: handoff !== null, snapshotsClosed };
 }

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

@@ -8,7 +8,11 @@ export interface SessionCaptureRequest {
     readonly texts: readonly string[];
 }
 export type SessionCaptureResult = Readonly<CaptureTally>;
-/** Captures the session's statements into `ctx`'s tenant under the caller's project, skipping each text a row the caller can see already holds.
- *  Synchronous from the dedup read to the last write, so no other write lands between them. No console output and no process.exit. */
+/**
+ * Captures the session's statements into `ctx`'s tenant under the caller's project, skipping each text a row the caller
+ * can see already holds.
+ * Synchronous from the dedup read to the last write, so no other write lands between them. No console output and no
+ * process.exit.
+ */
 export declare function captureSessionTexts(ctx: Context, req: SessionCaptureRequest): SessionCaptureResult;
 //# sourceMappingURL=session-texts.d.ts.map

package/dist/capture/session-texts.js

@@ -1,4 +1,5 @@
-// `hippo capture --last-session` for a caller whose transcript was read on another machine: its project names the rows, never the store's folder.
+// `hippo capture --last-session` for a caller whose transcript was read on another machine: its project names the rows,
+// never the store's folder.
 import { BadRequestError } from '../core/api-errors.js';
 import { assertCallerIds } from '../api/prompt-hook.js';
 import { assertCallerProject, projectNames } from '../core/project-identity.js';
@@ -15,18 +16,24 @@ function assertSessionCapture(req) {
     assertCallerIds(req.sessionId, req.project);
     if (req.sessionId.trim() === '')
         throw new BadRequestError('session id: required');
-    // A '' project would read every project's rows as its own and write user-global rows; a rewritten one would split a project.
+    // A '' project would read every project's rows as its own and write user-global rows; a rewritten one would split a
+    // project.
     assertCallerProject(req.project);
     if (req.texts.length > MAX_TEXTS)
         throw new BadRequestError(`texts: at most ${MAX_TEXTS}`);
     const sizes = req.texts.map((t) => Buffer.byteLength(t, 'utf8'));
     if (sizes.some((n) => n > MAX_TEXT_BYTES))
         throw new BadRequestError(`each text: at most ${MAX_TEXT_BYTES} bytes`);
-    if (sizes.reduce((a, b) => a + b, 0) > MAX_TOTAL_BYTES)
+    if (sizes.reduce((a, b) => a + b, 0) > MAX_TOTAL_BYTES) {
         throw new BadRequestError(`texts: at most ${MAX_TOTAL_BYTES} bytes in all`);
+    }
 }
-/** Captures the session's statements into `ctx`'s tenant under the caller's project, skipping each text a row the caller can see already holds.
- *  Synchronous from the dedup read to the last write, so no other write lands between them. No console output and no process.exit. */
+/**
+ * Captures the session's statements into `ctx`'s tenant under the caller's project, skipping each text a row the caller
+ * can see already holds.
+ * Synchronous from the dedup read to the last write, so no other write lands between them. No console output and no
+ * process.exit.
+ */
 export function captureSessionTexts(ctx, req) {
     assertSessionCapture(req);
     const extracted = extractFromTexts(req.texts.map(scrubForSharing));
@@ -34,9 +41,17 @@ export function captureSessionTexts(ctx, req) {
     const items = extracted.slice(-MAX_ITEMS);
     if (items.length === 0)
         return { captured: 0, skipped: 0, rejected: 0 };
-    // The project filter is classifyOriginProject's in SQL: the caller's rows and user-global rows block a copy, other projects' rows do not.
+    // The project filter is classifyOriginProject's in SQL: the caller's rows and user-global rows block a copy, other
+    // projects' rows do not.
     const held = loadTextsHoldingWords(ctx.hippoRoot, ctx.tenantId, items.map((i) => longestWord(i.content)), projectNames(req.project));
-    const tally = captureExtractedItems(ctx.hippoRoot, { dryRun: false, tenantId: ctx.tenantId, originProject: req.project, sessionId: req.sessionId, actor: ctx.actor.subject, lean: true }, items, storedTextKeys(held));
+    const tally = captureExtractedItems(ctx.hippoRoot, {
+        dryRun: false,
+        tenantId: ctx.tenantId,
+        originProject: req.project,
+        sessionId: req.sessionId,
+        actor: ctx.actor.subject,
+        lean: true,
+    }, items, storedTextKeys(held));
     return { ...tally, skipped: tally.skipped + extracted.length - items.length };
 }
 //# sourceMappingURL=session-texts.js.map

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

@@ -1,13 +1,15 @@
 import type { SessionTurn } from './transcript.js';
 /** A turn close runs after each reply; a full close runs once, when the session ends. */
 export type WorkerMode = 'turn' | 'full';
-/** Runs `work` unless a live worker holds this session, which then runs the request after its own so the last reply is never dropped. */
+/** Runs `work` unless a live worker holds this session, which then runs the request after its own so the last reply is
+ * never dropped. */
 export declare function runSessionWorker(sessionId: string | null, mode: WorkerMode, work: (mode: WorkerMode) => Promise<void>): Promise<void>;
 /** The cursor position after `turns`: how many there were and a hash of the last. */
 export declare function turnPosition(turns: readonly SessionTurn[]): string;
 /** The turns after `position`; all of them when it is null or its last turn is no longer in view. */
 export declare function turnsAfter(turns: readonly SessionTurn[], position: string | null): readonly SessionTurn[];
-/** The saved position for this session's transcript; null when none was saved, it names another file, or it is unreadable. */
+/** The saved position for this session's transcript; null when none was saved, it names another file, or it is
+ * unreadable. */
 export declare function loadTurnPosition(sessionId: string, transcriptPath: string): string | null;
 export declare function saveTurnPosition(sessionId: string, transcriptPath: string, turns: readonly SessionTurn[], log: (message: string) => void): void;
 //# sourceMappingURL=session-worker.d.ts.map

package/dist/capture/session-worker.js

@@ -3,10 +3,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { homeDir } from '../util/agent-homes.js';
-import { errorMessage, log as logger } from '../util/log.js';
+import { errorCode, errorMessage, log as logger, errorFields } from '../util/log.js';
 import { isObjectLike, isStringValue } from '../core/capture-contract.js';
 import { SESSION_ID_RE } from './copilot-transcript.js';
 import { blockHash } from '../util/token-text.js';
+import { MINUTE_MS } from '../util/time.js';
 /** Null for a missing id or one that could climb out of the sessions folder. */
 function sessionStateFiles(sessionId) {
     if (sessionId === null || !SESSION_ID_RE.test(sessionId))
@@ -24,8 +25,10 @@ function pidAlive(pid) {
         return err instanceof Error && 'code' in err && err.code === 'EPERM';
     }
 }
-/** Windows reuses pids, so past this a lock is stale whatever process it names; a worker rarely waits more than minutes on a busy store. */
-const STALE_LOCK_MS = 15 * 60 * 1000;
+/** Windows reuses pids, so past this a lock is stale whatever process it names; a worker rarely waits more than minutes
+ * on a busy store. */
+const STALE_LOCK_MS = 15 * MINUTE_MS;
+const heldHere = new Set();
 /** A dead holder frees its session at once, and any holder at STALE_LOCK_MS. */
 function holderAlive(lock) {
     let text;
@@ -45,13 +48,16 @@ function holderAlive(lock) {
     if (!held)
         return true;
     const pid = Number(held[1]);
-    return pid !== process.pid && pidAlive(pid);
+    // Our own pid is live only while this process holds the lock; a leftover from a dead run that reused the pid is not.
+    return pid === process.pid ? heldHere.has(lock) : pidAlive(pid);
 }
-// SHORTCUT: two takers racing one stale-lock cleanup can both run, as every worker did before the lock; an atomic link-based take if that shows up.
+// SHORTCUT: two takers racing one stale-lock cleanup can both run, as every worker did before the lock; an atomic
+// link-based take if that shows up.
 function takeSessionLock(lock) {
     for (let attempt = 0; attempt < 2; attempt++) {
         try {
             fs.writeFileSync(lock, `${process.pid}:${Date.now()}`, { flag: 'wx' });
+            heldHere.add(lock);
             return 'taken';
         }
         catch (err) {
@@ -69,19 +75,36 @@ function takeSessionLock(lock) {
     }
     return 'held';
 }
+const warnedLocks = new Set();
+// The lock is best-effort, so the work still runs; the line says why it ran without one.
+function warnUnusableLockOnce(lock) {
+    if (warnedLocks.has(lock))
+        return;
+    warnedLocks.add(lock);
+    logger.warn(`session worker: lock ${lock} cannot be created or cleared, so the work runs without it`);
+}
 function releaseSessionLock(lock) {
+    heldHere.delete(lock);
     try {
         fs.rmSync(lock, { force: true });
     }
     catch (err) {
         // A lock left behind names this pid, which is dead once the worker exits, so the next taker clears it.
-        logger.debug(`session lock not removed: ${errorMessage(err)}`);
+        logger.debug(`session lock not removed: ${errorMessage(err)}`, errorFields(err));
     }
 }
-/** False when the sessions folder cannot be written, so the caller runs unlocked as before. */
+/** False when the request could not be queued; the caller then refuses the run, since an unlocked worker could race a
+ * live one. */
 function queueRun(files, mode) {
     try {
         fs.mkdirSync(path.dirname(files.queued), { recursive: true });
+    }
+    catch (err) {
+        logger.warn(`session worker: cannot create ${path.dirname(files.queued)}, ` +
+            `so the ${mode} close is not run: ${errorMessage(err)}`, errorFields(err));
+        return false;
+    }
+    try {
         // A full close outranks a turn close: it overwrites a queued turn, and a turn never replaces a queued full close.
         if (mode === 'full')
             fs.writeFileSync(files.queued, 'full');
@@ -90,7 +113,10 @@ function queueRun(files, mode) {
         return true;
     }
     catch (err) {
-        return err instanceof Error && 'code' in err && err.code === 'EEXIST';
+        if (errorCode(err) === 'EEXIST')
+            return true;
+        logger.warn(`session worker: cannot queue the ${mode} close in ${files.queued}, so it is not run: ${errorMessage(err)}`, errorFields(err));
+        return false;
     }
 }
 /** Takes the queued request by renaming it, so one queued while this reads it lands in a fresh file. */
@@ -99,8 +125,11 @@ function takeQueued(queued) {
     try {
         fs.renameSync(queued, taken);
     }
-    catch {
-        // Nothing queued, or a rename refused for a moment; the request stays queued for the next round.
+    catch (err) {
+        // ENOENT means nothing is queued; any other refusal leaves the request queued for the next round, but is told.
+        if (errorCode(err) !== 'ENOENT') {
+            logger.warn(`session worker: cannot take the queued request ${queued}: ${errorMessage(err)}`, errorFields(err));
+        }
         return null;
     }
     try {
@@ -110,14 +139,19 @@ function takeQueued(queued) {
         fs.rmSync(taken, { force: true });
     }
 }
-/** Runs `work` unless a live worker holds this session, which then runs the request after its own so the last reply is never dropped. */
+/** Runs `work` unless a live worker holds this session, which then runs the request after its own so the last reply is
+ * never dropped. */
 export async function runSessionWorker(sessionId, mode, work) {
     const files = sessionStateFiles(sessionId);
-    if (files === null || !queueRun(files, mode))
+    if (files === null)
         return work(mode);
+    if (!queueRun(files, mode))
+        return;
     for (let take = takeSessionLock(files.lock); take !== 'held'; take = takeSessionLock(files.lock)) {
-        if (take === 'unusable')
+        if (take === 'unusable') {
+            warnUnusableLockOnce(files.lock);
             return work(mode);
+        }
         let ran = false;
         try {
             for (let next = takeQueued(files.queued); next !== null; next = takeQueued(files.queued)) {
@@ -150,14 +184,16 @@ export function turnsAfter(turns, position) {
         return turns;
     if (count <= turns.length && turnKey(turns[count - 1]) === key)
         return turns.slice(count);
-    // A transcript too big to read whole is read from its tail, so the count shifts; the last turn's text still marks the place.
+    // A transcript too big to read whole is read from its tail, so the count shifts; the last turn's text still marks the
+    // place.
     for (let i = turns.length - 1; i >= 0; i--) {
         if (turnKey(turns[i]) === key)
             return turns.slice(i + 1);
     }
     return turns;
 }
-/** The saved position for this session's transcript; null when none was saved, it names another file, or it is unreadable. */
+/** The saved position for this session's transcript; null when none was saved, it names another file, or it is
+ * unreadable. */
 export function loadTurnPosition(sessionId, transcriptPath) {
     const file = sessionStateFiles(sessionId)?.cursor;
     if (!file || !fs.existsSync(file))
@@ -179,7 +215,11 @@ export function saveTurnPosition(sessionId, transcriptPath, turns, log) {
     if (!file)
         return;
     const cursor = {
-        runtime: 'vscode', sessionId, source: transcriptPath, position: turnPosition(turns), updatedAt: new Date().toISOString(),
+        runtime: 'vscode',
+        sessionId,
+        source: transcriptPath,
+        position: turnPosition(turns),
+        updatedAt: new Date().toISOString(),
     };
     const tmp = `${file}.${process.pid}.tmp`;
     try {
@@ -188,7 +228,8 @@ export function saveTurnPosition(sessionId, transcriptPath, turns, log) {
         fs.renameSync(tmp, file);
     }
     catch (err) {
-        // Windows refuses the rename (EPERM) while another process has the cursor open; the next reply re-reads these turns, which the dedupe keys absorb.
+        // Windows refuses the rename (EPERM) while another process has the cursor open; the next reply re-reads these
+        // turns, which the dedupe keys absorb.
         log(`cursor not saved: ${errorMessage(err)}`);
     }
 }