hippo-memory 1.67.0 → 1.69.0

package/dist/api/promote.js

@@ -1,14 +1,12 @@
 // Promote to the global store, supersede with a successor, and archive raw memories.
-import { openHippoDb, closeHippoDb, isSqliteBusy } from '../db.js';
+import { openHippoDb, closeHippoDb } from '../db.js';
 import { ConflictError, NotFoundError } from '../api-errors.js';
-import { auditRejectionRefusal } from '../store/audit-event.js';
 import { stampOriginProject } from '../store/entry-row.js';
-import { removeEntryMirrors } from '../store/mirrors.js';
-import { writeEntryDbOnly, writeEntryMirrors } from '../store/entry-writes.js';
+import { writeEntryMirrors } from '../store/entry-writes.js';
+import { cleanArchivedMirrors, commitSupersede } from '../store/entry-writes-group.js';
 import { readEntry } from '../store/entry-reads.js';
 import { updateStatsUnlessBusy } from '../store/index-and-stats.js';
-import { markSummaryDirtyInTx } from '../summary-dirty.js';
-import { RejectedValueError } from '../rejection.js';
+import { requireGroup } from '../store-port.js';
 import { log } from '../log.js';
 import { createSuccessor } from '../memory.js';
 import { appendAuditEvent } from '../audit.js';
@@ -16,7 +14,7 @@ import { promoteToGlobal } from '../shared.js';
 import { archiveRawMemory } from '../raw-archive.js';
 import { loadConfig } from '../config.js';
 import { selectMemoryReach } from '../store/tenant-lookup.js';
-import { canTouchScope } from '../recall-scope.js';
+import { canTouchScope, personalScopeOf } from '../recall-scope.js';
 export function promote(ctx, id) {
     // Tenant scope: promoteToGlobal reads the entry from the local root via
     // readEntry without a tenant filter, so a Bearer for tenant A could
@@ -49,11 +47,28 @@ export function promote(ctx, id) {
     return { ok: true, sourceId: id, globalId: globalEntry.id };
 }
 export function supersede(ctx, oldId, newContent) {
-    const old = readSupersedable(ctx, oldId);
-    const newEntry = createSuccessor(old, newContent, {
+    const reply = ctx.store ? supersedeThroughStore(ctx, ctx.store, oldId, newContent) : supersedeOnHippoDb(ctx, oldId, newContent);
+    // SAFETY: a C typed with a store gets the promise its path returns; a wide C is typed as the union, which a caller has to await anyway.
+    return reply;
+}
+async function supersedeThroughStore(ctx, store, oldId, newContent) {
+    const entryWrites = requireGroup(store, 'entryWrites');
+    const [old] = await store.entriesByIds([oldId], ctx.tenantId);
+    const newEntry = createSuccessor(assertSupersedable(ctx, oldId, old ?? null), newContent, {
         tenantId: ctx.tenantId,
         baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
     });
+    // The store writes origin_project as given, so the served folder's fallback is stamped here.
+    const successor = stampOriginProject(ctx.hippoRoot, newEntry);
+    await entryWrites.supersede({ tenantId: ctx.tenantId, actor: ctx.actor.subject, ownScope: personalScopeOf(ctx.actor), oldId, successor });
+    return { ok: true, oldId, newId: successor.id };
+}
+function supersedeOnHippoDb(ctx, oldId, newContent) {
+    const old = assertSupersedable(ctx, oldId, readEntry(ctx.hippoRoot, oldId, ctx.tenantId));
+    const successor = stampOriginProject(ctx.hippoRoot, createSuccessor(old, newContent, {
+        tenantId: ctx.tenantId,
+        baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
+    }));
     // Race-safe transition: open a fresh db handle, BEGIN IMMEDIATE, run all
     // three steps (CAS on old + writeEntryDbOnly(new) + supersede audit row)
     // inside the same transaction. Two concurrent supersedes: exactly one CAS
@@ -62,14 +77,14 @@ export function supersede(ctx, oldId, newContent) {
     // the old.superseded_by pointer.
     const db = openHippoDb(ctx.hippoRoot);
     try {
-        commitSupersede(db, ctx, oldId, old, newEntry);
+        commitSupersede(db, { tenantId: ctx.tenantId, actor: ctx.actor.subject, ownScope: personalScopeOf(ctx.actor), oldId, successor });
         // Mirrors after COMMIT, while the db handle is still open. Same
         // invariant as the original writeEntry: a mirror failure leaves disk
         // MISSING the markdown for the new memory (rebuildIndex rewrites every
         // markdown mirror from the DB) but DOES NOT desync the DB or
         // roll back the supersede. Logged + swallowed, non-fatal.
         try {
-            writeEntryMirrors(ctx.hippoRoot, newEntry);
+            writeEntryMirrors(ctx.hippoRoot, successor);
         }
         catch (mirrorErr) {
             log.error(`supersede: mirror write failed (non-fatal, will self-heal): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`);
@@ -78,11 +93,10 @@ export function supersede(ctx, oldId, newContent) {
     finally {
         closeHippoDb(db);
     }
-    return { ok: true, oldId, newId: newEntry.id };
+    return { ok: true, oldId, newId: successor.id };
 }
 /** The tenant-scoped row to supersede; another tenant's id, or someone else's personal row, reads as not found. */
-function readSupersedable(ctx, oldId) {
-    const old = readEntry(ctx.hippoRoot, oldId, ctx.tenantId);
+function assertSupersedable(ctx, oldId, old) {
     if (!old || !canTouchScope(ctx.actor, old.scope ?? null)) {
         throw new NotFoundError(`Memory not found: ${oldId}`);
     }
@@ -92,50 +106,22 @@ function readSupersedable(ctx, oldId) {
     }
     return old;
 }
-/** CAS on the old row, the successor's insert and the 'supersede' audit row, in one BEGIN IMMEDIATE transaction. */
-function commitSupersede(db, ctx, oldId, old, newEntry) {
-    db.exec('BEGIN IMMEDIATE');
-    try {
-        // The tenant filter repeats readEntry's check at no cost, closing an ownership change between read and update.
-        const result = db.prepare(`
-      UPDATE memories
-      SET superseded_by = ?
-      WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL
-    `).run(newEntry.id, oldId, ctx.tenantId);
-        if ((result.changes ?? 0) === 0) {
-            db.exec('ROLLBACK');
-            throw new ConflictError(`Memory ${oldId} already superseded by another writer`);
-        }
-        // After the CAS guard, so a lost race throws before the old parent is marked for rebuild.
-        if (old.dag_parent_id) {
-            markSummaryDirtyInTx(db, old.dag_parent_id, ctx.tenantId, ctx.actor.subject);
-        }
-        // Emits its own 'remember' audit row inside the same transaction.
-        writeEntryDbOnly(db, stampOriginProject(ctx.hippoRoot, newEntry), { actor: ctx.actor.subject });
-        appendAuditEvent(db, {
-            tenantId: ctx.tenantId,
-            actor: ctx.actor.subject,
-            op: 'supersede',
-            targetId: oldId,
-            metadata: { newId: newEntry.id },
-        });
-        db.exec('COMMIT');
-    }
-    catch (err) {
-        try {
-            db.exec('ROLLBACK');
-        }
-        catch { /* already rolled back */ }
-        // The refusal audit lands after ROLLBACK, in a fresh implicit transaction the aborted one cannot undo.
-        if (err instanceof RejectedValueError) {
-            auditRejectionRefusal(db, err, ctx.actor.subject);
-        }
-        throw err;
-    }
-}
 export function archiveRaw(ctx, id, reason, opts = {}) {
+    const reply = ctx.store ? archiveRawThroughStore(ctx, ctx.store, id, reason, opts) : archiveRawOnHippoDb(ctx, id, reason, opts);
+    // SAFETY: a C typed with a store gets the promise its path returns; a wide C is typed as the union, which a caller has to await anyway.
+    return reply;
+}
+/** afterArchive writes on hippo.db's own handle, and only connectors send it, so a store refuses it. */
+async function archiveRawThroughStore(ctx, store, id, reason, opts) {
+    const entryWrites = requireGroup(store, 'entryWrites');
+    if (opts.afterArchive)
+        throw new Error('afterArchive runs on hippo.db only, never through a store');
+    const archivedAt = await entryWrites.archiveRaw({ tenantId: ctx.tenantId, actor: ctx.actor.subject, ownScope: personalScopeOf(ctx.actor), id, reason });
+    return { ok: true, archivedAt };
+}
+function archiveRawOnHippoDb(ctx, id, reason, opts) {
     const db = openHippoDb(ctx.hippoRoot);
-    let mirrorOk = false;
+    let archivedAt;
     try {
         // Tenant scope: archiveRawMemory looks up the row by id alone, so a
         // Bearer for tenant A could archive tenant B's raw row without this
@@ -146,40 +132,12 @@ export function archiveRaw(ctx, id, reason, opts = {}) {
         if (reach?.tenantId !== ctx.tenantId || !canTouchScope(ctx.actor, reach.scope)) {
             throw new NotFoundError(`memory not found: ${id}`);
         }
-        archiveRawMemory(db, id, {
+        archivedAt = archiveRawMemory(db, id, {
             reason,
             who: ctx.actor.subject,
             afterArchive: opts.afterArchive,
         });
-        // archiveRawMemory deletes the memories row but leaves any legacy markdown
-        // mirror in <root>/{buffer,episodic,semantic}/<id>.md untouched. If we left
-        // the mirror in place, a subsequent initStore() on an empty memories table
-        // would silently re-import the row via bootstrapLegacyStore — defeating the
-        // archive (and the GDPR right-to-be-forgotten promise on raw rows). Mirror
-        // forget() at src/store.ts:1046, which uses the same removeEntryMirrors call.
-        // The DB transaction has already committed; if filesystem unlink fails here
-        // we log and continue. The mirror reaper in openHippoDb will catch it on
-        // next DB open: raw_archive.mirror_cleaned_at stays NULL until every layer
-        // mirror for this id is gone, so the reaper genuinely retries.
-        try {
-            removeEntryMirrors(ctx.hippoRoot, id);
-            mirrorOk = true;
-        }
-        catch (mirrorErr) {
-            log.error(`archiveRaw: mirror cleanup failed for ${id} (will retry via reaper on next openHippoDb): ${mirrorErr instanceof Error ? mirrorErr.message : String(mirrorErr)}`);
-        }
-        if (mirrorOk) {
-            // Stamp mirror_cleaned_at now so the next openHippoDb reaper SELECT
-            // returns empty for this row. NULL stays untouched on failure -> retry.
-            try {
-                db.prepare(`UPDATE raw_archive SET mirror_cleaned_at = ? WHERE memory_id = ?`).run(new Date().toISOString(), id);
-            }
-            catch (err) {
-                if (!isSqliteBusy(err))
-                    throw err;
-                log.warnThenDebug('archive-mirror-stamp-busy', `archived ${id}; the store was busy, so the mirror reaper will re-check it on the next open`);
-            }
-        }
+        cleanArchivedMirrors(db, ctx.hippoRoot, id);
     }
     finally {
         closeHippoDb(db);
@@ -187,9 +145,6 @@ export function archiveRaw(ctx, id, reason, opts = {}) {
     // Counted here rather than in the CLI: the HTTP archive route calls this too,
     // so a routed archive would otherwise never reach the forgotten counter.
     updateStatsUnlessBusy(ctx.hippoRoot, { forgotten: 1 }, `removed ${id}`);
-    // archiveRawMemory does not return the archive_at timestamp it wrote. We
-    // emit a fresh ISO timestamp here for the API response. Within a millisecond
-    // of the actual write, fine for a server response shape.
-    return { ok: true, archivedAt: new Date().toISOString() };
+    return { ok: true, archivedAt };
 }
 //# sourceMappingURL=promote.js.map

package/dist/api/remember.d.ts

@@ -1,6 +1,6 @@
 import type { DatabaseSyncLike } from '../db.js';
 import { type MemoryKind } from '../memory.js';
-import type { Context } from './types.js';
+import type { Context, StoreReply } from './types.js';
 export interface RememberOpts {
     content: string;
     kind?: MemoryKind;
@@ -38,5 +38,6 @@ export interface RememberResult {
     /** Set only when the content held secret material: untrusted text had it redacted, typed text was stored as sent. */
     warnings?: string[];
 }
-export declare function remember(ctx: Context, opts: RememberOpts): RememberResult;
+/** Store one memory. With `ctx.store`, its entryWrites group writes the row and its remember row; hippo.db is opened only when there is no store. */
+export declare function remember<C extends Context>(ctx: C, opts: RememberOpts): StoreReply<C, RememberResult>;
 //# sourceMappingURL=remember.d.ts.map

package/dist/api/remember.js

@@ -1,5 +1,7 @@
 // Write path: remember stores one memory after secret vetting and, for untrusted content, the instruction check.
 import { writeEntry } from '../store/entry-writes.js';
+import { stampOriginProject } from '../store/entry-row.js';
+import { requireGroup } from '../store-port.js';
 import { detectInstruction } from '../instruction-detect.js';
 import { quarantineScopeFor, recordQuarantine } from '../quarantine.js';
 import { createMemory } from '../memory.js';
@@ -24,7 +26,7 @@ function rememberScope(ctx, opts) {
     }
     return own;
 }
-export function remember(ctx, opts) {
+function prepareRemember(ctx, opts) {
     if (opts.project)
         assertCallerProject(opts.project);
     const requestedScope = rememberScope(ctx, opts);
@@ -39,6 +41,39 @@ export function remember(ctx, opts) {
         tenantId: ctx.tenantId,
         baseHalfLifeDays: loadConfig(ctx.hippoRoot).defaultHalfLifeDays,
     });
+    // Aliases only widen what a reader matches; a row has one origin. A personal row's '' follows its owner into every project.
+    const origin = opts.personal ? '' : opts.project?.name;
+    const stamped = origin !== undefined ? { ...entry, origin_project: origin } : entry;
+    return { entry: stamped, requestedScope, detection, warnings: vetted.warnings };
+}
+function rememberResult(ctx, prepared) {
+    const { entry, detection, warnings } = prepared;
+    const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId };
+    if (detection.flagged)
+        result.quarantined = { reason: detection.reason ?? 'unknown' };
+    if (warnings.length > 0)
+        result.warnings = [...warnings];
+    return result;
+}
+/** Store one memory. With `ctx.store`, its entryWrites group writes the row and its remember row; hippo.db is opened only when there is no store. */
+export function remember(ctx, opts) {
+    const reply = ctx.store ? rememberThroughStore(ctx, ctx.store, opts) : rememberOnHippoDb(ctx, opts);
+    // SAFETY: a C typed with a store gets the promise its path returns; a wide C is typed as the union, which a caller has to await anyway.
+    return reply;
+}
+/** afterWrite and the quarantine row write on hippo.db's own handle, and only connectors send them, so a store refuses both. */
+async function rememberThroughStore(ctx, store, opts) {
+    const entryWrites = requireGroup(store, 'entryWrites');
+    if (opts.afterWrite || opts.untrusted)
+        throw new Error('afterWrite and untrusted content are written to hippo.db only, never through a store');
+    const prepared = prepareRemember(ctx, opts);
+    // The store writes origin_project as given, so the served folder's fallback is stamped here.
+    await entryWrites.writeEntry({ entry: stampOriginProject(ctx.hippoRoot, prepared.entry), actor: ctx.actor.subject });
+    return rememberResult(ctx, prepared);
+}
+function rememberOnHippoDb(ctx, opts) {
+    const prepared = prepareRemember(ctx, opts);
+    const { requestedScope, detection } = prepared;
     // writeEntry threads ctx.actor.subject into its internal audit hook, so exactly
     // one 'remember' event lands in the log with the supplied actor.
     const afterWrite = detection.flagged
@@ -53,15 +88,7 @@ export function remember(ctx, opts) {
             opts.afterWrite?.(db, memoryId);
         }
         : opts.afterWrite;
-    // Aliases only widen what a reader matches; a row has one origin. A personal row's '' follows its owner into every project.
-    const origin = opts.personal ? '' : opts.project?.name;
-    const stamped = origin !== undefined ? { ...entry, origin_project: origin } : entry;
-    writeEntry(ctx.hippoRoot, stamped, { actor: ctx.actor.subject, afterWrite });
-    const result = { id: entry.id, kind: entry.kind, tenantId: ctx.tenantId };
-    if (detection.flagged)
-        result.quarantined = { reason: detection.reason ?? 'unknown' };
-    if (vetted.warnings.length > 0)
-        result.warnings = vetted.warnings;
-    return result;
+    writeEntry(ctx.hippoRoot, prepared.entry, { actor: ctx.actor.subject, afterWrite });
+    return rememberResult(ctx, prepared);
 }
 //# sourceMappingURL=remember.js.map

package/dist/api/types.d.ts

@@ -25,6 +25,15 @@ export interface Context {
     actor: Actor;
     store?: HippoStore;
 }
+export type HippoDbContext = Context & {
+    store?: undefined;
+};
+export type StoreReply<C extends Context, R> = C extends {
+    readonly store: HippoStore;
+} ? Promise<R> : C extends {
+    readonly hippoRoot: string;
+    readonly store?: undefined;
+} ? R : R | Promise<R>;
 /**
  * Helper for building process-local Actor values (admin and host admin),
  * used by CLI and CLI-run connector Context constructors so the role

package/dist/auth.d.ts

@@ -23,6 +23,25 @@ export interface CreateApiKeyResult {
     keyId: string;
     plaintext: string;
 }
+/** A fresh key: the plaintext its caller sees once, and the scrypt hash a store keeps in its place. */
+export interface MintedApiKey extends CreateApiKeyResult {
+    keyHash: string;
+}
+export declare function mintApiKey(): MintedApiKey;
+/** One api_keys row as core hands it to a store: the hash of the secret, never the secret. */
+export interface NewApiKey {
+    readonly keyId: string;
+    readonly keyHash: string;
+    readonly tenantId: string;
+    readonly label: string | null;
+    readonly role: 'admin' | 'member';
+    readonly createdAt: string;
+    /** The auth-resolver subject a self-service key belongs to; null for a key an admin or the CLI mints. */
+    readonly ownerSubject: string | null;
+    /** ISO time the key stops working; null means it never expires. */
+    readonly expiresAt: string | null;
+}
+export declare function insertApiKey(db: DatabaseSyncLike, key: NewApiKey): void;
 export declare function createApiKey(db: DatabaseSyncLike, opts: CreateApiKeyOpts): CreateApiKeyResult;
 export interface ValidateResult {
     valid: boolean;

package/dist/auth.js

@@ -36,17 +36,25 @@ function verifyKey(plaintext, stored) {
     const actual = scryptSync(plaintext, salt, expected.length);
     return expected.length === actual.length && timingSafeEqual(expected, actual);
 }
-export function createApiKey(db, opts) {
+export function mintApiKey() {
     const keyId = `${API_KEY_PREFIX}${randBase32(ID_LEN)}`;
-    const secret = randBase32(SECRET_LEN);
-    const plaintext = `${keyId}.${secret}`;
-    const hash = hashKey(plaintext);
+    const plaintext = `${keyId}.${randBase32(SECRET_LEN)}`;
+    return { keyId, plaintext, keyHash: hashKey(plaintext) };
+}
+export function insertApiKey(db, key) {
     // openHippoDb runs runMigrations synchronously before returning the db handle,
     // so migration v26 (adds role column) is in place before this INSERT runs.
     // 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)
+    if (key.expiresAt !== null)
         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);
+    db.prepare(`INSERT INTO api_keys (key_id, key_hash, tenant_id, label, created_at, role, owner_subject, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(key.keyId, key.keyHash, key.tenantId, key.label, key.createdAt, key.role, key.ownerSubject, key.expiresAt);
+}
+export function createApiKey(db, opts) {
+    const { keyId, plaintext, keyHash } = mintApiKey();
+    insertApiKey(db, {
+        keyId, keyHash, tenantId: opts.tenantId, label: opts.label ?? null, role: opts.role ?? 'admin', createdAt: new Date().toISOString(),
+        ownerSubject: opts.ownerSubject ?? null, expiresAt: opts.expiresAt ?? null,
+    });
     return { keyId, plaintext };
 }
 /** The api_keys row for `keyId` with its scope grants; null when no row matches. */

package/dist/capture/compact.js

@@ -4,10 +4,11 @@ import { isInitialized } from '../store/open.js';
 import { saveActiveTaskSnapshot, loadActiveTaskSnapshot } from '../store/sessions.js';
 import { PRE_COMPACT_INSTRUCTION, parsePostCompactPayload, postCompactLine, recordCompactionStart, recordSnapshotSaved, saveCompaction, replayCompactionsAt, COMPACTION_DB_WAIT_MS, } from '../compaction-record.js';
 import { resolveTenantId } from '../tenant.js';
-import { defaultPreCompactLogPath } from '../hooks/shared.js';
+import { defaultPreCompactLogPath, vscodeUserHooksFile } from '../hooks/shared.js';
 import { readClaudeCodePreCompact } from '../capture-contract.js';
 import { errorMessage } from '../log.js';
 import { resolveLastSessionTranscript } from './transcript.js';
+import { isVscodeTranscript } from './copilot-transcript.js';
 import { mergeWorkingState, transcriptWorkingState } from './working-state.js';
 // ---------------------------------------------------------------------------
 // `hippo pre-compact` — PreCompact hook producer
@@ -58,6 +59,14 @@ function printPreCompactInstruction(logFile) {
         appendPreCompactLog(logFile, `instruction not printed: ${errorMessage(err)}`);
     }
 }
+/** The Copilot CLI accepts both preCompact and PreCompact, so hippo.json's pair can run twice for one compaction. */
+const TWIN_FIRE_MS = 10_000;
+function snapshotJustSaved(hippoRoot, sessionId) {
+    if (sessionId === null || sessionId === '')
+        return false;
+    const active = loadActiveTaskSnapshot(hippoRoot, resolveTenantId({}));
+    return active?.session_id === sessionId && active.source === 'pre-compact' && Date.now() - Date.parse(active.updated_at) < TWIN_FIRE_MS;
+}
 /** Runs the PreCompact producer: records the compaction, asks the summariser for memories, saves a working-state snapshot. Never extracts memories itself; SessionEnd capture owns that. */
 function runPreCompact(hippoRoot, options, logFile) {
     const { stdinText, stdinTimedOut = false, runtime = 'claude-code' } = options;
@@ -74,10 +83,20 @@ function runPreCompact(hippoRoot, options, logFile) {
         return;
     }
     const { sessionId, transcriptPath: payloadTranscriptPath, cwd: payloadCwd, trigger: payloadTrigger } = receipt.input;
+    // With chat.useClaudeHooks on, VS Code runs Claude Code's hooks too; it never sends PostCompact to close a record, nor reads the summariser text.
+    const vscode = runtime === 'claude-code' && isVscodeTranscript(payloadTranscriptPath);
+    if (vscode && fs.existsSync(vscodeUserHooksFile())) {
+        appendPreCompactLog(logFile, 'skip: VS Code payload, hippo.json runs pre-compact for this chat');
+        return;
+    }
+    if (runtime === 'copilot' && snapshotJustSaved(hippoRoot, sessionId)) {
+        appendPreCompactLog(logFile, `skip: snapshot for session ${sessionId} saved under ${TWIN_FIRE_MS / 1000} s ago, by the other preCompact entry`);
+        return;
+    }
     // The record is the "something saved before every compaction", so it lands even when no snapshot is derivable below.
     // Copilot has no PostCompact hook to close a record, so its compactions get the snapshot alone.
     let recordId = null;
-    if (runtime === 'claude-code' && sessionId !== null && sessionId !== '') {
+    if (runtime === 'claude-code' && !vscode && sessionId !== null && sessionId !== '') {
         recordId = recordCompactionStart(hippoRoot, { sessionId, trigger: payloadTrigger, cwd: payloadCwd, transcriptPath: payloadTranscriptPath }, (message) => appendPreCompactLog(logFile, message));
         printPreCompactInstruction(logFile);
     }

package/dist/capture/copilot-transcript.d.ts

@@ -8,8 +8,11 @@ export interface CopilotTurn {
     role: 'user' | 'assistant';
     text: string;
 }
+export declare const SESSION_ID_RE: RegExp;
 /** The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a missing file. */
 export declare function copilotTranscriptFor(sessionId: string): string | null;
+/** True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in either slash and any case. */
+export declare function isVscodeTranscript(file: string | null): boolean;
 /** The turn one Copilot event-log line carries: the text of a human user.message or of an assistant.message; null for any other line, a sub-agent's included. */
 export declare function copilotTurn(line: CopilotEventLine): CopilotTurn | null;
 //# sourceMappingURL=copilot-transcript.d.ts.map

package/dist/capture/copilot-transcript.js

@@ -5,7 +5,7 @@ import * as path from 'path';
 import { copilotHomeDir } from '../hooks/shared.js';
 import { isObjectLike, isStringValue } from '../capture-contract.js';
 // A session id becomes a folder name, so anything beyond word characters and hyphens could climb out of session-state.
-const SESSION_ID_RE = /^[\w-]+$/;
+export const SESSION_ID_RE = /^[\w-]+$/;
 // user.message sources that mark text hippo did not get from the human: a hidden skill injection or another agent's prompt.
 const INJECTED_SOURCE_PREFIXES = ['skill-', 'agent-'];
 /** The Copilot CLI log for a session, `<copilotHome>/session-state/<id>/events.jsonl`; null for an unsafe id or a missing file. */
@@ -15,6 +15,13 @@ export function copilotTranscriptFor(sessionId) {
     const file = path.join(copilotHomeDir(), 'session-state', sessionId, 'events.jsonl');
     return fs.existsSync(file) ? file : null;
 }
+/** True for VS Code's own chat log, `<workspaceStorage>/<id>/github.copilot-chat/transcripts/<session id>.jsonl`, in either slash and any case. */
+export function isVscodeTranscript(file) {
+    if (!file)
+        return false;
+    const parts = file.toLowerCase().split(/[\\/]/);
+    return parts.length >= 3 && parts[parts.length - 2] === 'transcripts' && parts[parts.length - 3] === 'github.copilot-chat';
+}
 function isSubagentLine(line, data) {
     if (isStringValue(line.agentId) && line.agentId !== '')
         return true;

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

@@ -0,0 +1,13 @@
+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. */
+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. */
+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