@indigoai-us/hq-cli 5.209.0 → 5.210.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.210.0] — 2026-09-26
+
+### Fixed
+
+- Lane messages delivered during a provider turn are replayed after transcript
+  compaction when `lanes.message-compaction-replay` is enabled, limited to that
+  provider turn. Monitor events keep their data framing.
+
 ## [5.209.0] — 2026-09-26
 
 ### Added

package/dist/lanes-drain-hook.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lanes-drain-hook.d.ts.map

package/dist/lanes-drain-hook.js

@@ -0,0 +1,52 @@
+import { runDrainHook } from "./lib/lanes/dropbox.js";
+function parseHookInput(text) {
+    if (text.trim() === "")
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`invalid_hook_input_json: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("invalid_hook_input_shape: expected a JSON object");
+    }
+    const value = parsed;
+    for (const key of ["transcript_path", "session_id", "hook_event_name"]) {
+        if (value[key] !== undefined && value[key] !== null && typeof value[key] !== "string") {
+            throw new Error(`invalid_hook_input_field: ${key} must be a string`);
+        }
+    }
+    return {
+        ...(typeof value.transcript_path === "string" ? { transcript_path: value.transcript_path } : {}),
+        ...(typeof value.session_id === "string" ? { session_id: value.session_id } : {}),
+        ...(typeof value.hook_event_name === "string" ? { hook_event_name: value.hook_event_name } : {}),
+    };
+}
+async function main() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.from(chunk));
+    const text = Buffer.concat(chunks).toString("utf8");
+    let input = {};
+    let inputError = "";
+    try {
+        input = parseHookInput(text);
+    }
+    catch (err) {
+        inputError = `hq-lanes-drain: ${err instanceof Error ? err.message : String(err)}\n`;
+    }
+    const result = await runDrainHook(process.env, input);
+    if (result.stdout)
+        process.stdout.write(result.stdout);
+    if (inputError || result.stderr)
+        process.stderr.write(`${inputError}${result.stderr}`);
+    process.exitCode = result.exitCode;
+}
+main().catch((err) => {
+    process.stderr.write(`hq-lanes-drain: hook_runner_failed: ${err instanceof Error ? err.message : String(err)}\n`);
+    // A hook runner failure must not stop the provider's requested tool call.
+    process.exitCode = 0;
+});
+//# sourceMappingURL=lanes-drain-hook.js.map

package/dist/lib/lanes/compaction.d.ts

@@ -25,7 +25,7 @@
  * transcript is read only for `compact_boundary` system records, and only
  * their `compactMetadata.preTokens` is kept.
  */
-import type { LaneCompactionRecord, LaneRecord, LaneRunUsage } from "./types.js";
+import type { LaneCompactionRecord, LaneProvider, LaneRecord, LaneRunUsage } from "./types.js";
 export declare const COMPACTION_MECHANISM: "claude_print_compact";
 /** The whole prompt of the compaction turn. */
 export declare const COMPACTION_PROMPT = "/compact";
@@ -47,6 +47,20 @@ export interface CompactBoundaryProbe {
     count: number;
     last_pre_tokens: number | null;
 }
+export interface ProviderCompactionDelta {
+    count: number;
+    next_offset: number;
+    replaced: boolean;
+}
+/** Read newly appended, newline-complete marker records after a saved byte offset. */
+export declare function probeProviderCompactionsSince(transcriptPath: string, provider: LaneProvider, startOffset: number): ProviderCompactionDelta;
+export declare function providerTranscriptSize(transcriptPath: string): number;
+/**
+ * Read only provider compaction markers from a lane transcript. Claude writes
+ * `system/compact_boundary`; Codex rollout files write a top-level
+ * `compacted` record. Tool and prompt contents are never returned or logged.
+ */
+export declare function probeProviderCompactions(transcriptPath: string | null, provider: LaneProvider): number;
 /** Locate `<home>/projects/<cwd-slug>/<sid>.jsonl` without deriving the slug. */
 export declare function findSessionTranscript(home: string, sessionId: string): string | null;
 /** Count compact boundaries in a transcript. Other lines are never parsed. */

package/dist/lib/lanes/compaction.js

@@ -49,6 +49,102 @@ export function compactionDue(lane, nowMs, thresholdMs) {
         threshold_ms: thresholdMs,
     };
 }
+function isProviderMarkerLine(line, lineNumber, transcriptPath, provider) {
+    const needle = provider === "claude" ? "compact_boundary" : "compacted";
+    if (!line.includes(needle))
+        return false;
+    let record;
+    try {
+        const parsed = JSON.parse(line);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return false;
+        record = parsed;
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: skipped unparseable provider transcript marker line ${lineNumber} in ${transcriptPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        return false;
+    }
+    return ((provider === "claude" && record.type === "system" && record.subtype === "compact_boundary") ||
+        (provider === "codex" && record.type === "compacted"));
+}
+/** Read newly appended, newline-complete marker records after a saved byte offset. */
+export function probeProviderCompactionsSince(transcriptPath, provider, startOffset) {
+    if (provider === "grok")
+        return { count: 0, next_offset: startOffset, replaced: false };
+    const fd = fs.openSync(transcriptPath, "r");
+    try {
+        const size = fs.fstatSync(fd).size;
+        if (startOffset > size)
+            return { count: 0, next_offset: size, replaced: true };
+        if (startOffset === size)
+            return { count: 0, next_offset: size, replaced: false };
+        const chunkSize = 1024 * 1024;
+        const lineParts = [];
+        let count = 0;
+        let position = startOffset;
+        let nextOffset = startOffset;
+        let lineNumber = 0;
+        while (position < size) {
+            const chunk = Buffer.allocUnsafe(Math.min(chunkSize, size - position));
+            const read = fs.readSync(fd, chunk, 0, chunk.length, position);
+            if (read === 0)
+                break;
+            position += read;
+            let lineStart = 0;
+            for (let index = 0; index < read; index += 1) {
+                if (chunk[index] !== 0x0a)
+                    continue;
+                lineParts.push(chunk.subarray(lineStart, index));
+                const line = Buffer.concat(lineParts).toString("utf8");
+                lineParts.length = 0;
+                lineNumber += 1;
+                if (isProviderMarkerLine(line, lineNumber, transcriptPath, provider))
+                    count += 1;
+                lineStart = index + 1;
+                nextOffset = position - (read - lineStart);
+            }
+            if (lineStart < read)
+                lineParts.push(chunk.subarray(lineStart, read));
+        }
+        return {
+            count,
+            next_offset: nextOffset,
+            replaced: false,
+        };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+export function providerTranscriptSize(transcriptPath) {
+    try {
+        return fs.statSync(transcriptPath).size;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return 0;
+        throw err;
+    }
+}
+/**
+ * Read only provider compaction markers from a lane transcript. Claude writes
+ * `system/compact_boundary`; Codex rollout files write a top-level
+ * `compacted` record. Tool and prompt contents are never returned or logged.
+ */
+export function probeProviderCompactions(transcriptPath, provider) {
+    if (transcriptPath === null)
+        return 0;
+    if (provider === "grok")
+        return 0;
+    try {
+        return probeProviderCompactionsSince(transcriptPath, provider, 0).count;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return 0;
+        throw err;
+    }
+}
 /** Locate `<home>/projects/<cwd-slug>/<sid>.jsonl` without deriving the slug. */
 export function findSessionTranscript(home, sessionId) {
     const projects = path.join(home, "projects");

package/dist/lib/lanes/dropbox.d.ts

@@ -8,12 +8,15 @@
  * overlap.
  */
 import * as fs from "node:fs";
-import { type LaneRecord, type LaneState, type QuestionRecord } from "./types.js";
+import { probeProviderCompactionsSince } from "./compaction.js";
+import { tryReadLane } from "./store.js";
+import { type LaneCompanyRef, type LaneRecord, type LaneState, type QuestionRecord } from "./types.js";
 export declare const DROPBOX_DIR = "dropbox";
 export declare const INBOX_NAME = "inbox.jsonl";
 export declare const DRAINING_DIR = "draining";
 export declare const DELIVERED_DIR = "delivered";
 export declare const INFLIGHT_DIR = "inflight";
+export { LANE_MESSAGE_COMPACTION_REPLAY_FLAG } from "./message-replay.js";
 export interface DropboxMessage {
     at?: string;
     message_id?: string;
@@ -45,6 +48,21 @@ export interface DrainDeps {
     canDrain?: () => boolean;
     /** Test seam: runs after this process has claimed and read its bytes. */
     afterRead?: () => void;
+    /** Prefix marks archives that belong to one provider turn. */
+    archivePrefix?: string;
+}
+export interface LaneDrainHookInput {
+    transcript_path?: string | null;
+    session_id?: string;
+    hook_event_name?: string;
+}
+export interface RunDrainHookDeps {
+    readFlag?: (flag: string, options: {
+        company?: LaneCompanyRef | null;
+        env: NodeJS.ProcessEnv;
+    }) => Promise<boolean>;
+    readLane?: typeof tryReadLane;
+    probeCompactionsSince?: typeof probeProviderCompactionsSince;
 }
 export declare function mintClaimId(): string;
 export declare function assertSafeLaneId(laneId: string): void;
@@ -81,7 +99,7 @@ export declare function formatOperatorInstruction(messages: DropboxMessage[]): s
 export declare function formatMonitorEvent(message: DropboxMessage): string;
 /** Keep event order while framing monitor output separately from operator messages. */
 export declare function formatDropboxMessages(messages: DropboxMessage[]): string;
-export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "UserPromptSubmit"): string;
+export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "UserPromptSubmit", leadingNote?: string): string;
 export interface DrainHookResult {
     exitCode: number;
     stdout: string;
@@ -92,7 +110,7 @@ export interface DrainHookResult {
  * That no-op is load-bearing: this hook is registered in the grok home and runs
  * on every session on the box.
  */
-export declare function runDrainHook(env: NodeJS.ProcessEnv): DrainHookResult;
+export declare function runDrainHook(env: NodeJS.ProcessEnv, input?: LaneDrainHookInput, deps?: RunDrainHookDeps): Promise<DrainHookResult>;
 /** Spec §6.5: only a still-running lane gets drop-box delivery. */
 export declare function laneAcceptsDropboxDelivery(lane: Pick<LaneRecord, "state">): boolean;
 /**

package/dist/lib/lanes/dropbox.js

@@ -10,13 +10,18 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { probeProviderCompactionsSince, providerTranscriptSize, } from "./compaction.js";
 import { LanesError } from "./errors.js";
+import { readLanesRegistryFlag } from "./registry-flag.js";
+import { LANE_MESSAGE_COMPACTION_REPLAY_FLAG, MESSAGE_COMPACTION_REPLAY_NOTE, MESSAGE_REPLAY_STATE_NAME, } from "./message-replay.js";
 import { LANES_RUNS_REL, readProcStarttime } from "./spawn.js";
+import { tryReadLane } from "./store.js";
 export const DROPBOX_DIR = "dropbox";
 export const INBOX_NAME = "inbox.jsonl";
 export const DRAINING_DIR = "draining";
 export const DELIVERED_DIR = "delivered";
 export const INFLIGHT_DIR = "inflight";
+export { LANE_MESSAGE_COMPACTION_REPLAY_FLAG } from "./message-replay.js";
 function defaultDrainDeps() {
     return {
         mkdirSync: fs.mkdirSync.bind(fs),
@@ -278,7 +283,7 @@ export function drainDropboxAtPath(box, depsInput = {}) {
     deps.afterRead?.();
     for (const name of claimed) {
         const src = path.join(inflightDir, name);
-        const dest = path.join(delivered, `${deps.unique()}.${name}`);
+        const dest = path.join(delivered, `${deps.archivePrefix ?? ""}${deps.unique()}.${name}`);
         if (!tryRename(src, dest, deps)) {
             throw new LanesError("dropbox_unreadable", `Claimed drop box file disappeared before delivery archive: ${src}`, { path: src });
         }
@@ -346,20 +351,118 @@ export function formatDropboxMessages(messages) {
     flushOperatorMessages();
     return sections.join("\n\n");
 }
-export function hookAdditionalContextJson(messages, hookEventName = "PreToolUse") {
+export function hookAdditionalContextJson(messages, hookEventName = "PreToolUse", leadingNote) {
+    const formatted = formatDropboxMessages(messages);
     return `${JSON.stringify({
         hookSpecificOutput: {
             hookEventName,
-            additionalContext: formatDropboxMessages(messages),
+            additionalContext: leadingNote ? `${leadingNote}\n\n${formatted}` : formatted,
         },
     })}\n`;
 }
+function replayStatePath(hqRoot, laneId) {
+    return path.join(dropboxDir(hqRoot, laneId), MESSAGE_REPLAY_STATE_NAME);
+}
+function safeProviderTranscriptPath(transcriptPath, provider, env) {
+    if (provider === "grok")
+        return transcriptPath;
+    const home = provider === "claude" ? env.CLAUDE_CONFIG_DIR : env.CODEX_HOME;
+    if (!home) {
+        throw new LanesError("message_replay_provider_home_missing", `Cannot validate ${provider} transcript without its provider home`);
+    }
+    if (!path.isAbsolute(transcriptPath) || path.extname(transcriptPath) !== ".jsonl") {
+        throw new LanesError("message_replay_transcript_path_invalid", `The ${provider} hook transcript path must be an absolute JSONL path`);
+    }
+    const configuredHomePath = path.resolve(home);
+    const homePath = fs.realpathSync(home);
+    const candidate = path.resolve(transcriptPath);
+    const expectedRoot = provider === "claude" ? "projects" : "sessions";
+    const assertWithinProviderHome = (root, resolvedTranscript, message) => {
+        const relative = path.relative(root, resolvedTranscript);
+        if (relative === "" ||
+            relative === ".." ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative) ||
+            relative.split(path.sep)[0] !== expectedRoot) {
+            throw new LanesError("message_replay_transcript_outside_provider_home", message);
+        }
+    };
+    try {
+        const realTranscript = fs.realpathSync(candidate);
+        assertWithinProviderHome(homePath, realTranscript, `The ${provider} hook transcript resolves outside its ${expectedRoot} directory`);
+        return realTranscript;
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            assertWithinProviderHome(configuredHomePath, candidate, `The ${provider} hook transcript is outside its configured ${expectedRoot} directory`);
+            return candidate;
+        }
+        throw err;
+    }
+}
+function readReplayState(filePath, turnId) {
+    const text = fs.readFileSync(filePath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new LanesError("message_replay_state_invalid", `Replay state ${filePath} is invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new LanesError("message_replay_state_invalid", `Replay state ${filePath} is not an object`);
+    }
+    const state = parsed;
+    if (state.schema_version !== 1 ||
+        state.turn_id !== turnId ||
+        (state.last_compaction_marker !== null &&
+            (!Number.isSafeInteger(state.last_compaction_marker) || Number(state.last_compaction_marker) < 0)) ||
+        (state.transcript_offset !== undefined &&
+            (!Number.isSafeInteger(state.transcript_offset) || Number(state.transcript_offset) < 0)) ||
+        (state.transcript_path !== undefined && typeof state.transcript_path !== "string") ||
+        (state.flag_enabled !== undefined && typeof state.flag_enabled !== "boolean")) {
+        throw new LanesError("message_replay_state_invalid", `Replay state ${filePath} does not match the current provider turn`);
+    }
+    // Older state files persisted this per-turn cache. Accept it, but remove it
+    // before the next write so the flag is refreshed for every compaction.
+    delete state.flag_enabled;
+    return state;
+}
+function writeReplayState(filePath, state) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    fs.writeFileSync(tempPath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+    try {
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (err) {
+        fs.rmSync(tempPath, { force: true });
+        throw err;
+    }
+}
+function deliveredMessagesForTurn(hqRoot, laneId, turnId) {
+    const delivered = path.join(dropboxDir(hqRoot, laneId), DELIVERED_DIR);
+    let names;
+    try {
+        names = fs.readdirSync(delivered).filter((name) => name.startsWith(`${turnId}.`));
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+    names.sort();
+    return names.flatMap((name) => readClaimedFile(path.join(delivered, name), defaultDrainDeps()));
+}
+function reportReplayFailure(err) {
+    return `hq-lanes-drain: message compaction replay failed: ${err instanceof Error ? err.message : String(err)}\n`;
+}
 /**
  * Hook protocol. HQ_LANE_ID absent or empty → exit 0, empty stdout, empty stderr.
  * That no-op is load-bearing: this hook is registered in the grok home and runs
  * on every session on the box.
  */
-export function runDrainHook(env) {
+export async function runDrainHook(env, input = {}, deps = {}) {
     const laneId = env.HQ_LANE_ID ?? "";
     if (laneId === "") {
         return { exitCode: 0, stdout: "", stderr: "" };
@@ -382,10 +485,81 @@ export function runDrainHook(env) {
         stderr += `hq-lanes-drain: failed to record tool activity: ${err instanceof Error ? err.message : String(err)}\n`;
     }
     try {
-        const messages = drainDropbox(hqRoot, laneId);
-        if (messages.length === 0) {
-            return { exitCode: 0, stdout: "", stderr };
+        const turnId = env.HQ_LANE_TURN_ID ?? "";
+        const validTurnId = /^[A-Za-z0-9-]{1,80}$/.test(turnId);
+        const messages = drainDropbox(hqRoot, laneId, {
+            ...(validTurnId ? { archivePrefix: `${turnId}.` } : {}),
+        });
+        let replayed;
+        let replayNote;
+        if (validTurnId) {
+            try {
+                const statePath = replayStatePath(hqRoot, laneId);
+                let state;
+                try {
+                    state = readReplayState(statePath, turnId);
+                }
+                catch (err) {
+                    if (err.code !== "ENOENT")
+                        throw err;
+                    throw new LanesError("message_replay_state_missing", `Replay state ${statePath} was not initialized for this provider turn`);
+                }
+                if (input.transcript_path) {
+                    const lane = (deps.readLane ?? tryReadLane)(hqRoot, laneId);
+                    if (!lane) {
+                        throw new LanesError("message_replay_lane_missing", `Lane ${laneId} could not be read for compaction replay`);
+                    }
+                    if (lane.provider === "grok") {
+                        state.last_compaction_marker = 0;
+                    }
+                    else {
+                        const transcriptPath = safeProviderTranscriptPath(input.transcript_path, lane.provider, env);
+                        if (state.last_compaction_marker === null ||
+                            state.transcript_path !== transcriptPath ||
+                            state.transcript_offset === undefined) {
+                            // Existing transcript history belongs to the turn's resume
+                            // prompt. Start watching only records appended from this point.
+                            state.last_compaction_marker = 0;
+                            state.transcript_path = transcriptPath;
+                            state.transcript_offset = providerTranscriptSize(transcriptPath);
+                        }
+                        else {
+                            const delta = (deps.probeCompactionsSince ?? probeProviderCompactionsSince)(transcriptPath, lane.provider, state.transcript_offset);
+                            state.transcript_offset = delta.next_offset;
+                            if (delta.replaced) {
+                                // A replaced or truncated transcript establishes a new
+                                // baseline; it is not evidence of a fresh compaction.
+                                state.last_compaction_marker = 0;
+                            }
+                            else if (delta.count > 0) {
+                                state.last_compaction_marker += delta.count;
+                                const flagEnabled = await (deps.readFlag ?? readLanesRegistryFlag)(LANE_MESSAGE_COMPACTION_REPLAY_FLAG, { company: lane.company, env });
+                                if (flagEnabled) {
+                                    replayed = deliveredMessagesForTurn(hqRoot, laneId, turnId);
+                                    if (replayed.length > 0)
+                                        replayNote = MESSAGE_COMPACTION_REPLAY_NOTE;
+                                }
+                            }
+                        }
+                    }
+                }
+                writeReplayState(statePath, state);
+            }
+            catch (err) {
+                // Replay is advisory hook context. Report failures but let the provider
+                // tool call continue with whatever the ordinary inbox drain delivered.
+                stderr += reportReplayFailure(err);
+            }
         }
+        if (replayNote && replayed && replayed.length > 0) {
+            return {
+                exitCode: 0,
+                stdout: hookAdditionalContextJson(replayed, "PreToolUse", replayNote),
+                stderr,
+            };
+        }
+        if (messages.length === 0)
+            return { exitCode: 0, stdout: "", stderr };
         return { exitCode: 0, stdout: hookAdditionalContextJson(messages), stderr };
     }
     catch (err) {

package/dist/lib/lanes/hooks-install.d.ts

@@ -20,6 +20,7 @@
 import type { LaneProvider } from "./types.js";
 export declare const DRAIN_HOOK_BASENAME = "hq-lanes-drain";
 export declare const DRAIN_HOOK_TIMEOUT_SECONDS = 30;
+export declare function drainHookEntryPath(): string;
 export declare function lanesHookAssetsDir(): string;
 export declare const DRAIN_HOOK_REGISTRATION_KINDS: readonly ["hooks_dir", "settings_json", "config_toml"];
 export type DrainHookRegistrationKind = (typeof DRAIN_HOOK_REGISTRATION_KINDS)[number];
@@ -40,7 +41,7 @@ export interface DrainHookInstallResult {
     files: string[];
     registration: DrainHookRegistration;
 }
-export declare function drainHookCommand(shPath: string): string;
+export declare function drainHookCommand(_shPath?: string): string;
 export declare function drainHookShPath(providerHome: string): string;
 export declare function renderDrainHookJson(shPath: string): string;
 export interface MergeResult {
@@ -53,7 +54,7 @@ export interface MergeResult {
  * and do nothing when a command hook with this exact command string is
  * already in the list. No `matcher` means every tool call.
  */
-export declare function mergeClaudeSettingsHook(existingText: string | null, command: string, settingsPath: string): MergeResult;
+export declare function mergeClaudeSettingsHook(existingText: string | null, command: string, settingsPath: string, legacyCommand?: string): MergeResult;
 /**
  * Codex: hooks come from `config.toml` in the codex home. The drain is
  * appended as one `[[hooks.PreToolUse]]` table and `[features] hooks = true`
@@ -61,7 +62,7 @@ export declare function mergeClaudeSettingsHook(existingText: string | null, com
  * byte for byte; the result is re-parsed and must contain the registration,
  * otherwise nothing is written.
  */
-export declare function mergeCodexConfigHook(existingText: string | null, command: string, configPath: string): MergeResult;
+export declare function mergeCodexConfigHook(existingText: string | null, command: string, configPath: string, legacyCommand?: string): MergeResult;
 export declare function drainHookRegistrationPath(provider: LaneProvider, providerHome: string): string;
 export interface DrainHookRegistrationProbe {
     kind: DrainHookRegistrationKind;

package/dist/lib/lanes/hooks-install.js

@@ -25,6 +25,12 @@ import { LanesError } from "./errors.js";
 import { parseLaneProvider } from "./types.js";
 export const DRAIN_HOOK_BASENAME = "hq-lanes-drain";
 export const DRAIN_HOOK_TIMEOUT_SECONDS = 30;
+function shellQuote(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
+export function drainHookEntryPath() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../dist/lanes-drain-hook.js");
+}
 export function lanesHookAssetsDir() {
     return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../assets/lanes-hooks");
 }
@@ -38,7 +44,10 @@ export const PROVIDER_REGISTRATION_KIND = {
     codex: "config_toml",
     grok: "hooks_dir",
 };
-export function drainHookCommand(shPath) {
+export function drainHookCommand(_shPath) {
+    return `${shellQuote(process.execPath)} ${shellQuote(drainHookEntryPath())}`;
+}
+function legacyDrainHookCommand(shPath) {
     return `bash ${shPath}`;
 }
 export function drainHookShPath(providerHome) {
@@ -87,6 +96,21 @@ function groupsContainCommand(groups, command) {
         return group.hooks.some((hook) => isPlainObject(hook) && hook.type === "command" && hook.command === command);
     });
 }
+function removeCommandFromGroups(groups, command) {
+    let changed = false;
+    const next = groups.flatMap((group) => {
+        if (!isPlainObject(group) || !Array.isArray(group.hooks))
+            return [group];
+        const hooks = group.hooks.filter((hook) => !(isPlainObject(hook) &&
+            hook.type === "command" &&
+            hook.command === command));
+        if (hooks.length === group.hooks.length)
+            return [group];
+        changed = true;
+        return hooks.length === 0 ? [] : [{ ...group, hooks }];
+    });
+    return { groups: next, changed };
+}
 export function renderDrainHookJson(shPath) {
     return `${JSON.stringify({
         hooks: {
@@ -110,7 +134,7 @@ export function renderDrainHookJson(shPath) {
  * and do nothing when a command hook with this exact command string is
  * already in the list. No `matcher` means every tool call.
  */
-export function mergeClaudeSettingsHook(existingText, command, settingsPath) {
+export function mergeClaudeSettingsHook(existingText, command, settingsPath, legacyCommand) {
     let root = {};
     if (existingText !== null && existingText.trim() !== "") {
         try {
@@ -131,17 +155,22 @@ export function mergeClaudeSettingsHook(existingText, command, settingsPath) {
     if (!Array.isArray(pre)) {
         throw new LanesError("settings_unparseable", `${settingsPath} has a non-array "hooks.PreToolUse"; refusing to rewrite it`, { path: settingsPath });
     }
-    if (groupsContainCommand(pre, command)) {
+    const migration = legacyCommand && legacyCommand !== command
+        ? removeCommandFromGroups(pre, legacyCommand)
+        : { groups: pre, changed: false };
+    if (groupsContainCommand(migration.groups, command) && !migration.changed) {
         return { text: existingText ?? "", changed: false };
     }
-    const nextPre = [
-        ...pre,
-        {
-            hooks: [
-                { type: "command", command, timeout: DRAIN_HOOK_TIMEOUT_SECONDS },
-            ],
-        },
-    ];
+    const nextPre = groupsContainCommand(migration.groups, command)
+        ? migration.groups
+        : [
+            ...migration.groups,
+            {
+                hooks: [
+                    { type: "command", command, timeout: DRAIN_HOOK_TIMEOUT_SECONDS },
+                ],
+            },
+        ];
     const nextRoot = { ...root, hooks: { ...hooks, PreToolUse: nextPre } };
     return { text: `${JSON.stringify(nextRoot, null, 2)}\n`, changed: true };
 }
@@ -156,6 +185,127 @@ function tomlHooksFeatureEnabled(parsed) {
 function tomlHasCommand(parsed, command) {
     return isPlainObject(parsed.hooks) && groupsContainCommand(parsed.hooks.PreToolUse, command);
 }
+function tomlHeader(line) {
+    const match = /^\s*(\[\[|\[)([^\]]+)(\]\]|\])\s*(?:#.*)?$/.exec(line);
+    if (!match) {
+        const trimmed = line.trimStart();
+        return trimmed.startsWith("[")
+            ? { path: "", array: trimmed.startsWith("[[") }
+            : undefined;
+    }
+    const array = match[1] === "[[";
+    if ((array && match[3] !== "]]") ||
+        (!array && match[3] !== "]")) {
+        return { path: "", array };
+    }
+    return { path: match[2].trim(), array };
+}
+function tomlCommandValue(line) {
+    const match = /^\s*command\s*=\s*(.+)$/.exec(line);
+    if (!match)
+        return undefined;
+    try {
+        const parsed = parseToml(`command = ${match[1]}\n`);
+        return isPlainObject(parsed) && typeof parsed.command === "string"
+            ? parsed.command
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Remove old installer-created Codex command tables while retaining TOML text and operator hooks. */
+function removeLegacyCodexHook(text, parsed, legacyCommand, configPath) {
+    if (!legacyCommand || legacyCommand === "")
+        return { text, changed: false };
+    const hooks = isPlainObject(parsed.hooks) ? parsed.hooks.PreToolUse : undefined;
+    const groups = Array.isArray(hooks) ? hooks : [];
+    const expectedCount = groups.reduce((total, group) => {
+        if (!isPlainObject(group) || !Array.isArray(group.hooks))
+            return total;
+        return total + group.hooks.filter((hook) => isPlainObject(hook) &&
+            hook.type === "command" &&
+            hook.command === legacyCommand).length;
+    }, 0);
+    if (expectedCount === 0)
+        return { text, changed: false };
+    const lines = text.split("\n");
+    const parentHeaders = lines.flatMap((line, index) => {
+        const header = tomlHeader(line);
+        return header?.array && header.path === "hooks.PreToolUse" ? [index] : [];
+    });
+    const wholeGroupIndexes = new Set();
+    if (parentHeaders.length === groups.length) {
+        groups.forEach((group, index) => {
+            if (isPlainObject(group) &&
+                Array.isArray(group.hooks) &&
+                group.hooks.length === 1 &&
+                isPlainObject(group.hooks[0]) &&
+                group.hooks[0].type === "command" &&
+                group.hooks[0].command === legacyCommand) {
+                wholeGroupIndexes.add(index);
+            }
+        });
+    }
+    const spans = [];
+    let parentGroupIndex = -1;
+    for (let index = 0; index < lines.length; index += 1) {
+        const header = tomlHeader(lines[index]);
+        if (header?.array && header.path === "hooks.PreToolUse") {
+            parentGroupIndex += 1;
+            if (!wholeGroupIndexes.has(parentGroupIndex))
+                continue;
+            let end = index + 1;
+            for (; end < lines.length; end += 1) {
+                const nextHeader = tomlHeader(lines[end]);
+                if (!nextHeader)
+                    continue;
+                if (nextHeader.array && nextHeader.path === "hooks.PreToolUse")
+                    break;
+                if (nextHeader.path.startsWith("hooks.PreToolUse."))
+                    continue;
+                break;
+            }
+            spans.push({ start: index, end });
+            index = end - 1;
+            continue;
+        }
+        if (!header?.array || header.path !== "hooks.PreToolUse.hooks")
+            continue;
+        let end = index + 1;
+        let foundLegacyCommand = false;
+        for (; end < lines.length; end += 1) {
+            const nextHeader = tomlHeader(lines[end]);
+            if (!nextHeader) {
+                if (tomlCommandValue(lines[end]) === legacyCommand) {
+                    foundLegacyCommand = true;
+                }
+                continue;
+            }
+            if (nextHeader.array &&
+                nextHeader.path === "hooks.PreToolUse.hooks") {
+                break;
+            }
+            if (nextHeader.path.startsWith("hooks.PreToolUse.hooks."))
+                continue;
+            break;
+        }
+        if (foundLegacyCommand)
+            spans.push({ start: index, end });
+        index = end - 1;
+    }
+    if (spans.length !== expectedCount) {
+        throw new LanesError("config_toml_migration_failed", `Could not safely remove all legacy lane drain hooks from ${configPath}; refusing to add a second drain`, { path: configPath, expected: expectedCount, found: spans.length });
+    }
+    for (const span of spans.reverse())
+        lines.splice(span.start, span.end - span.start);
+    const migrated = lines.join("\n");
+    const migratedConfig = parseTomlOrThrow(migrated, configPath, "after legacy hook removal");
+    if (tomlHasCommand(migratedConfig, legacyCommand)) {
+        throw new LanesError("config_toml_migration_failed", `Legacy lane drain hook remains in ${configPath}; refusing to add a second drain`, { path: configPath });
+    }
+    return { text: migrated, changed: true };
+}
 function parseTomlOrThrow(text, configPath, stage) {
     let parsed;
     try {
@@ -203,15 +353,18 @@ function enableTomlHooksFeature(text) {
  * byte for byte; the result is re-parsed and must contain the registration,
  * otherwise nothing is written.
  */
-export function mergeCodexConfigHook(existingText, command, configPath) {
+export function mergeCodexConfigHook(existingText, command, configPath, legacyCommand) {
     const original = existingText ?? "";
     const parsed = parseTomlOrThrow(original, configPath, "before merge");
-    const hasCommand = tomlHasCommand(parsed, command);
-    const featureOn = tomlHooksFeatureEnabled(parsed);
-    if (hasCommand && featureOn) {
+    const migration = removeLegacyCodexHook(original, parsed, legacyCommand, configPath);
+    const textAfterMigration = migration.text;
+    const current = parseTomlOrThrow(textAfterMigration, configPath, "after legacy hook removal");
+    const hasCommand = tomlHasCommand(current, command);
+    const featureOn = tomlHooksFeatureEnabled(current);
+    if (hasCommand && featureOn && !migration.changed) {
         return { text: original, changed: false };
     }
-    let text = original;
+    let text = textAfterMigration;
     if (!featureOn)
         text = enableTomlHooksFeature(text);
     if (!hasCommand) {
@@ -286,8 +439,8 @@ function registerDrainHook(provider, providerHome, shPath) {
     }
     const existing = readTextIfExists(regPath);
     const merged = kind === "settings_json"
-        ? mergeClaudeSettingsHook(existing, command, regPath)
-        : mergeCodexConfigHook(existing, command, regPath);
+        ? mergeClaudeSettingsHook(existing, command, regPath, legacyDrainHookCommand(shPath))
+        : mergeCodexConfigHook(existing, command, regPath, legacyDrainHookCommand(shPath));
     if (!merged.changed) {
         return { kind, path: regPath, command, changed: false };
     }

package/dist/lib/lanes/message-replay.d.ts

@@ -0,0 +1,14 @@
+export declare const LANE_MESSAGE_COMPACTION_REPLAY_FLAG = "lanes.message-compaction-replay";
+export declare const MESSAGE_REPLAY_STATE_NAME = "message-compaction-replay.json";
+export declare const MESSAGE_COMPACTION_REPLAY_NOTE = "These messages were delivered before a context compaction and still apply.";
+export interface MessageReplayState {
+    schema_version: 1;
+    turn_id: string;
+    /** Null until the provider transcript is first observed in this turn. */
+    last_compaction_marker: number | null;
+    /** Last complete JSONL byte offset scanned in the provider transcript. */
+    transcript_offset?: number;
+    /** Canonical transcript path for this provider turn. */
+    transcript_path?: string;
+}
+//# sourceMappingURL=message-replay.d.ts.map

package/dist/lib/lanes/message-replay.js

@@ -0,0 +1,4 @@
+export const LANE_MESSAGE_COMPACTION_REPLAY_FLAG = "lanes.message-compaction-replay";
+export const MESSAGE_REPLAY_STATE_NAME = "message-compaction-replay.json";
+export const MESSAGE_COMPACTION_REPLAY_NOTE = "These messages were delivered before a context compaction and still apply.";
+//# sourceMappingURL=message-replay.js.map

package/dist/lib/lanes/spawn.js

@@ -8,6 +8,7 @@
  * mutable fields are re-read from the lane record (spec §5.4).
  */
 import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -25,6 +26,7 @@ import { resolveMachineIdentity, } from "./machine-identity.js";
 import { appendCappedHistory, listLaneIds, readLane, retryUpdateLane } from "./store.js";
 import { copySessionFiles, planSessionCopy } from "./move-account.js";
 import { ensureSessionHome } from "./session-relink.js";
+import { MESSAGE_REPLAY_STATE_NAME } from "./message-replay.js";
 import { hasEarlierEligibleQueuedLane, laneAdmissionCapReason, withLaneAdmissionLock, } from "./admission.js";
 import { resolveAdmissionHost } from "./admission-host.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, ENVELOPE_INVALID_REASON, parseLaneProvider, } from "./types.js";
@@ -1750,6 +1752,8 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         ? providerAutoCompactTokens(config.providers.claude)
         : undefined;
     const childEnv = workerEnv(env, { envVar: resolved.envVar, home: resolved.home }, lane.lane_id, hqRoot, autoCompactTokens, lane.mesh_company ?? lane.company ?? undefined, workerPolicyDir);
+    const laneTurnId = randomUUID();
+    childEnv.HQ_LANE_TURN_ID = laneTurnId;
     const model = resolveLaneModel({
         cliModel: pinnedModel,
         profileModel,
@@ -2014,6 +2018,30 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         }
         return laneLaunchResult(claimedRecord);
     }
+    // Each normal spawn/resume starts a fresh provider turn. The resume prompt
+    // carries the prior message text, so only messages delivered after this
+    // reset may be replayed if the new turn compacts.
+    const replayStatePath = path.join(runDir, "dropbox", MESSAGE_REPLAY_STATE_NAME);
+    const replayStateTempPath = `${replayStatePath}.${process.pid}.${laneTurnId}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(replayStatePath), { recursive: true });
+        fs.writeFileSync(replayStateTempPath, `${JSON.stringify({
+            schema_version: 1,
+            turn_id: laneTurnId,
+            last_compaction_marker: null,
+        })}\n`, { mode: 0o600 });
+        fs.renameSync(replayStateTempPath, replayStatePath);
+    }
+    catch (err) {
+        try {
+            fs.rmSync(replayStateTempPath, { force: true });
+        }
+        catch (cleanupErr) {
+            process.stderr.write(`hq lanes: compaction replay state temp cleanup failed for ${lane.lane_id}: ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}\n`);
+        }
+        delete childEnv.HQ_LANE_TURN_ID;
+        process.stderr.write(`hq lanes: compaction replay disabled for ${lane.lane_id}; failed to reset turn state: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
     const workerOutPath = path.join(logsDir, "worker.out");
     const workerOutOffset = fileSizeOrZero(workerOutPath);
     let workerPid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.209.0",
+  "version": "5.210.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {