@indigoai-us/hq-cli 5.208.0 → 5.210.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [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
+
+- Behind the off-by-default `checkpoint.ontology.grok-backend` flag, `hq core checkpoint --backend auto` tries grok first for the payload company and falls back to the usual order when grok is missing or crashed last time. The detached ontology plan reads the flag and records it in the company state directory, so the foreground checkpoint makes no network call; a flag change applies from the checkpoint after the next plan.
+- Behind the off-by-default `checkpoint.ontology.ignore-annotations` flag, the checkpoint ontology plan gives the model a copy of each knowledge input without the old cloud annotator's `entities:` front-matter list and entity links, which were mostly wrong and which the model copied.
+
 ## [5.208.0] — 2026-09-26
 
 ### Fixed

package/dist/commands/core-checkpoint.d.ts

@@ -71,9 +71,17 @@ export declare function writeStamps(liveRoot: string, sessionId: string | undefi
  * claude session keeps using claude and a codex session keeps using codex
  * (same-engine continuity), then the fallback priority claude -> codex -> grok
  * for whatever the caller is not. Deterministic and env-only, so it is unit
- * tested directly.
+ * tested directly. `preferGrok` (the company's grok-backend flag) puts grok
+ * ahead of that order and leaves the rest as the fallback.
  */
-export declare function autoBackendPreference(): SpawnableBackend[];
+export declare function autoBackendPreference(preferGrok?: boolean): SpawnableBackend[];
+/**
+ * Whether the payload company's last ontology plan recorded
+ * checkpoint.ontology.grok-backend as on. Reads only the local state file the
+ * detached sibling writes, so a foreground checkpoint never waits on the flag
+ * registry; a flag change takes effect from the checkpoint after the next plan.
+ */
+export declare function companyPrefersGrok(liveRoot: string, companySlug: string | null | undefined): boolean;
 /**
  * Whether the maintenance sibling may run at all. The process environment wins
  * over the settings file, so a one-off `HQ_CHECKPOINT_AGENT=0 hq core

package/dist/commands/core-checkpoint.js

@@ -15,6 +15,8 @@ import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { peekIdToken } from "../utils/id-token.js";
 import { toHqStateWriteError } from "../utils/hq-state-write-error.js";
 import { checkpointStampWriteErrorFor, isCheckpointStampWriteError, } from "../utils/checkpoint-stamp-write-error.js";
+import { readBackendPreference } from "../lib/checkpoint-ontology/plan.js";
+import { resolveOntologyCompany } from "../lib/checkpoint-ontology/company.js";
 const DEFAULT_TRIGGER = "stop-gate";
 const BACKENDS = new Set(["auto", "claude", "codex", "grok", "none"]);
 // Pinned by operator directive 2026-09-15; change defaults here deliberately.
@@ -672,13 +674,34 @@ function callerBackend() {
  * claude session keeps using claude and a codex session keeps using codex
  * (same-engine continuity), then the fallback priority claude -> codex -> grok
  * for whatever the caller is not. Deterministic and env-only, so it is unit
- * tested directly.
+ * tested directly. `preferGrok` (the company's grok-backend flag) puts grok
+ * ahead of that order and leaves the rest as the fallback.
  */
-export function autoBackendPreference() {
+export function autoBackendPreference(preferGrok = false) {
     const caller = callerBackend();
-    if (!caller)
-        return [...FALLBACK_BACKEND_ORDER];
-    return [caller, ...FALLBACK_BACKEND_ORDER.filter((name) => name !== caller)];
+    const order = caller
+        ? [caller, ...FALLBACK_BACKEND_ORDER.filter((name) => name !== caller)]
+        : [...FALLBACK_BACKEND_ORDER];
+    return preferGrok ? ["grok", ...order.filter((name) => name !== "grok")] : order;
+}
+/**
+ * Whether the payload company's last ontology plan recorded
+ * checkpoint.ontology.grok-backend as on. Reads only the local state file the
+ * detached sibling writes, so a foreground checkpoint never waits on the flag
+ * registry; a flag change takes effect from the checkpoint after the next plan.
+ */
+export function companyPrefersGrok(liveRoot, companySlug) {
+    const resolved = resolveOntologyCompany(liveRoot, companySlug);
+    if (!resolved.ok)
+        return false;
+    try {
+        return readBackendPreference(liveRoot, resolved.company);
+    }
+    catch (error) {
+        // A damaged state file must not stop the checkpoint; the usual order applies.
+        printError(`checkpoint: ignoring unreadable backend preference for ${resolved.company.slug}: ${error.message}`);
+        return false;
+    }
 }
 function settingsEnvValue(liveRoot, key) {
     // settings.local.json wins, matching Claude Code's own merge order.
@@ -767,12 +790,12 @@ function assertKnownBackend(requested) {
         usage(`checkpoint: unknown backend: ${value}`);
     return value;
 }
-function resolveBackend(requested, liveRoot) {
+function resolveBackend(requested, liveRoot, company) {
     const value = assertKnownBackend(requested);
     // An explicitly named backend is honoured as given; only `auto` shops around.
     if (value !== "auto")
         return value;
-    const available = autoBackendPreference().filter((name) => backendOnPath(name) && backendResponds(name));
+    const available = autoBackendPreference(companyPrefersGrok(liveRoot, company)).filter((name) => backendOnPath(name) && backendResponds(name));
     if (available.length === 0)
         return "none";
     const crashed = crashedBackends(path.join(liveRoot, "workspace", "checkpoints", "sibling"));
@@ -1073,7 +1096,7 @@ function runCheckpoint(options, command, group) {
     const siblingOptOut = options.agent === false || !siblingEnabledBySetting(liveRoot);
     // Validated even when nothing will spawn, so `--backend bogus` is still an error.
     const requestedBackend = assertKnownBackend(options.backend);
-    const backend = siblingOptOut ? "none" : resolveBackend(requestedBackend, liveRoot);
+    const backend = siblingOptOut ? "none" : resolveBackend(requestedBackend, liveRoot, input.company);
     const now = new Date();
     const threadId = `T-${formatTimestamp(now)}-auto-${summarySlug(input.summary)}`;
     const threadPath = path.join(liveRoot, "workspace", "threads", `${threadId}.json`);

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/checkpoint-ontology/plan.d.ts

@@ -12,6 +12,13 @@ import { type OntologyCompany } from "./company.js";
 export declare const ONTOLOGY_FLAG = "checkpoint.ontology";
 export declare const SHARED_INPUTS_FLAG = "checkpoint.ontology.shared-inputs";
 export declare const COMPANY_BRIEF_FLAG = "checkpoint.ontology.company-brief";
+export declare const IGNORE_ANNOTATIONS_FLAG = "checkpoint.ontology.ignore-annotations";
+/**
+ * With `--backend auto`, `hq core checkpoint` tries grok first for this
+ * company. Read here, in the detached sibling, and recorded in the company's
+ * state directory, so the foreground checkpoint makes no network call.
+ */
+export declare const GROK_BACKEND_FLAG = "checkpoint.ontology.grok-backend";
 export declare const PLAN_FILE = "ontology-plan.json";
 export declare const CANDIDATES_FILE = "ontology-candidates.json";
 export declare const REPORT_FILE = "ontology-report.json";
@@ -59,6 +66,8 @@ export interface PlanInput {
     } | null;
     /** For signals: `entity_refs` items with no entity file yet. */
     missing_refs?: string[];
+    /** Run-directory-relative copy of `path` with annotator entity lists removed; same line numbers. */
+    read_path?: string;
 }
 export interface OntologyPlan {
     schema: typeof PLAN_SCHEMA;
@@ -112,9 +121,13 @@ export type PlanOutcome = {
     planPath: string;
     companyBrief?: CompanyBriefResult;
 };
+export declare const READ_PATH_INSTRUCTION = "When an input has read_path, read that file (relative to the run directory) instead of path, with the same line range. It is the same text with an older annotator's entity lists and entity links removed.";
 export declare function ledgerPath(hqRoot: string, company: OntologyCompany): string;
 export declare function readLedger(hqRoot: string, company: OntologyCompany): Ledger | null;
 export declare function writeLedger(hqRoot: string, company: OntologyCompany, ledger: Ledger): void;
+export declare function backendPreferencePath(hqRoot: string, company: OntologyCompany): string;
+/** The grok-backend flag value the last plan recorded; false when no plan has recorded one. */
+export declare function readBackendPreference(hqRoot: string, company: OntologyCompany): boolean;
 /** Company-relative paths of the payload's touched files that are inside this company. */
 export declare function sessionTouched(hqRoot: string, company: OntologyCompany, files: unknown): Set<string>;
 /** 1-based line ranges, each at most `chunkTokens` tokens (bytes / 4). */
@@ -130,4 +143,13 @@ export declare function refreshLedger(company: OntologyCompany, existing: Ledger
 };
 /** Plan this run. Never throws for a skip; returns the reason instead. */
 export declare function planOntologyRun(options: PlanOptions): Promise<PlanOutcome>;
+/**
+ * The cloud annotator wrote an `entities:` list into knowledge front matter and
+ * `[[ontology/entities/...]]` links into the text. Most are wrong, and a model
+ * told to ignore them still copies them (design section 18), so the model reads
+ * a copy without them. The list's lines are blanked rather than removed so the
+ * plan's line ranges still hold; a link becomes its label, or its last path
+ * segment. Returns null when the text has neither.
+ */
+export declare function stripAnnotations(text: string): string | null;
 //# sourceMappingURL=plan.d.ts.map

package/dist/lib/checkpoint-ontology/plan.js

@@ -16,6 +16,13 @@ import { buildEntityIndex, listKnowledgeFiles, listSignalFiles, readSignal } fro
 export const ONTOLOGY_FLAG = "checkpoint.ontology";
 export const SHARED_INPUTS_FLAG = "checkpoint.ontology.shared-inputs";
 export const COMPANY_BRIEF_FLAG = "checkpoint.ontology.company-brief";
+export const IGNORE_ANNOTATIONS_FLAG = "checkpoint.ontology.ignore-annotations";
+/**
+ * With `--backend auto`, `hq core checkpoint` tries grok first for this
+ * company. Read here, in the detached sibling, and recorded in the company's
+ * state directory, so the foreground checkpoint makes no network call.
+ */
+export const GROK_BACKEND_FLAG = "checkpoint.ontology.grok-backend";
 export const PLAN_FILE = "ontology-plan.json";
 export const CANDIDATES_FILE = "ontology-candidates.json";
 export const REPORT_FILE = "ontology-report.json";
@@ -27,6 +34,7 @@ export const BUDGET = {
     maxTokens: 60_000,
     chunkTokens: 12_000,
 };
+export const READ_PATH_INSTRUCTION = "When an input has read_path, read that file (relative to the run directory) instead of path, with the same line range. It is the same text with an older annotator's entity lists and entity links removed.";
 const CANDIDATE_INSTRUCTIONS = [
     `Write ${CANDIDATES_FILE} in the run directory as {"schema":"${CANDIDATES_SCHEMA}","candidates":[...]} and nothing else.`,
     "Each candidate: {input, type, name, aliases, confidence, evidence}. input is one of this plan's input ids; type is person, project, company or concept; name is the entity's full proper name; aliases are other names the input uses for it (at most 5); confidence is 0 to 1; evidence is a short quote from the input.",
@@ -61,6 +69,26 @@ export function writeLedger(hqRoot, company, ledger) {
     const target = ledgerPath(hqRoot, company);
     safeWriteFile(hqRoot, [stateRoot(hqRoot, company)], target, `${JSON.stringify(ledger, null, 2)}\n`);
 }
+export function backendPreferencePath(hqRoot, company) {
+    return path.join(stateRoot(hqRoot, company), "backend.json");
+}
+/** The grok-backend flag value the last plan recorded; false when no plan has recorded one. */
+export function readBackendPreference(hqRoot, company) {
+    let raw;
+    try {
+        raw = fs.readFileSync(backendPreferencePath(hqRoot, company), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+    return JSON.parse(raw)?.prefer_grok === true;
+}
+function recordBackendPreference(hqRoot, company, preferGrok) {
+    const target = backendPreferencePath(hqRoot, company);
+    safeWriteFile(hqRoot, [stateRoot(hqRoot, company)], target, `${JSON.stringify({ prefer_grok: preferGrok })}\n`);
+}
 /** Company-relative paths of the payload's touched files that are inside this company. */
 export function sessionTouched(hqRoot, company, files) {
     const out = new Set();
@@ -172,13 +200,18 @@ export async function planOntologyRun(options) {
     if (!resolution.ok)
         return { status: "skipped", reason: resolution.reason };
     const company = resolution.company;
-    if (!(await options.readFlag(ONTOLOGY_FLAG, company)))
+    if (!(await options.readFlag(ONTOLOGY_FLAG, company))) {
+        // A preference recorded while the ontology was on must not outlive it.
+        fs.rmSync(backendPreferencePath(hqRoot, company), { force: true });
         return { status: "skipped", reason: "flag off" };
+    }
     const sharedInputs = await options.readFlag(SHARED_INPUTS_FLAG, company);
     // Before the ledger, so a nothing-changed plan still records the brief.
     const companyBrief = (await options.readFlag(COMPANY_BRIEF_FLAG, company))
         ? writeCompanyBrief(hqRoot, company, options.now ?? new Date())
         : undefined;
+    const ignoreAnnotations = await options.readFlag(IGNORE_ANNOTATIONS_FLAG, company);
+    recordBackendPreference(hqRoot, company, await options.readFlag(GROK_BACKEND_FLAG, company));
     const touched = sessionTouched(hqRoot, company, payload.files);
     const { ledger, firstRun } = refreshLedger(company, readLedger(hqRoot, company), touched, sharedInputs);
     const pending = Object.entries(ledger.entries)
@@ -192,9 +225,16 @@ export async function planOntologyRun(options) {
             remaining += 1;
             continue;
         }
-        const lines = fs.readFileSync(path.join(company.dir, rel), "utf8").split("\n");
+        const text = fs.readFileSync(path.join(company.dir, rel), "utf8");
+        const lines = text.split("\n");
         const chunks = chunkLines(lines.join("\n"), BUDGET.chunkTokens);
         const kind = rel.startsWith("signals/") ? "signal" : "knowledge";
+        const cleaned = ignoreAnnotations && kind === "knowledge" ? stripAnnotations(text) : null;
+        const readPath = cleaned === null ? null : path.join(READ_COPY_DIR, rel);
+        if (readPath !== null) {
+            fs.mkdirSync(path.dirname(path.join(runDir, readPath)), { recursive: true });
+            fs.writeFileSync(path.join(runDir, readPath), cleaned);
+        }
         let index = entry.next_chunk ?? 0;
         for (; index < chunks.length; index += 1) {
             const [start, end] = chunks[index];
@@ -212,6 +252,7 @@ export async function planOntologyRun(options) {
                 lines: chunks.length > 1 ? [start, end] : null,
                 chunk: chunks.length > 1 ? { index, count: chunks.length } : null,
                 ...(kind === "signal" ? { missing_refs: missingRefs(company.dir, rel) } : {}),
+                ...(readPath !== null ? { read_path: readPath } : {}),
             });
             tokens += cost;
         }
@@ -267,13 +308,47 @@ export async function planOntologyRun(options) {
             planned_tokens: tokens,
         },
         candidates_file: CANDIDATES_FILE,
-        instructions: CANDIDATE_INSTRUCTIONS,
+        instructions: inputs.some((input) => input.read_path)
+            ? [...CANDIDATE_INSTRUCTIONS.slice(0, 3), READ_PATH_INSTRUCTION, ...CANDIDATE_INSTRUCTIONS.slice(3)]
+            : CANDIDATE_INSTRUCTIONS,
     };
     fs.mkdirSync(runDir, { recursive: true });
     const planPath = path.join(runDir, PLAN_FILE);
     fs.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}\n`);
     return companyBrief ? { status: "planned", plan, planPath, companyBrief } : { status: "planned", plan, planPath };
 }
+const READ_COPY_DIR = "ontology-inputs";
+/**
+ * The cloud annotator wrote an `entities:` list into knowledge front matter and
+ * `[[ontology/entities/...]]` links into the text. Most are wrong, and a model
+ * told to ignore them still copies them (design section 18), so the model reads
+ * a copy without them. The list's lines are blanked rather than removed so the
+ * plan's line ranges still hold; a link becomes its label, or its last path
+ * segment. Returns null when the text has neither.
+ */
+export function stripAnnotations(text) {
+    let out = text;
+    const front = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+    if (front && /^entities:/m.test(front[1])) {
+        let inList = false;
+        const body = front[1]
+            .split("\n")
+            .map((line) => {
+            if (/^entities:/.test(line))
+                inList = true;
+            else if (inList && /^\S/.test(line))
+                inList = false;
+            return inList ? "" : line;
+        })
+            .join("\n");
+        const start = text.indexOf("\n") + 1;
+        out = text.slice(0, start) + body + text.slice(start + front[1].length);
+    }
+    out = out
+        .replace(/\[\[ontology\/entities\/[^\]|\n]*\|([^\]\n]*)\]\]/g, "$1")
+        .replace(/\[\[ontology\/entities\/(?:[^\]\n]*\/)?([^\]/\n]*)\]\]/g, "$1");
+    return out === text ? null : out;
+}
 const SESSION_TEXT_MAX_BYTES = 8_000;
 /** The session summary, decisions and learnings from the payload, capped. */
 function sessionContent(payload) {

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