@indigoai-us/hq-cli 5.345.11 → 5.345.13

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/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

@@ -19,11 +19,6 @@ export declare const QUESTION_AGE_MS: number;
 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;
-export declare const RECONCILE_LOCK_STALE_MS = 30000;
-export declare const RECONCILE_LOCK_TIMEOUT_MS = 5000;
-/** A pickup probe that has not cleared its marker within this window is abandoned. */
-export declare const PICKUP_VALIDATION_MAX_AGE_MS: number;
-export declare const PICKUP_VALIDATION_TIMEOUT_REASON: "pickup_validation_timeout";
 export declare const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
 export declare const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";
 export declare const RECONCILE_TIMER_NAME = "hq-lanes-reconcile.timer";

package/dist/lib/lanes/reconcile.js

@@ -45,11 +45,11 @@ export const QUESTION_AGE_MS = 60 * 60 * 1000;
 export const MAX_AGED_ADVANCES = MAX_LANE_DEPTH - 1;
 /** Aligns with watcher silence: a host that has not reported for this long is dead. */
 export const DEAD_HOST_MS = SILENCE_MS;
-export const RECONCILE_LOCK_STALE_MS = 30_000;
-export const RECONCILE_LOCK_TIMEOUT_MS = 5_000;
+const RECONCILE_LOCK_STALE_MS = 30_000;
+const RECONCILE_LOCK_TIMEOUT_MS = 5_000;
 /** A pickup probe that has not cleared its marker within this window is abandoned. */
-export const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
-export const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
+const PICKUP_VALIDATION_MAX_AGE_MS = 15 * 60 * 1000;
+const PICKUP_VALIDATION_TIMEOUT_REASON = "pickup_validation_timeout";
 export const CLOSE_INTERRUPTED_DONE_STORY_WORKERS_FLAG = "lanes.close-interrupted-done-story-workers";
 const INTERRUPTED_DONE_STORY_MIN_AGE_MS = 24 * 60 * 60 * 1000;
 export const RECONCILE_UNIT_NAME = "hq-lanes-reconcile.service";

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

@@ -179,7 +179,7 @@ export declare const LANE_PROVIDERS: readonly ["claude", "codex", "grok"];
 export type LaneProvider = (typeof LANE_PROVIDERS)[number];
 export declare const QUEUED_REASONS: readonly ["cap", "provider_cap", "account_cap", "profile_cap", "queue_position", "throttle", "provider_binary_missing", "account_retry", "lead_reserve", "worker_profile_changed", "low_disk", "admit_failed"];
 export type QueuedReason = (typeof QUEUED_REASONS)[number];
-export type QueuedDetails = {
+type QueuedDetails = {
     reason: "worker_profile_changed";
     expected_hash: string | null;
     actual_hash: string;
@@ -308,7 +308,7 @@ export interface SeniorHistoryEntry {
     by: string;
     reason: string;
 }
-export interface LaneStopHistoryEntry {
+interface LaneStopHistoryEntry {
     at: string;
     reason: string;
 }
@@ -370,7 +370,7 @@ export interface AttributionHistoryEntry {
     at: string;
     story_switch_unacknowledged?: StorySwitchUnacknowledgedNote;
 }
-export interface StorySwitchPending {
+interface StorySwitchPending {
     previous_project_id: string;
     previous_story_id: string;
     project_id: string;
@@ -416,7 +416,7 @@ export interface ManagerStatusGateHistoryEntry {
     resume_queued?: boolean;
     resume_skipped_reason?: "open_question" | "blocked" | "miss_limit" | "no_provider_session";
 }
-export interface BlockerFreshnessState {
+interface BlockerFreshnessState {
     /** Stable hashes of the stale blocker labels seen at the last completed turn. */
     stale_keys: string[];
     stale_labels: string[];
@@ -440,7 +440,7 @@ export interface BlockerFreshnessHistoryEntry {
     reason?: string;
     delivery_recovered?: true;
 }
-export interface KrFreshnessState {
+interface KrFreshnessState {
     /** Stable fingerprint of the last stalled KPI set, which is resumed once. */
     stalled_fingerprint?: string;
 }
@@ -1044,4 +1044,5 @@ export interface LanesConfig {
 export declare function isIsoDateTime(value: string): boolean;
 export declare function parseMajorSchema(schemaVersion: string, expectedPrefix: string, expectedMajor: number): void;
 export declare function parseLaneEnvelope(raw: unknown): LaneEnvelope;
+export {};
 //# sourceMappingURL=types.d.ts.map

package/dist/utils/run-bundled-script.js

@@ -33,7 +33,7 @@ import { spawnSync } from "child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "path";
-import { resolveBundledAsset } from "./hq-roots.js";
+import { resolveBundledAsset } from "./hq-roots-core.js";
 /**
  * Which interpreter runs a bundled asset, chosen by extension.
  *

package/package.json

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