@indigoai-us/hq-cli 5.209.0 → 5.211.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [5.211.0] — 2026-09-26
+
+### Fixed
+
+- Reconcile now applies `keep_alive` from a recorded worker profile to older
+  lanes whose lane field is unset. An explicit lane value wins, unreadable
+  profiles fail closed and are reported, and `lanes show --json` identifies
+  the source of its effective value.
+
+## [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/commands/lanes.js

@@ -38,6 +38,7 @@ import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
 import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
+import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
@@ -4489,6 +4490,15 @@ async function runShow(ctx, laneId) {
         ? { ...storedLane, state: "remote", remote_state: storedLane.state, queued_reason: undefined }
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
+    let keepAliveState;
+    try {
+        keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`hq lanes show: keep-alive profile could not be loaded for ${laneId}: ${message}\n`);
+        keepAliveState = { enabled: false, source: "none" };
+    }
     printJson({
         ok: true,
         action: "show",
@@ -4514,7 +4524,8 @@ async function runShow(ctx, laneId) {
         terminal_reason: lane.terminal_reason ?? null,
         terminal_details: lane.terminal_details ?? null,
         keep_alive_state: {
-            enabled: lane.keep_alive === true,
+            enabled: keepAliveState.enabled,
+            source: keepAliveState.source,
             consecutive_auto_resumes: lane.keep_alive_resume_count ?? 0,
             last_auto_resume_at: lane.keep_alive_last_resume_at ?? null,
             next_eligible_at: lane.keep_alive_next_eligible_at ?? null,

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/admission.js

@@ -137,8 +137,8 @@ export function hasActivePendingResume(lane, nowMs) {
         return false;
     if (lane.state === "queued" && pending.trigger === "answered_questions")
         return false;
+    // This timestamp tags automatic keep-alive resumes, including profile-derived ones.
     if (lane.state === "queued" &&
-        lane.keep_alive === true &&
         pending.trigger === "resume" &&
         pending.resumed_from === "done" &&
         lane.keep_alive_last_resume_at === pending.at)

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/profile.d.ts

@@ -6,7 +6,7 @@
  * and package trees; this module describes the provider launch contract that
  * must be re-read for every spawn.
  */
-import { type LaneProvider } from "./types.js";
+import { type LaneRecord, type LaneProvider } from "./types.js";
 export interface WorkerProfileMeta {
     version?: string;
     provider: LaneProvider;
@@ -37,6 +37,12 @@ export declare function personalWorkerProfileDir(hqRoot: string, id: string): st
 /** A meta.yaml file is the explicit marker for a personal worker profile. */
 export declare function workerProfileMarker(hqRoot: string, id: string): "absent" | "present";
 export declare function loadWorkerProfile(hqRoot: string, id: string): WorkerProfile;
+export interface EffectiveLaneKeepAlive {
+    enabled: boolean;
+    source: "lane" | "profile" | "none";
+}
+/** Resolve the keep-alive opt-in recorded on a lane or its attached profile. */
+export declare function resolveLaneKeepAlive(hqRoot: string, lane: Pick<LaneRecord, "keep_alive" | "worker_profile">): EffectiveLaneKeepAlive;
 export declare function workerProfilePrompt(profile: WorkerProfile, delivery?: "hook" | "prompt"): string;
 export declare function ignoredWorkerProfileFields(provider: LaneProvider): string[];
 /**

package/dist/lib/lanes/profile.js

@@ -370,6 +370,19 @@ export function loadWorkerProfile(hqRoot, id) {
         contentHash: hashProfileFiles(dir, hashFiles),
     };
 }
+/** Resolve the keep-alive opt-in recorded on a lane or its attached profile. */
+export function resolveLaneKeepAlive(hqRoot, lane) {
+    if (lane.keep_alive !== undefined) {
+        return { enabled: lane.keep_alive, source: "lane" };
+    }
+    if (lane.worker_profile === undefined) {
+        return { enabled: false, source: "none" };
+    }
+    const profileKeepAlive = loadWorkerProfile(hqRoot, lane.worker_profile).meta.keep_alive;
+    return profileKeepAlive === undefined
+        ? { enabled: false, source: "none" }
+        : { enabled: profileKeepAlive, source: "profile" };
+}
 export function workerProfilePrompt(profile, delivery = "prompt") {
     const parts = [profile.systemPrompt.trimEnd()];
     if (delivery === "hook")

package/dist/lib/lanes/reconcile.js

@@ -15,7 +15,7 @@ import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
 import { LANE_HIRE_GRANTS_FLAG, terminalChildResumeHireGrantError, withHireGrantAdmission, } from "./hire-grants.js";
-import { loadWorkerProfile } from "./profile.js";
+import { loadWorkerProfile, resolveLaneKeepAlive } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, unindexedClaudeSessionLiveness, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, envelopeRepairMode, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
@@ -801,7 +801,8 @@ export async function runPassBody(hqRoot, deps) {
     const keepAliveHireGrantFlagCompanies = new Map();
     for (const lane of lanes) {
         if (lane.state !== "done" ||
-            lane.keep_alive !== true ||
+            (lane.keep_alive !== true &&
+                !(lane.keep_alive === undefined && lane.worker_profile !== undefined)) ||
             !laneRunsHere(lane, deps.host) ||
             lane.terminal_reason === PROVIDER_REJECTED_REASON ||
             lane.terminal_reason === "account_not_logged_in" ||
@@ -1417,19 +1418,27 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
     const nowIso = now.toISOString();
     const config = loadLanesConfig(hqRoot);
     for (const lane of lanes) {
+        const hasRecordedProfileFallback = lane.keep_alive === undefined && lane.worker_profile !== undefined;
         if (lane.state !== "done" ||
-            lane.keep_alive !== true ||
+            lane.keep_alive === false ||
+            (lane.keep_alive !== true && !hasRecordedProfileFallback) ||
             !laneRunsHere(lane, deps.host))
             continue;
         const latest = readLatestEnvelopeRecord(hqRoot, lane.lane_id);
         const envelope = latest?.envelope;
         if (!envelope || envelope.decision !== "done")
             continue;
+        const keepAliveConfigurationUnchanged = (candidate) => lane.keep_alive === true
+            ? candidate.keep_alive === true
+            : lane.keep_alive === undefined &&
+                lane.worker_profile !== undefined &&
+                candidate.keep_alive === undefined &&
+                candidate.worker_profile === lane.worker_profile;
         if (envelope.story_complete === true) {
             if (hasKeepAliveProgress(lane)) {
                 casLaneIf(hqRoot, lane.lane_id, (current) => current.version === lane.version &&
                     current.state === "done" &&
-                    current.keep_alive === true, (current) => clearedKeepAliveProgress(current), deps.dryRun);
+                    keepAliveConfigurationUnchanged(current), (current) => clearedKeepAliveProgress(current), deps.dryRun);
             }
             continue;
         }
@@ -1440,10 +1449,31 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
             continue;
         if (flagByCompany.get(keepAliveCompanyKey(lane.company)) !== true)
             continue;
+        let keepAlive;
+        try {
+            keepAlive = resolveLaneKeepAlive(hqRoot, lane);
+        }
+        catch (err) {
+            const message = err instanceof LanesError
+                ? `${err.error}: ${err.message}`
+                : err instanceof Error ? err.message : String(err);
+            markDirty(summary, {
+                kind: "lane",
+                id: lane.lane_id,
+                why: `keep-alive worker profile could not be loaded: ${message}`,
+            });
+            continue;
+        }
+        if (!keepAlive.enabled)
+            continue;
+        const keepAliveStillEnabled = (candidate) => keepAlive.source === "lane"
+            ? candidate.keep_alive === true
+            : candidate.keep_alive === undefined &&
+                candidate.worker_profile === lane.worker_profile;
         const current = readLane(hqRoot, lane.lane_id);
         if (current.version !== lane.version ||
             current.state !== "done" ||
-            current.keep_alive !== true ||
+            !keepAliveStillEnabled(current) ||
             !laneRunsHere(current, deps.host))
             continue;
         const currentEnvelope = readLatestEnvelopeRecord(hqRoot, current.lane_id)?.envelope;
@@ -1453,7 +1483,7 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
             if (hasKeepAliveProgress(current)) {
                 casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
                     latestLane.state === "done" &&
-                    latestLane.keep_alive === true, (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
+                    keepAliveStillEnabled(latestLane), (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
             }
             continue;
         }
@@ -1470,7 +1500,7 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
                 continue;
             const exhausted = casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
                 latestLane.state === "done" &&
-                latestLane.keep_alive === true &&
+                keepAliveStillEnabled(latestLane) &&
                 (latestLane.keep_alive_resume_count ?? 0) >= LEAD_LANE_KEEP_ALIVE_MAX_RESUMES &&
                 latestLane.keep_alive_exhausted_at === undefined, (latestLane) => ({ ...latestLane, keep_alive_exhausted_at: nowIso }), deps.dryRun);
             if (exhausted.changed && !deps.dryRun) {
@@ -1495,7 +1525,7 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
             if (resetByHuman && hasKeepAliveProgress(current)) {
                 casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
                     latestLane.state === "done" &&
-                    latestLane.keep_alive === true, (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
+                    keepAliveStillEnabled(latestLane), (latestLane) => clearedKeepAliveProgress(latestLane), deps.dryRun);
             }
             continue;
         }
@@ -1515,7 +1545,7 @@ function resumeDoneKeepAlive(hqRoot, lanes, summary, deps, now, flagByCompany, h
         }
         const queue = (expectedSeniorId) => casLaneIf(hqRoot, current.lane_id, (latestLane) => latestLane.version === current.version &&
             latestLane.state === "done" &&
-            latestLane.keep_alive === true &&
+            keepAliveStillEnabled(latestLane) &&
             (expectedSeniorId === undefined ||
                 (latestLane.senior.kind === "lane" && latestLane.senior.id === expectedSeniorId)), (latestLane) => ({
             ...latestLane,

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.211.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {