@indigoai-us/hq-cli 5.345.12 → 5.345.14

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## [Unreleased]
 
+## [5.345.14] — 2026-10-06
+- Route frequently called native core commands through isolated fast handlers.
+- Allow lane hierarchies up to four levels and include actionable senior-chain details when depth limits refuse a create or re-parent.
+
+## [5.345.13] — 2026-10-06
+- Stream provider transcript scans and account-move comparisons so large session files do not require whole-file reads.
+
 ## [5.345.12] — 2026-10-06
 - Route rebuild-index, pin, scheduled-job commands, and worker-skill lint through the fast CLI entry path to reduce command startup time.
 - `hq daemon` on desktop machines no longer starts a lane reconcile process every 15 seconds when no lane needs it. It checks the lane store first: live lanes, keep-alive lanes, pending resumes and pending questions keep the 15-second cadence; a store with only settled lanes is reconciled once a minute, as before 15-second polling; an HQ folder with no lanes, questions, lead registry or lanes config is not reconciled at all. Outposts and self-hosted machines are unchanged.

package/assets/scaffold/core/scripts/hq-delegate-grant.sh

@@ -65,11 +65,11 @@ done
 [ -f "$MANIFEST" ] || die "manifest not found: $MANIFEST"
 jq -e . "$MANIFEST" >/dev/null 2>&1 || die "manifest is not valid JSON: $MANIFEST"
 
-COMPANY="$(jq -r '.company // empty' "$MANIFEST")"
-PROJECT="$(jq -r '.project.name // empty' "$MANIFEST")"
-PRINCIPAL="$(jq -r '.to.principal // empty' "$MANIFEST")"
-DISPLAY="$(jq -r '.to.displayName // .to.principal // empty' "$MANIFEST")"
-STATUS="$(jq -r '.status // empty' "$MANIFEST")"
+COMPANY="$(jq -r '.company // empty' "$MANIFEST" | tr -d '\r')"
+PROJECT="$(jq -r '.project.name // empty' "$MANIFEST" | tr -d '\r')"
+PRINCIPAL="$(jq -r '.to.principal // empty' "$MANIFEST" | tr -d '\r')"
+DISPLAY="$(jq -r '.to.displayName // .to.principal // empty' "$MANIFEST" | tr -d '\r')"
+STATUS="$(jq -r '.status // empty' "$MANIFEST" | tr -d '\r')"
 [ -n "$COMPANY" ]   || die "manifest has no company"
 [ -n "$PROJECT" ]   || die "manifest has no project.name"
 [ -n "$PRINCIPAL" ] || die "manifest has no to.principal"
@@ -96,7 +96,7 @@ case "$PRINCIPAL" in
     TAIL="$(printf '%s' "$PRINCIPAL" | tail -c 9 | tr '[:upper:]' '[:lower:]')"
     LEGACY_GROUP="grp_dlg-$TAIL"
     NEXT_GROUP="$(agent_group_id "$PRINCIPAL")"
-    RECORDED_GROUP="$(jq -r '.grantPrincipal // empty' "$MANIFEST")"
+    RECORDED_GROUP="$(jq -r '.grantPrincipal // empty' "$MANIFEST" | tr -d '\r')"
     case "$RECORDED_GROUP" in
       "$LEGACY_GROUP"|"$NEXT_GROUP") GRANT_PRINCIPAL="$RECORDED_GROUP" ;;
       *) GRANT_PRINCIPAL="$NEXT_GROUP" ;;
@@ -109,7 +109,7 @@ case "$STATUS" in
   *) die "manifest status is '$STATUS' — grants run from 'building' (or re-run from 'granted'), not from there" ;;
 esac
 
-PREFIX_COUNT="$(jq '.vaultPrefixes | length' "$MANIFEST")"
+PREFIX_COUNT="$(jq '.vaultPrefixes | length' "$MANIFEST" | tr -d '\r')"
 [ "$PREFIX_COUNT" -gt 0 ] || die "manifest has no vaultPrefixes"
 
 # --- validate every prefix BEFORE touching anything --------------------------
@@ -118,7 +118,7 @@ PREFIX_COUNT="$(jq '.vaultPrefixes | length' "$MANIFEST")"
 # not exist in the bucket. Either is a hard error, never a silent grant.
 
 BAD="$(jq -r '.vaultPrefixes[] | .prefix
-  | select((endswith("/") | not) or startswith("companies/") or startswith("/"))' "$MANIFEST")"
+  | select((endswith("/") | not) or startswith("companies/") or startswith("/"))' "$MANIFEST" | tr -d '\r')"
 if [ -n "$BAD" ]; then
   die "prefix violates the hq-files prefix conventions (must be company-relative folder form ending in '/'): $BAD"
 fi
@@ -130,8 +130,8 @@ if [ "$GRANT_PRINCIPAL" != "$PRINCIPAL" ]; then
   echo "  0. Agent recipient: grants flow through group $GRANT_PRINCIPAL (created if absent, containing exactly $DISPLAY)"
 fi
 echo "  1. Push companies/$COMPANY/projects/$PROJECT/ to the vault (on-conflict keep)"
-jq -r '.vaultPrefixes[] | "  2. Grant \(.permission) on \(.prefix) — \(.reason // "")"' "$MANIFEST"
-WRITE_PREFIXES="$(jq -r '.vaultPrefixes[] | select(.permission == "write") | .prefix' "$MANIFEST")"
+jq -r '.vaultPrefixes[] | "  2. Grant \(.permission) on \(.prefix) — \(.reason // "")"' "$MANIFEST" | tr -d '\r'
+WRITE_PREFIXES="$(jq -r '.vaultPrefixes[] | select(.permission == "write") | .prefix' "$MANIFEST" | tr -d '\r')"
 if [ -n "$WRITE_PREFIXES" ]; then
   echo
   echo "NOTE: granting 'write' is a privilege escalation. The recipient will be able"
@@ -155,7 +155,7 @@ hq sync push "companies/$COMPANY/projects/$PROJECT/" --company "$COMPANY" --on-c
 
 jq -r --arg co "$COMPANY" \
   '((.knowledge // []) + (.policies // []))[] | select(startswith("companies/" + $co + "/"))' \
-  "$MANIFEST" | while IFS= read -r kpath; do
+  "$MANIFEST" | tr -d '\r' | while IFS= read -r kpath; do
   if [ -e "$HQ_ROOT/$kpath" ]; then
     hq sync push "$kpath" --company "$COMPANY" --on-conflict keep \
       || die "vault push failed for referenced knowledge: $kpath"
@@ -195,8 +195,8 @@ case "$GRANT_PRINCIPAL" in
     if printf '%s' "$RESOLVED" | jq -e '.status == "found" and (.person.personUid | type == "string") and (.person.companyUid | type == "string")' >/dev/null; then
       [ "$RESOLVE_RC" -eq 0 ] || die "recipient resolution failed"
       EXPECTED_TYPE=person
-      EXPECTED_ID="$(printf '%s' "$RESOLVED" | jq -r '.person.personUid')"
-      EXPECTED_COMPANY="$(printf '%s' "$RESOLVED" | jq -r '.person.companyUid')"
+      EXPECTED_ID="$(printf '%s' "$RESOLVED" | jq -r '.person.personUid' | tr -d '\r')"
+      EXPECTED_COMPANY="$(printf '%s' "$RESOLVED" | jq -r '.person.companyUid' | tr -d '\r')"
     elif printf '%s' "$RESOLVED" | jq -e '.status == "not_found"' >/dev/null; then
       case "$PRINCIPAL" in *@*) EXPECTED_TYPE=email; EXPECTED_ID="$(printf '%s' "$PRINCIPAL" | tr '[:upper:]' '[:lower:]' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')" ;; *) die "unresolved recipient" ;; esac
     else
@@ -223,15 +223,15 @@ read_acl() {
 NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 i=0
 while [ "$i" -lt "$PREFIX_COUNT" ]; do
-  PFX="$(jq -r ".vaultPrefixes[$i].prefix" "$MANIFEST")"
-  PERM="$(jq -r ".vaultPrefixes[$i].permission" "$MANIFEST")"
+  PFX="$(jq -r ".vaultPrefixes[$i].prefix" "$MANIFEST" | tr -d '\r')"
+  PERM="$(jq -r ".vaultPrefixes[$i].permission" "$MANIFEST" | tr -d '\r')"
   # Always address the recursive "folder/*" pattern explicitly. Since hq-pro
   # #3662 (2026-09-23) the server echoes the raw pattern back on read, and a
   # bare trailing "/" can mean a PRIVATE folder pattern when that flag is on.
   # A delegation grant is always the recursive share, never a private folder.
   ACL_PATTERN="${PFX}*"
   BEFORE="$(read_acl "$ACL_PATTERN")" || die "ACL preflight failed; no share attempted for $PFX"
-  EXPECTED_COMPANY="$(printf '%s' "$BEFORE" | jq -r '.companyUid')"
+  EXPECTED_COMPANY="$(printf '%s' "$BEFORE" | jq -r '.companyUid' | tr -d '\r')"
   SHARE_RC=0
   hq files share "$ACL_PATTERN" --with "$GRANT_PRINCIPAL" --permission "$PERM" --company "$COMPANY" || SHARE_RC=$?
   [ "$SHARE_RC" -eq 0 ] || echo "hq-delegate-grant: share reported an error on $PFX; checking exact grant" >&2

package/dist/commands/core-archive-old-threads-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runArchiveOldThreadsFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): number;
+//# sourceMappingURL=core-archive-old-threads-fast.d.ts.map

package/dist/commands/core-archive-old-threads-fast.js

@@ -0,0 +1,5 @@
+import { archiveOldThreads } from "../lib/core-utils/archive-old-threads.js";
+export function runArchiveOldThreadsFast(args, _stdin, _cwd, hqRoot) {
+    return archiveOldThreads([...args], { hqRoot });
+}
+//# sourceMappingURL=core-archive-old-threads-fast.js.map

package/dist/commands/core-codex-skill-bridge-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runCodexSkillBridgeFast(args: readonly string[], _stdin: string, _cwd: string, hqRoot: string | undefined): number;
+//# sourceMappingURL=core-codex-skill-bridge-fast.d.ts.map

package/dist/commands/core-codex-skill-bridge-fast.js

@@ -0,0 +1,5 @@
+import { runCodexSkillBridgeCommand } from "../lib/core-utils/codex-skill-bridge-entry.js";
+export function runCodexSkillBridgeFast(args, _stdin, _cwd, hqRoot) {
+    return runCodexSkillBridgeCommand([...args], { root: hqRoot });
+}
+//# sourceMappingURL=core-codex-skill-bridge-fast.js.map

package/dist/commands/core-delegate-w1b.js

@@ -7,7 +7,7 @@ import { serializeJqJson } from "../lib/core-utils/jq-json-serializer.js";
 import { shellDisplayPath } from "../lib/core-utils/shell-display-path.js";
 import { matchingSecretPatterns } from "../lib/core-utils/secret-patterns.js";
 import { describeCoreCommand } from "./core-command-catalog.js";
-import { commandExists, isRecord, jsonAt, jqFallback, jqRawPath, jqRawPaths, moveFile, readJsonFile, subprocess, writeJsonAtomically, } from "./core-delegate.js";
+import { commandExists, delegateDiagnosticPath, isRecord, jsonAt, jqFallback, jqRawPath, jqRawPaths, moveFile, readJsonFile, subprocess, writeJsonAtomically, } from "./core-delegate.js";
 import { resolveLiveRoot } from "../utils/hq-roots.js";
 import { ACL_SOURCE_DISPLAY_LABELS } from "../utils/files-browse-acl.js";
 import { runBundledScript } from "../utils/run-bundled-script.js";
@@ -179,11 +179,16 @@ function bashPath(value) {
     const drivePath = /^([A-Za-z]):\/(.*)$/u.exec(normalized);
     return drivePath ? `/${drivePath[1].toLowerCase()}/${drivePath[2]}` : normalized;
 }
+function shellFallbackArgs(args) {
+    if (process.platform !== "win32")
+        return args;
+    return args.map((arg, index) => args[index - 1] === "--manifest" && /^[a-z]:[\\/]/i.test(arg) ? bashPath(arg) : arg);
+}
 function runShellFallback(name, args, context) {
     const root = context.root ?? context.cwd;
     const result = runBundledScript({
         asset: ASSETS[name],
-        args,
+        args: shellFallbackArgs(args),
         cwd: context.cwd,
         hqRoot: bashPath(root),
         captureOutput: true,
@@ -404,16 +409,16 @@ function runGrant(args, context) {
     if (!manifestPath)
         return fail("grant", "--manifest is required");
     if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile())
-        return fail("grant", `manifest not found: ${shellDisplayPath(manifestPath)}`);
+        return fail("grant", `manifest not found: ${delegateDiagnosticPath(manifestPath)}`);
     let manifest;
     try {
         manifest = readJsonFile(manifestPath);
     }
     catch {
-        return fail("grant", `manifest is not valid JSON: ${shellDisplayPath(manifestPath)}`);
+        return fail("grant", `manifest is not valid JSON: ${delegateDiagnosticPath(manifestPath)}`);
     }
     if (manifest === null || manifest === false)
-        return fail("grant", `manifest is not valid JSON: ${shellDisplayPath(manifestPath)}`);
+        return fail("grant", `manifest is not valid JSON: ${delegateDiagnosticPath(manifestPath)}`);
     if (!isRecord(manifest))
         return fail("grant", "manifest has no company");
     const company = jqRawPath(manifest, "company");
@@ -790,10 +795,10 @@ function runSend(args, context) {
     if (!manifestPath)
         return fail("send", "--manifest is required");
     if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile())
-        return fail("send", `manifest not found: ${shellDisplayPath(manifestPath)}`);
+        return fail("send", `manifest not found: ${delegateDiagnosticPath(manifestPath)}`);
     const manifest = jsonFile(manifestPath);
     if (!manifest)
-        return fail("send", `manifest is not valid JSON: ${shellDisplayPath(manifestPath)}`);
+        return fail("send", `manifest is not valid JSON: ${delegateDiagnosticPath(manifestPath)}`);
     if (send) {
         const publishedPath = path.join(context.root ?? context.cwd, jqRawPath(manifest, "publication.manifestPath"));
         if (malformedJsonFile(publishedPath)) {
@@ -1047,12 +1052,12 @@ function runVerify(args, context) {
     if (!manifestPath)
         return fail("verify", "--manifest is required (or --dry-run with --company/--project/--to)");
     if (!fs.existsSync(manifestPath) || !fs.statSync(manifestPath).isFile())
-        return fail("verify", `manifest not found: ${shellDisplayPath(manifestPath)}`);
+        return fail("verify", `manifest not found: ${delegateDiagnosticPath(manifestPath)}`);
     if (malformedJsonFile(manifestPath))
         return runShellFallback("verify", args, context);
     const manifest = jsonFile(manifestPath);
     if (!manifest)
-        return fail("verify", `jq: error: ${shellDisplayPath(manifestPath)}: Invalid JSON`);
+        return fail("verify", `jq: error: ${delegateDiagnosticPath(manifestPath)}: Invalid JSON`);
     const lock = `${manifestPath}.send-lock`;
     try {
         fs.mkdirSync(lock);

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

@@ -40,6 +40,7 @@ export declare function jqRawPaths(value: unknown, dottedPaths: string[], fallba
 export declare function requireRecord(value: unknown, property: string): JsonRecord;
 export declare function moveFile(source: string, target: string): void;
 export declare function writeJsonAtomically(target: string, value: unknown, siblingTemp?: boolean): void;
+export declare function delegateDiagnosticPath(argument: string): string;
 /** Fast-entry adapter; family gating and shell fallback happen before import. */
 export declare function runDelegateFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined, commandName: string): number;
 /** Register the Wave 1a delegate commands and preserve the shell rollback path. */

package/dist/commands/core-delegate.js

@@ -188,6 +188,7 @@ export function moveFile(source, target) {
 }
 export function writeJsonAtomically(target, value, siblingTemp = false) {
     const serialized = serializeJqJson(value, "pretty");
+    // Native delegate JSON writers use LF on every platform.
     if (siblingTemp) {
         const temporary = `${target}.tmp`;
         fs.writeFileSync(temporary, serialized);
@@ -557,6 +558,13 @@ function parseStandard(name, args) {
     }
     return { values };
 }
+export function delegateDiagnosticPath(argument) {
+    // Git Bash receives drive-qualified native paths in MSYS spelling. Preserve
+    // relative and already-MSYS path arguments exactly as supplied.
+    if (process.platform === "win32" && /^[a-z]:[\\/]/i.test(argument))
+        return shellDisplayPath(argument);
+    return argument;
+}
 function existingManifest(name, args, context) {
     const prefix = `hq-delegate-${name}:`;
     const parsed = parseStandard(name, args);
@@ -575,11 +583,11 @@ function existingManifest(name, args, context) {
     }
     const file = path.resolve(context.cwd, manifestArg);
     if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
-        writeErr(`${prefix} manifest not found: ${shellDisplayPath(manifestArg)}\n`);
+        writeErr(`${prefix} manifest not found: ${delegateDiagnosticPath(manifestArg)}\n`);
         return { code: 1, parsed };
     }
     if (!jqValid(file)) {
-        writeErr(`${prefix} manifest is not valid JSON: ${shellDisplayPath(manifestArg)}\n`);
+        writeErr(`${prefix} manifest is not valid JSON: ${delegateDiagnosticPath(manifestArg)}\n`);
         return { code: 1, parsed };
     }
     return { file, parsed, document: readJsonFile(file) };

package/dist/commands/core-hq-status-summary-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runHqStatusSummaryFast(args: readonly string[], _stdin: string, cwd: string, _hqRoot: string | undefined, _commandName: string, hqRootArg: string | undefined): number | undefined;
+//# sourceMappingURL=core-hq-status-summary-fast.d.ts.map

package/dist/commands/core-hq-status-summary-fast.js

@@ -0,0 +1,11 @@
+import { summarizeHqStatus } from "../lib/core-utils/hq-status-summary.js";
+export function runHqStatusSummaryFast(args, _stdin, cwd, _hqRoot, _commandName, hqRootArg) {
+    // The full graph canonicalizes an explicit --hq-root through resolveLiveRoot.
+    // Keep that spelling on the authoritative path so the command graph can
+    // preserve its canonicalization and diagnostics. This adapter owns only the
+    // ordinary cwd-rooted invocation.
+    if (hqRootArg)
+        return undefined;
+    return summarizeHqStatus([...args], { cwd });
+}
+//# sourceMappingURL=core-hq-status-summary-fast.js.map

package/dist/commands/core-resize-screenshot-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runResizeScreenshotFast(args: readonly string[]): number;
+//# sourceMappingURL=core-resize-screenshot-fast.d.ts.map

package/dist/commands/core-resize-screenshot-fast.js

@@ -0,0 +1,5 @@
+import { resizeScreenshot } from "../lib/core-utils/resize-screenshot.js";
+export function runResizeScreenshotFast(args) {
+    return resizeScreenshot([...args]);
+}
+//# sourceMappingURL=core-resize-screenshot-fast.js.map

package/dist/commands/core-sentry-report-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runSentryReportFast(args: readonly string[], stdin: string, _cwd: string, hqRoot: string | undefined): Promise<number | undefined>;
+//# sourceMappingURL=core-sentry-report-fast.d.ts.map

package/dist/commands/core-sentry-report-fast.js

@@ -0,0 +1,33 @@
+import { reportSentryEvent } from "../lib/core-utils/sentry-report.js";
+export function runSentryReportFast(args, stdin, _cwd, hqRoot) {
+    let dryRun = false;
+    let timeoutMs;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (arg === "--timeout-ms") {
+            const value = args[index + 1];
+            if (value === undefined || value.startsWith("-"))
+                return Promise.resolve(undefined);
+            timeoutMs = Number(value);
+            index += 1;
+            continue;
+        }
+        if (arg?.startsWith("--timeout-ms=")) {
+            timeoutMs = Number(arg.slice("--timeout-ms=".length));
+            continue;
+        }
+        // Let Commander retain its authoritative diagnostics for forms this
+        // lightweight parser does not own. This branch emits no output.
+        return Promise.resolve(undefined);
+    }
+    // Live sends need main.ts's initialized Sentry transport. Keep those calls on
+    // the authoritative command graph; only side-effect-free validation is fast.
+    if (!dryRun)
+        return Promise.resolve(undefined);
+    return reportSentryEvent(stdin, { dryRun, timeoutMs, hqRoot }).then((result) => result.code);
+}
+//# sourceMappingURL=core-sentry-report-fast.js.map

package/dist/commands/core-soft-timeout-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runSoftTimeoutFast(args: readonly string[]): Promise<number>;
+//# sourceMappingURL=core-soft-timeout-fast.d.ts.map

package/dist/commands/core-soft-timeout-fast.js

@@ -0,0 +1,5 @@
+import { softTimeoutCommand } from "../lib/core-utils/soft-timeout.js";
+export function runSoftTimeoutFast(args) {
+    return softTimeoutCommand([...args]);
+}
+//# sourceMappingURL=core-soft-timeout-fast.js.map

package/dist/commands/core-token-usage-report-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runTokenUsageReportFast(args: readonly string[]): number;
+//# sourceMappingURL=core-token-usage-report-fast.d.ts.map

package/dist/commands/core-token-usage-report-fast.js

@@ -0,0 +1,5 @@
+import { tokenUsageReport } from "../lib/core-utils/token-usage-report.js";
+export function runTokenUsageReportFast(args) {
+    return tokenUsageReport([...args]);
+}
+//# sourceMappingURL=core-token-usage-report-fast.js.map

package/dist/commands/core-worktree-fast.d.ts

@@ -0,0 +1,2 @@
+export declare function runWorktreeFast(args: readonly string[], _stdin: string, cwd: string, hqRoot: string | undefined): number;
+//# sourceMappingURL=core-worktree-fast.d.ts.map

package/dist/commands/core-worktree-fast.js

@@ -0,0 +1,5 @@
+import { createWorktree } from "../lib/core-utils/worktree.js";
+export function runWorktreeFast(args, _stdin, cwd, hqRoot) {
+    return createWorktree([...args], { cwd: hqRoot ?? cwd, hqRoot });
+}
+//# sourceMappingURL=core-worktree-fast.js.map

package/dist/commands/lanes.js

@@ -2029,6 +2029,37 @@ function depthOfRef(hqRoot, ref, ctx, visited = new Set(), override) {
 function derivedLaneDepth(hqRoot, senior, ctx, override) {
     return depthOfRef(hqRoot, senior, ctx, new Set(), override) + 1;
 }
+function seniorLaneChain(hqRoot, ref, ctx, visited = new Set(), override) {
+    if (ref.kind === "user")
+        return [];
+    const key = seniorKey(ref);
+    if (visited.has(key)) {
+        throw new LanesError("senior_cycle", `Cycle in senior chain at ${key}`, { at: ref });
+    }
+    visited.add(key);
+    if (ref.kind === "session") {
+        if (!ref.id) {
+            throw new LanesError("invalid_senior_ref", "Session senior is missing an id", { senior: ref });
+        }
+        return seniorLaneChain(hqRoot, seniorOfSession(hqRoot, ref.id, ctx), ctx, visited, override);
+    }
+    if (!ref.id) {
+        throw new LanesError("invalid_senior_ref", "Lane senior is missing an id", { senior: ref });
+    }
+    const lane = readLane(hqRoot, ref.id);
+    const isOverridden = override?.laneId === lane.lane_id;
+    const senior = isOverridden ? override.senior : lane.senior;
+    const prefix = seniorLaneChain(hqRoot, senior, ctx, visited, override);
+    const depth = isOverridden ? override.depth : derivedLaneDepth(hqRoot, lane.senior, ctx, override);
+    return [...prefix, { lane_id: lane.lane_id, depth }];
+}
+function maxLaneDepthError(depth, chain, description, extraDetails = {}) {
+    const parentLane = [...chain].reverse().find((entry) => entry.depth < MAX_LANE_DEPTH);
+    const nextStep = parentLane
+        ? `Ask your senior lane ${parentLane.lane_id} to create this worker instead, or re-parent this lane under a shallower senior.`
+        : "Ask a shallower senior to create this lane, or re-parent it to a shallower senior.";
+    return new LanesError("max_lane_depth", `${description}: senior chain length ${depth} exceeds cap ${MAX_LANE_DEPTH}`, { ...extraDetails, depth, max: MAX_LANE_DEPTH, senior_chain: chain, next_step: nextStep });
+}
 function callerDepth(hqRoot, ctx) {
     const laneId = ctx.env.HQ_LANE_ID?.trim();
     if (laneId) {
@@ -3012,7 +3043,13 @@ async function runCreate(ctx, opts) {
     }
     const depth = callerDepth(hqRoot, ctx);
     if (depth >= MAX_LANE_DEPTH) {
-        throw new LanesError("max_lane_depth", `A depth-${depth} caller may not spawn lanes (cap ${MAX_LANE_DEPTH})`, { depth, max: MAX_LANE_DEPTH });
+        const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
+        const chain = callerLaneId
+            ? seniorLaneChain(hqRoot, { kind: "lane", id: callerLaneId }, ctx)
+            : seniorLaneChain(hqRoot, sessionIdFromEnv(ctx.env)
+                ? { kind: "session", id: sessionIdFromEnv(ctx.env) }
+                : { kind: "user" }, ctx);
+        throw maxLaneDepthError(depth + 1, chain, `A depth-${depth} caller may not spawn a depth-${depth + 1} lane`);
     }
     const senior = opts.senior ? parseSeniorRef(opts.senior) : defaultSenior(ctx);
     assertSeniorExists(hqRoot, senior, ctx);
@@ -3033,7 +3070,7 @@ async function runCreate(ctx, opts) {
     const hireGrant = requestedHireGrant ?? 0;
     const laneDepth = derivedLaneDepth(hqRoot, senior, ctx);
     if (laneDepth > MAX_LANE_DEPTH) {
-        throw new LanesError("max_lane_depth", `Lane depth ${laneDepth} exceeds cap ${MAX_LANE_DEPTH}`, { depth: laneDepth, max: MAX_LANE_DEPTH });
+        throw maxLaneDepthError(laneDepth, seniorLaneChain(hqRoot, senior, ctx), `Creating lane at depth ${laneDepth} is refused`);
     }
     // A no-company lane must not call company resolution (openMeshTransport).
     if (storyIds.length > 0 && ctx.storyLedgerEnabled()) {
@@ -7081,7 +7118,9 @@ function runReparentLocked(ctx, laneId, opts) {
     }
     const newDepth = derivedLaneDepth(hqRoot, nextSenior, ctx);
     if (newDepth > MAX_LANE_DEPTH) {
-        throw new LanesError("max_lane_depth", `Re-parent would put lane at depth ${newDepth} (cap ${MAX_LANE_DEPTH})`, { depth: newDepth, max: MAX_LANE_DEPTH });
+        const chain = seniorLaneChain(hqRoot, nextSenior, ctx);
+        chain.push({ lane_id: lane.lane_id, depth: newDepth });
+        throw maxLaneDepthError(newDepth, chain, `Re-parent would put lane at depth ${newDepth}`);
     }
     const pending = pendingQuestionsForLane(hqRoot, laneId);
     const oldDepth = derivedLaneDepth(hqRoot, lane.senior, ctx);
@@ -7099,7 +7138,9 @@ function runReparentLocked(ctx, laneId, opts) {
         const oldDescendantDepth = derivedLaneDepth(hqRoot, other.senior, ctx);
         const descendantDepth = derivedLaneDepth(hqRoot, other.senior, ctx, override);
         if (descendantDepth > MAX_LANE_DEPTH) {
-            throw new LanesError("max_lane_depth", `Re-parent would put descendant ${other.lane_id} at depth ${descendantDepth}`, { lane_id: other.lane_id, depth: descendantDepth, max: MAX_LANE_DEPTH });
+            const chain = seniorLaneChain(hqRoot, other.senior, ctx, new Set(), override);
+            chain.push({ lane_id: other.lane_id, depth: descendantDepth });
+            throw maxLaneDepthError(descendantDepth, chain, `Re-parent would put descendant ${other.lane_id} at depth ${descendantDepth}`, { lane_id: other.lane_id });
         }
         if (descendantDepth > oldDescendantDepth &&
             pendingQuestionsForLane(hqRoot, other.lane_id).length > 0) {

package/dist/fast-core.d.ts

@@ -7,7 +7,7 @@
  * module. The registration in `core.ts` remains the complete fallback path.
  */
 import { parseFastCore } from "./fast-scaffold.js";
-export declare function readStdinIfPiped(stream: NodeJS.ReadStream): Promise<string>;
+export declare function readStdinIfPiped(stream: NodeJS.ReadStream, maxBytes?: number): Promise<string>;
 /**
  * Run the fast-path core command named in `argv` and exit with its code.
  * Only call when {@link isFastCoreRequest} is true; a non-match returns without

package/dist/fast-core.js

@@ -14,12 +14,18 @@ const FAST_ROUTE_PROFILE_TOKEN = "hq-fast-route";
 function wantsFastRouteProfile(env) {
     return env.NODE_DEBUG === FAST_ROUTE_PROFILE_TOKEN;
 }
-export async function readStdinIfPiped(stream) {
+export async function readStdinIfPiped(stream, maxBytes) {
     if (stream.isTTY)
         return "";
     const chunks = [];
-    for await (const chunk of stream)
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    let bytesRead = 0;
+    for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytesRead += buffer.length;
+        if (maxBytes !== undefined && bytesRead > maxBytes)
+            return "";
+        chunks.push(buffer);
+    }
     return Buffer.concat(chunks).toString("utf8");
 }
 /**
@@ -105,7 +111,7 @@ export async function runFastCore(argv, parsed = parseFastCore(argv)) {
         handlerImportMs = profileElapsed(handlerImportStartedAt, profileMark());
         const stdinStartedAt = profileMark();
         const readsStdin = entry.readsStdinFor?.(parsed.args) ?? entry.readsStdin ?? false;
-        const stdin = readsStdin ? await readStdinIfPiped(process.stdin) : "";
+        const stdin = readsStdin ? await readStdinIfPiped(process.stdin, entry.kind === "native" ? entry.stdinMaxBytes : undefined) : "";
         stdinReadMs = profileElapsed(stdinStartedAt, profileMark());
         if (profile && profileStart !== undefined) {
             process.stderr.write(`HQ_FAST_ROUTE_PROFILE ${JSON.stringify({

package/dist/fast-scaffold.d.ts

@@ -42,6 +42,8 @@ export type FastScaffoldScript = {
     shellHqRoot?: "none" | "live" | "reconcile-default";
     /** Whether this handler consumes stdin. Shell companions inherit stdin directly. */
     readsStdin?: boolean;
+    /** Bound bytes buffered from stdin; overflow is treated as empty input. */
+    stdinMaxBytes?: number;
     /** Per-invocation stdin policy for handlers whose shell reads conditionally. */
     readsStdinFor?: (args: readonly string[]) => boolean;
     /** Whether the bundled fast-route module closure needs Node's network timeout patch. */
@@ -78,9 +80,10 @@ export declare function parseSecretsEnvFastRequest(argv: readonly string[]): Par
  * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
  * fast-path script. Returns null for anything else so the caller defers to the
  * full CLI. Mirrors the `core` group's single `--hq-root` option (both the
- * `--hq-root <path>` and `--hq-root=<path>` forms) and its `root: "live"`
- * binding; every remaining token is passed through untouched, exactly as the
- * commander registration does with allowUnknownOption + a variadic argument.
+ * `--hq-root <path>` and `--hq-root=<path>` forms) before the command name.
+ * Commander also accepts that parent option after a subcommand; those
+ * invocations are deferred because the fast parser cannot safely distinguish
+ * a parent option from a command's pass-through arguments.
  */
 export declare function parseFastCore(argv: readonly string[]): ParsedFastCore | null;
 /** Whether this invocation is a fast-path scaffold dispatch. */

package/dist/fast-scaffold.js

@@ -11,6 +11,101 @@
  */
 /** The relocated scripts that qualify for the entrypoint fast path. */
 export const FAST_SCAFFOLD_SCRIPTS = [
+    {
+        name: "sentry report",
+        kind: "native",
+        modulePath: "./commands/core-sentry-report-fast.js",
+        exportName: "runSentryReportFast",
+        flagKey: "hq-core-native-fast-route",
+        root: "live",
+        readsStdinFor: (args) => {
+            let dryRun = false;
+            for (let index = 0; index < args.length; index += 1) {
+                const arg = args[index];
+                if (arg === "--dry-run") {
+                    dryRun = true;
+                    continue;
+                }
+                if (arg === "--timeout-ms") {
+                    const value = args[index + 1];
+                    if (value === undefined || value.startsWith("-"))
+                        return false;
+                    index += 1;
+                    continue;
+                }
+                if (arg?.startsWith("--timeout-ms="))
+                    continue;
+                return false;
+            }
+            return dryRun;
+        },
+        stdinMaxBytes: 2_048,
+        requiresNodeNetworkCompatibility: true,
+        fallbackToCommandGraph: true,
+    },
+    {
+        name: "soft-timeout",
+        kind: "native",
+        modulePath: "./commands/core-soft-timeout-fast.js",
+        exportName: "runSoftTimeoutFast",
+        flagKey: "hq-core-native-fast-route",
+        root: "cwd",
+    },
+    {
+        name: "hq-status-summary",
+        kind: "native",
+        modulePath: "./commands/core-hq-status-summary-fast.js",
+        exportName: "runHqStatusSummaryFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/hq-status-summary.sh",
+        root: "cwd",
+        fallbackToCommandGraph: true,
+    },
+    {
+        name: "archive-old-threads",
+        kind: "native",
+        modulePath: "./commands/core-archive-old-threads-fast.js",
+        exportName: "runArchiveOldThreadsFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/archive-old-threads.sh",
+        root: "live",
+    },
+    {
+        name: "worktree",
+        kind: "native",
+        modulePath: "./commands/core-worktree-fast.js",
+        exportName: "runWorktreeFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/worktree.sh",
+        root: "live",
+    },
+    {
+        name: "token-usage-report",
+        kind: "native",
+        modulePath: "./commands/core-token-usage-report-fast.js",
+        exportName: "runTokenUsageReportFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/token-usage-report.sh",
+        root: "cwd",
+    },
+    {
+        name: "resize-screenshot",
+        kind: "native",
+        modulePath: "./commands/core-resize-screenshot-fast.js",
+        exportName: "runResizeScreenshotFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/resize-screenshot.sh",
+        root: "cwd",
+    },
+    {
+        name: "codex-skill-bridge",
+        kind: "native",
+        modulePath: "./commands/core-codex-skill-bridge-fast.js",
+        exportName: "runCodexSkillBridgeFast",
+        flagKey: "hq-core-native-fast-route",
+        asset: "core/scripts/codex-skill-bridge.sh",
+        root: "live",
+    },
     ...["notify", "probe", "remediate", "run"].map((name) => ({
         name: `job ${name}`,
         kind: "native",
@@ -454,9 +549,10 @@ export function parseSecretsEnvFastRequest(argv) {
  * Parse `hq core [--hq-root <path>] <name> [args...]` when `<name>` is a
  * fast-path script. Returns null for anything else so the caller defers to the
  * full CLI. Mirrors the `core` group's single `--hq-root` option (both the
- * `--hq-root <path>` and `--hq-root=<path>` forms) and its `root: "live"`
- * binding; every remaining token is passed through untouched, exactly as the
- * commander registration does with allowUnknownOption + a variadic argument.
+ * `--hq-root <path>` and `--hq-root=<path>` forms) before the command name.
+ * Commander also accepts that parent option after a subcommand; those
+ * invocations are deferred because the fast parser cannot safely distinguish
+ * a parent option from a command's pass-through arguments.
  */
 export function parseFastCore(argv) {
     // argv is process.argv: [node, hq, core, ...rest].
@@ -482,7 +578,10 @@ export function parseFastCore(argv) {
         .find((candidate) => candidate.name.split(" ").every((part, index) => commandArgs[index] === part));
     if (!entry)
         return null;
-    return { entry, hqRootArg, args: argv.slice(i + entry.name.split(" ").length) };
+    const routeArgs = argv.slice(i + entry.name.split(" ").length);
+    if (routeArgs.some((arg) => arg === "--hq-root" || arg.startsWith("--hq-root=")))
+        return null;
+    return { entry, hqRootArg, args: routeArgs };
 }
 /** Whether this invocation is a fast-path scaffold dispatch. */
 export function isFastCoreRequest(argv) {

package/dist/lib/core-utils/sentry-report.js

@@ -24,7 +24,6 @@ import { gte as semverGte, valid as validSemver } from "semver";
 import { CLI_VERSION } from "../../cli-version.js";
 import { beforeSend } from "../../sentry-before-send.js";
 import { resolveLiveRoot } from "../../utils/hq-roots.js";
-import { hookTimeoutDebugContextEnabled } from "./hook-timeout-debug-context-flag.js";
 const requireSentry = createRequire(import.meta.url);
 let sentryModule;
 function loadSentryModule() {
@@ -208,7 +207,14 @@ const defaultDependencies = {
     },
     stdout: process.stdout,
     stderr: process.stderr,
-    timeoutDebugContextEnabled: (signal) => hookTimeoutDebugContextEnabled({}, signal),
+    timeoutDebugContextEnabled: async (signal) => {
+        // This optional diagnostic gate is needed only for reports that carry
+        // hook-timeout debug context. Load it on demand so ordinary dry-run
+        // validation stays on the isolated fast route without importing the full
+        // flag registry.
+        const { hookTimeoutDebugContextEnabled } = await import("./hook-timeout-debug-context-flag.js");
+        return hookTimeoutDebugContextEnabled({}, signal);
+    },
 };
 /**
  * Read no more than the accepted event size. Returning early keeps a malformed

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

@@ -53,7 +53,7 @@ export interface ProviderCompactionDelta {
     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 probeProviderCompactionsSince(transcriptPath: string, provider: LaneProvider, startOffset: number, maxLineBytes?: number): ProviderCompactionDelta;
 export declare function providerTranscriptSize(transcriptPath: string): number;
 /**
  * Read only provider compaction markers from a lane transcript. Claude writes
@@ -64,7 +64,7 @@ export declare function probeProviderCompactions(transcriptPath: string | null,
 /** 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. */
-export declare function probeCompactBoundaries(transcriptPath: string | null): CompactBoundaryProbe;
+export declare function probeCompactBoundaries(transcriptPath: string | null, maxLineBytes?: number): CompactBoundaryProbe;
 interface CompactionCommandResult {
     status: number | null;
     error?: string;

package/dist/lib/lanes/compaction.js

@@ -49,10 +49,116 @@ export function compactionDue(lane, nowMs, thresholdMs) {
         threshold_ms: thresholdMs,
     };
 }
-function isProviderMarkerLine(line, lineNumber, transcriptPath, provider) {
+function readJsonStringAt(input, start) {
+    if (input[start] !== '"')
+        return null;
+    let index = start + 1;
+    while (index < input.length) {
+        if (input[index] === "\\") {
+            index += 2;
+            continue;
+        }
+        if (input[index] === '"') {
+            try {
+                return { value: JSON.parse(input.slice(start, index + 1)), end: index + 1 };
+            }
+            catch {
+                return null;
+            }
+        }
+        index += 1;
+    }
+    return null;
+}
+function skipJsonWhitespace(input, start) {
+    let index = start;
+    while (/\s/.test(input[index] ?? ""))
+        index += 1;
+    return index;
+}
+function skipJsonValue(input, start) {
+    const first = input[start];
+    if (first === '"')
+        return readJsonStringAt(input, start)?.end ?? null;
+    if (first !== "{" && first !== "[") {
+        let index = start;
+        while (index < input.length && input[index] !== "," && input[index] !== "}" && input[index] !== "]")
+            index += 1;
+        return index < input.length ? index : null;
+    }
+    const stack = [first === "{" ? "}" : "]"];
+    let index = start + 1;
+    while (index < input.length) {
+        const char = input[index];
+        if (char === '"') {
+            const parsed = readJsonStringAt(input, index);
+            if (!parsed)
+                return null;
+            index = parsed.end;
+            continue;
+        }
+        if (char === "{" || char === "[")
+            stack.push(char === "{" ? "}" : "]");
+        else if (char === "}" || char === "]") {
+            if (stack.pop() !== char)
+                return null;
+            if (stack.length === 0)
+                return index + 1;
+        }
+        index += 1;
+    }
+    return null;
+}
+/** Extract a top-level JSON value from a bounded prefix, even if its tail is truncated. */
+function topLevelJsonValue(input, targetKey) {
+    let index = skipJsonWhitespace(input, 0);
+    if (input[index++] !== "{")
+        return null;
+    while (index < input.length) {
+        index = skipJsonWhitespace(input, index);
+        if (input[index] === "}")
+            return null;
+        const key = readJsonStringAt(input, index);
+        if (!key)
+            return null;
+        index = skipJsonWhitespace(input, key.end);
+        if (input[index++] !== ":")
+            return null;
+        index = skipJsonWhitespace(input, index);
+        const end = skipJsonValue(input, index);
+        if (key.value === targetKey)
+            return end === null ? null : input.slice(index, end);
+        if (end === null)
+            return null;
+        index = skipJsonWhitespace(input, end);
+        if (input[index] === ",")
+            index += 1;
+        else
+            return null;
+    }
+    return null;
+}
+function topLevelString(input, targetKey) {
+    const raw = topLevelJsonValue(input, targetKey);
+    if (!raw?.startsWith('"'))
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function isProviderMarkerLine(line, lineNumber, transcriptPath, provider, oversized = false) {
     const needle = provider === "claude" ? "compact_boundary" : "compacted";
     if (!line.includes(needle))
         return false;
+    if (oversized) {
+        const type = topLevelString(line, "type");
+        const subtype = topLevelString(line, "subtype");
+        return (provider === "claude" && type === "system" && subtype === "compact_boundary") ||
+            (provider === "codex" && type === "compacted");
+    }
     let record;
     try {
         const parsed = JSON.parse(line);
@@ -67,25 +173,61 @@ function isProviderMarkerLine(line, lineNumber, transcriptPath, provider) {
     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 TRANSCRIPT_READ_CHUNK_BYTES = 1024 * 1024;
+const TRANSCRIPT_MAX_LINE_BYTES = 64 * 1024 * 1024;
+const TRANSCRIPT_OVERSIZED_PREFIX_BYTES = 64 * 1024;
+/** Read JSONL incrementally, retaining at most one bounded line plus one chunk. */
+function scanTranscriptLines(transcriptPath, startOffset, includeUnterminatedLast, onLine, maxLineBytes = TRANSCRIPT_MAX_LINE_BYTES) {
     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;
+        const fileSize = fs.fstatSync(fd).size;
+        if (startOffset > fileSize) {
+            return { file_size: fileSize, next_offset: fileSize, replaced: true };
+        }
         let position = startOffset;
-        let nextOffset = startOffset;
         let lineNumber = 0;
-        while (position < size) {
-            const chunk = Buffer.allocUnsafe(Math.min(chunkSize, size - position));
+        let lineParts = [];
+        let lineBytes = 0;
+        let skipLongLine = false;
+        let nextOffset = startOffset;
+        const appendPart = (part) => {
+            if (part.length === 0 || skipLongLine)
+                return;
+            lineBytes += part.length;
+            if (lineBytes > maxLineBytes) {
+                skipLongLine = true;
+                const prefix = Buffer.alloc(Math.min(TRANSCRIPT_OVERSIZED_PREFIX_BYTES, lineBytes));
+                let copied = 0;
+                for (const previous of lineParts) {
+                    const length = Math.min(previous.length, prefix.length - copied);
+                    if (length <= 0)
+                        break;
+                    previous.copy(prefix, copied, 0, length);
+                    copied += length;
+                }
+                const partLength = Math.min(part.length, prefix.length - copied);
+                if (partLength > 0)
+                    part.copy(prefix, copied, 0, partLength);
+                lineParts = prefix.length > 0 ? [prefix] : [];
+                lineBytes = prefix.length;
+                return;
+            }
+            lineParts.push(part);
+        };
+        const finishLine = (endOffset) => {
+            lineNumber += 1;
+            const recognizedMarker = onLine(Buffer.concat(lineParts, lineBytes).toString("utf8"), lineNumber, skipLongLine);
+            if (skipLongLine && recognizedMarker !== true) {
+                process.stderr.write(`hq lanes: skipped oversized transcript line ${lineNumber} in ${transcriptPath} (over ${maxLineBytes} bytes)\n`);
+            }
+            lineParts = [];
+            lineBytes = 0;
+            skipLongLine = false;
+            nextOffset = endOffset;
+        };
+        while (position < fileSize) {
+            const chunk = Buffer.allocUnsafe(Math.min(TRANSCRIPT_READ_CHUNK_BYTES, fileSize - position));
+            const chunkStart = position;
             const read = fs.readSync(fd, chunk, 0, chunk.length, position);
             if (read === 0)
                 break;
@@ -94,28 +236,34 @@ export function probeProviderCompactionsSince(transcriptPath, provider, startOff
             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;
+                appendPart(chunk.subarray(lineStart, index));
+                finishLine(chunkStart + index + 1);
                 lineStart = index + 1;
-                nextOffset = position - (read - lineStart);
             }
             if (lineStart < read)
-                lineParts.push(chunk.subarray(lineStart, read));
+                appendPart(chunk.subarray(lineStart, read));
         }
-        return {
-            count,
-            next_offset: nextOffset,
-            replaced: false,
-        };
+        if (includeUnterminatedLast && (lineBytes > 0 || skipLongLine))
+            finishLine(fileSize);
+        return { file_size: fileSize, next_offset: nextOffset, replaced: false };
     }
     finally {
         fs.closeSync(fd);
     }
 }
+/** Read newly appended, newline-complete marker records after a saved byte offset. */
+export function probeProviderCompactionsSince(transcriptPath, provider, startOffset, maxLineBytes = TRANSCRIPT_MAX_LINE_BYTES) {
+    if (provider === "grok")
+        return { count: 0, next_offset: startOffset, replaced: false };
+    let count = 0;
+    const scan = scanTranscriptLines(transcriptPath, startOffset, false, (line, lineNumber, oversized) => {
+        const marker = isProviderMarkerLine(line, lineNumber, transcriptPath, provider, oversized);
+        if (marker)
+            count += 1;
+        return marker;
+    }, maxLineBytes);
+    return { count, next_offset: scan.next_offset, replaced: scan.replaced };
+}
 export function providerTranscriptSize(transcriptPath) {
     try {
         return fs.statSync(transcriptPath).size;
@@ -166,39 +314,58 @@ export function findSessionTranscript(home, sessionId) {
     return null;
 }
 /** Count compact boundaries in a transcript. Other lines are never parsed. */
-export function probeCompactBoundaries(transcriptPath) {
+export function probeCompactBoundaries(transcriptPath, maxLineBytes = TRANSCRIPT_MAX_LINE_BYTES) {
     if (transcriptPath === null)
         return { count: 0, last_pre_tokens: null };
-    let text;
+    let count = 0;
+    let last = null;
     try {
-        text = fs.readFileSync(transcriptPath, "utf8");
+        scanTranscriptLines(transcriptPath, 0, true, (line, lineNumber, oversized) => {
+            if (oversized) {
+                const marker = topLevelString(line, "type") === "system" && topLevelString(line, "subtype") === "compact_boundary";
+                if (!marker)
+                    return false;
+                count += 1;
+                const rawMetadata = topLevelJsonValue(line, "compactMetadata");
+                if (rawMetadata) {
+                    try {
+                        const meta = JSON.parse(rawMetadata);
+                        const pre = meta.preTokens;
+                        last = typeof pre === "number" && Number.isFinite(pre) ? pre : null;
+                    }
+                    catch {
+                        last = null;
+                    }
+                }
+                else {
+                    last = null;
+                }
+                return true;
+            }
+            if (!line.includes('"compact_boundary"'))
+                return;
+            let rec;
+            try {
+                rec = JSON.parse(line);
+            }
+            catch (err) {
+                process.stderr.write(`hq lanes: skipped an unparseable line in ${transcriptPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+                return false;
+            }
+            if (rec.type !== "system" || rec.subtype !== "compact_boundary")
+                return false;
+            count += 1;
+            const meta = rec.compactMetadata;
+            const pre = meta?.preTokens;
+            last = typeof pre === "number" && Number.isFinite(pre) ? pre : null;
+            return true;
+        }, maxLineBytes);
     }
     catch (err) {
-        const code = err.code;
-        if (code === "ENOENT")
+        if (err.code === "ENOENT")
             return { count: 0, last_pre_tokens: null };
         throw err;
     }
-    let count = 0;
-    let last = null;
-    for (const line of text.split("\n")) {
-        if (!line.includes('"compact_boundary"'))
-            continue;
-        let rec;
-        try {
-            rec = JSON.parse(line);
-        }
-        catch (err) {
-            process.stderr.write(`hq lanes: skipped an unparseable line in ${transcriptPath}: ${err instanceof Error ? err.message : String(err)}\n`);
-            continue;
-        }
-        if (rec.type !== "system" || rec.subtype !== "compact_boundary")
-            continue;
-        count += 1;
-        const meta = rec.compactMetadata;
-        const pre = meta?.preTokens;
-        last = typeof pre === "number" && Number.isFinite(pre) ? pre : null;
-    }
     return { count, last_pre_tokens: last };
 }
 /** Synchronous `/compact`. stdout is discarded; stderr goes to the run dir. */

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

@@ -1,3 +1,3 @@
 /** Maximum number of lane levels below the user. */
-export declare const MAX_LANE_DEPTH = 3;
+export declare const MAX_LANE_DEPTH = 4;
 //# sourceMappingURL=constants.d.ts.map

package/dist/lib/lanes/constants.js

@@ -1,3 +1,3 @@
 /** Maximum number of lane levels below the user. */
-export const MAX_LANE_DEPTH = 3;
+export const MAX_LANE_DEPTH = 4;
 //# sourceMappingURL=constants.js.map

package/dist/lib/lanes/move-account.js

@@ -123,16 +123,39 @@ function refuseCredential(provider, file) {
     }
 }
 function sameContent(a, b) {
+    const chunkBytes = 1024 * 1024;
+    let aFd;
+    let bFd;
     try {
         const sa = fs.statSync(a);
         const sb = fs.statSync(b);
         if (sa.size !== sb.size)
             return false;
-        return fs.readFileSync(a).equals(fs.readFileSync(b));
+        aFd = fs.openSync(a, "r");
+        bFd = fs.openSync(b, "r");
+        const aChunk = Buffer.allocUnsafe(chunkBytes);
+        const bChunk = Buffer.allocUnsafe(chunkBytes);
+        let position = 0;
+        while (position < sa.size) {
+            const requested = Math.min(chunkBytes, sa.size - position);
+            const aRead = fs.readSync(aFd, aChunk, 0, requested, position);
+            const bRead = fs.readSync(bFd, bChunk, 0, requested, position);
+            if (aRead !== requested || bRead !== requested || !aChunk.subarray(0, aRead).equals(bChunk.subarray(0, bRead))) {
+                return false;
+            }
+            position += requested;
+        }
+        return true;
     }
     catch {
         return false;
     }
+    finally {
+        if (aFd !== undefined)
+            fs.closeSync(aFd);
+        if (bFd !== undefined)
+            fs.closeSync(bFd);
+    }
 }
 /**
  * Copy one file via a temp name and rename, so a partial copy is never a

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

@@ -15,7 +15,10 @@ import type { LaneCompanyRef, LaneAccountSelection, LaneRecord, LivenessState, Q
 import { type LaneMesh } from "./mesh-events.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
 export declare const QUESTION_AGE_MS: number;
-/** Spec §6.6 + §9: a depth-3 worker has two hops to age toward the user. */
+/**
+ * Questions can advance through a session and its senior lane separately at
+ * each lane level, so allow both routing hops per lane before reaching user.
+ */
 export declare const MAX_AGED_ADVANCES: number;
 /** Aligns with watcher silence: a host that has not reported for this long is dead. */
 export declare const DEAD_HOST_MS: number;

package/dist/lib/lanes/reconcile.js

@@ -41,8 +41,11 @@ import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from
 import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
 export const QUESTION_AGE_MS = 60 * 60 * 1000;
-/** Spec §6.6 + §9: a depth-3 worker has two hops to age toward the user. */
-export const MAX_AGED_ADVANCES = MAX_LANE_DEPTH - 1;
+/**
+ * Questions can advance through a session and its senior lane separately at
+ * each lane level, so allow both routing hops per lane before reaching user.
+ */
+export const MAX_AGED_ADVANCES = MAX_LANE_DEPTH * 2;
 /** Aligns with watcher silence: a host that has not reported for this long is dead. */
 export const DEAD_HOST_MS = SILENCE_MS;
 const RECONCILE_LOCK_STALE_MS = 30_000;

package/package.json

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