@indigoai-us/hq-cli 5.345.55 → 5.345.57

package/dist/lib/lanes/store.js

@@ -537,6 +537,7 @@ export function parseLaneRecord(raw, filePath) {
         });
     }
     for (const field of [
+        "blocked_since",
         "keep_alive_opted_in_at",
         "keep_alive_last_resume_at",
         "keep_alive_next_eligible_at",
@@ -547,6 +548,24 @@ export function parseLaneRecord(raw, filePath) {
         if (raw[field] !== undefined)
             requireTimestamp(raw[field], field, filePath);
     }
+    if (raw.escalations !== undefined) {
+        if (!Array.isArray(raw.escalations)) {
+            throw new LaneSchemaError("escalations must be an array", { path: filePath, field: "escalations" });
+        }
+        for (const [index, value] of raw.escalations.entries()) {
+            const field = `escalations[${index}]`;
+            if (!isPlainObject(value) || Object.keys(value).some((key) => !["at", "to", "hours"].includes(key))) {
+                throw new LaneSchemaError(`${field} must contain only at, to, and hours`, { path: filePath, field });
+            }
+            requireTimestamp(value.at, `${field}.at`, filePath);
+            if (typeof value.to !== "string" || value.to.trim() === "") {
+                throw new LaneSchemaError(`${field}.to must be a non-empty string`, { path: filePath, field: `${field}.to` });
+            }
+            if (typeof value.hours !== "number" || !Number.isFinite(value.hours) || value.hours < 6) {
+                throw new LaneSchemaError(`${field}.hours must be a finite number of at least 6`, { path: filePath, field: `${field}.hours` });
+            }
+        }
+    }
     requireString(raw.project_id, "project_id");
     if (typeof raw.story_id !== "string" ||
         (raw.story_id.trim() === "" && raw.no_story_reason === undefined)) {
@@ -1165,9 +1184,27 @@ export function parseQuestionRecord(raw, filePath) {
             value: delivered_at,
         });
     }
+    const seen_at = raw.seen_at === undefined ? null : raw.seen_at;
+    if (seen_at !== null &&
+        (typeof seen_at !== "string" || !Number.isFinite(Date.parse(seen_at)))) {
+        throw new LaneSchemaError("seen_at must be a valid timestamp or null", {
+            path: filePath,
+            value: seen_at,
+        });
+    }
+    const seen_session_id = raw.seen_session_id === undefined ? null : raw.seen_session_id;
+    if (seen_session_id !== null &&
+        (typeof seen_session_id !== "string" || !seen_session_id.trim())) {
+        throw new LaneSchemaError("seen_session_id must be a non-empty string or null", {
+            path: filePath,
+            value: seen_session_id,
+        });
+    }
     return {
         ...raw,
         delivered_at,
+        seen_at,
+        seen_session_id,
         ...(raw.priority === null ? { priority: undefined } : {}),
     };
 }
@@ -1362,12 +1399,15 @@ export function mergeQuestionRecords(live, sidecars) {
     const all = [live, ...sidecars];
     const base = higherVersionRecord(live, sidecars);
     const deliveredAt = all
+        .filter((record) => record.status === "answered")
         .map((record) => record.delivered_at)
         .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
         .sort((a, b) => Date.parse(a) - Date.parse(b))[0] ?? null;
     return {
         ...base,
         delivered_at: deliveredAt,
+        seen_at: base.seen_at ?? null,
+        seen_session_id: base.seen_session_id ?? null,
         answer_history: unionHistory(all.map(questionAnswerHistory), entryIdentity, questionAnswerHistory(base)),
         routing_history: unionHistory(all.map((record) => record.routing_history), entryIdentity, base.routing_history),
     };
@@ -1631,14 +1671,19 @@ export function updateLane(hqRoot, laneId, expectedVersion, writer, updater, dep
         // `current` is the pre-update snapshot and stays untouched: the updater
         // receives a deep clone, so mutating its argument in place cannot reach
         // the record the ownership check compares against.
-        const updated = updater(structuredClone(current));
+        const proposed = updater(structuredClone(current));
+        const updated = current.state === "blocked" && proposed.state !== "blocked"
+            ? { ...proposed, blocked_since: undefined }
+            : proposed;
         for (const key of Object.keys(updated)) {
             if (key === "version" || key === "updated_at" || fieldUnchanged(current[key], updated[key]))
                 continue;
             const allowedWriters = LANE_FIELD_WRITERS[key];
+            const transitionClearedBlockedSince = key === "blocked_since" &&
+                current.state === "blocked" && updated.state !== "blocked" && updated.blocked_since === undefined;
             // Unknown forward-version fields are preserved, never assigned an
             // ownership rule by a v1 reader.
-            if (allowedWriters && !allowedWriters.includes(writer)) {
+            if (allowedWriters && !allowedWriters.includes(writer) && !transitionClearedBlockedSince) {
                 throw new LanesError("lane_writer_unauthorized", `Writer ${writer} cannot write lane field ${key}`, { writer, field: key });
             }
         }
@@ -1909,6 +1954,8 @@ export function createQuestion(hqRoot, init, deps = defaultStoreDeps()) {
         schema_version: init.schema_version ?? QUESTION_SCHEMA_VERSION,
         question_id,
         delivered_at: init.delivered_at ?? null,
+        seen_at: init.seen_at ?? null,
+        seen_session_id: init.seen_session_id ?? null,
         version: 1,
         routing_history: init.routing_history ?? [],
     };

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

@@ -546,6 +546,10 @@ export interface LaneRecord {
     senior: SeniorRef;
     senior_history: SeniorHistoryEntry[];
     state: LaneState;
+    /** Start of the current uninterrupted blocked episode; never inferred from an envelope. */
+    blocked_since?: string;
+    /** Durable six-hour blocked-lane escalation history. */
+    escalations?: LaneEscalationEntry[];
     queued_reason?: QueuedReason;
     queued_details?: QueuedDetails;
     /** Time the current queue turn began; old records fall back to created_at. */
@@ -573,6 +577,8 @@ export interface LaneRecord {
     keep_alive?: boolean;
     /** Whether completed keep-alive stories wait for queued work after a done turn. */
     keep_alive_standing?: boolean;
+    /** Conduct loop lanes keep one registered worker identity while phases are queued. */
+    loop_mode?: true;
     /** Time this lane most recently explicitly opted into keep-alive. */
     keep_alive_opted_in_at?: string;
     /** Why reconcile declined to resume this lane most recently. */
@@ -765,6 +771,11 @@ export interface LaneRecord {
     /** Last successful lane_progress mesh delivery, preserved across watcher restarts. */
     last_progress_event_at?: string;
 }
+export interface LaneEscalationEntry {
+    at: string;
+    to: string;
+    hours: number;
+}
 /** The v1 fields that must exist on every durable lane record (spec §3).
  * `company` is normalized from absence for pre-attribution legacy records. */
 export declare const REQUIRED_LANE_RECORD_FIELDS: readonly ["schema_version", "lane_id", "project_id", "story_id", "depth", "senior", "senior_history", "state", "priority", "provider", "host", "version", "created_at", "updated_at", "attribution_history"];
@@ -809,6 +820,10 @@ export interface PendingResume {
     trigger: "answered_questions" | "message" | "monitor_event" | "system_notice" | "resume" | "watcher";
     /** True when this queued resume was initiated automatically by keep-alive. */
     keep_alive?: true;
+    /** Working directory for a deferred loop phase. */
+    working_directory?: string;
+    /** Start this deferred conduct phase with a fresh provider session. */
+    fresh_thread?: true;
     resumed_from?: "interrupted" | "done" | "blocked" | "failed" | "awaiting_input";
     from_failed?: true;
     /** Senior that authorized a failed-lane resume, rechecked at the claim CAS. */
@@ -930,6 +945,9 @@ export interface QuestionRecord {
     version: number;
     /** Null until the owner starts a resume carrying this answer; absent on old records. */
     delivered_at?: string | null;
+    /** When the current session audience last saw this pending question. */
+    seen_at?: string | null;
+    seen_session_id?: string | null;
     body: QuestionBodyRef;
     routing_history: RoutingHistoryEntry[];
     answer?: QuestionAnswer;

package/dist/lib/lanes/types.js

@@ -230,15 +230,15 @@ export const LANE_FIELD_WRITERS = {
     depth: ["command"], senior: ["command"], senior_history: ["command"],
     hire_grant: ["creator", "command"],
     released_hire_grant: ["command"],
-    state: ["creator", "command", "watcher", "reconcile", "spawn"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_details: ["command", "reconcile", "spawn", "watcher"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
+    state: ["creator", "command", "watcher", "reconcile", "spawn"], blocked_since: ["watcher", "reconcile"], escalations: ["reconcile"], queued_reason: ["creator", "command", "spawn", "watcher", "reconcile"], queued_details: ["command", "reconcile", "spawn", "watcher"], queued_at: ["creator", "command", "spawn", "watcher", "reconcile"], admission_reserved_at: ["creator", "command", "reconcile", "spawn", "watcher"],
     pickup_validation_pending: ["creator", "command", "spawn", "reconcile"],
     pickup_validation_pending_since: ["creator", "command", "spawn", "reconcile"],
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
-    keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile", "spawn"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile", "spawn"], keep_alive_next_eligible_at: ["command", "reconcile", "spawn"], keep_alive_exhausted_at: ["command", "reconcile", "spawn"],
+    keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile", "spawn"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile", "spawn"], keep_alive_next_eligible_at: ["command", "reconcile", "spawn"], keep_alive_exhausted_at: ["command", "reconcile", "spawn"], loop_mode: ["creator"],
     provider: ["creator", "command"], provider_source: ["creator", "command"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_source: ["creator", "command"], profile_settings_pinned: ["command"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], fallback_question_cancellation_failures: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
     version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
-    last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
+    last_message_at: ["creator", "command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile", "spawn"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile", "spawn", "command"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],

package/dist/lib/lanes/watcher.js

@@ -469,6 +469,9 @@ function applyTerminalToLaneWithResult(hqRoot, laneId, classification, opts = {}
             ...current,
             ...runResultFields(hqRoot, current, at),
             state: effectiveClassification.state,
+            blocked_since: effectiveClassification.state === "blocked"
+                ? current.state === "blocked" ? current.blocked_since ?? at : at
+                : undefined,
             queued_reason: undefined,
             queued_details: undefined,
             stalled: undefined,

package/dist/lib/lanes/worker-continuity.d.ts

@@ -0,0 +1,18 @@
+import { type LaneRecord, type LaneProvider, type SeniorRef } from "./types.js";
+export interface WorkerContinuityLookup {
+    senior: SeniorRef;
+    worker: string;
+    provider: LaneProvider;
+    company: LaneRecord["company"];
+    freshThread?: boolean;
+}
+export interface WorkerContinuityResult {
+    previous?: LaneRecord;
+    resumable: boolean;
+    fallbackReason?: "provider_unsupported" | "session_id_missing" | "state_unsafe" | "host_mismatch";
+}
+export declare function sameLaneHost(left: LaneRecord["host"], right: LaneRecord["host"]): boolean;
+/** Select the prior worker lane within exactly one senior/company/provider scope. */
+export declare function findWorkerContinuityLane(lanes: readonly LaneRecord[], lookup: WorkerContinuityLookup): WorkerContinuityResult;
+export declare function workerContinuityPrompt(previous: LaneRecord, resultSummary?: string, resultRef?: string): string;
+//# sourceMappingURL=worker-continuity.d.ts.map

package/dist/lib/lanes/worker-continuity.js

@@ -0,0 +1,81 @@
+import { LanesError } from "./errors.js";
+import { providerSupportsSessionResume } from "./delivery.js";
+import { isTerminalLaneState } from "./types.js";
+function seniorKey(senior) {
+    return `${senior.kind}:${senior.id ?? ""}`;
+}
+function sameCompany(left, right) {
+    if (left?.uid && right?.uid)
+        return left.uid === right.uid;
+    if (left?.slug && right?.slug)
+        return left.slug === right.slug;
+    return left == null && right == null;
+}
+function compareNewest(left, right) {
+    return right.created_at.localeCompare(left.created_at) || right.lane_id.localeCompare(left.lane_id);
+}
+export function sameLaneHost(left, right) {
+    return left.kind === right.kind && left.id === right.id;
+}
+/** Select the prior worker lane within exactly one senior/company/provider scope. */
+export function findWorkerContinuityLane(lanes, lookup) {
+    const scoped = lanes
+        .filter((lane) => lane.worker === lookup.worker && lane.provider === lookup.provider &&
+        seniorKey(lane.senior) === seniorKey(lookup.senior) && sameCompany(lane.company ?? lane.mesh_company, lookup.company))
+        .sort(compareNewest);
+    const live = scoped.find((lane) => !isTerminalLaneState(lane.state));
+    if (live) {
+        throw new LanesError("worker_lane_busy", `Worker ${lookup.worker} already has live lane ${live.lane_id}`, {
+            worker: lookup.worker,
+            lane_id: live.lane_id,
+            state: live.state,
+        });
+    }
+    const previous = scoped[0];
+    if (!previous)
+        return { resumable: false };
+    if (lookup.freshThread)
+        return { previous, resumable: false };
+    const previousSessionId = previous.provider_session_id?.trim();
+    if (previousSessionId) {
+        const liveDescendant = lanes
+            .filter((lane) => lane.lane_id !== previous.lane_id && lane.provider === lookup.provider &&
+            sameCompany(lane.company ?? lane.mesh_company, lookup.company) &&
+            lane.provider_session_id === previousSessionId &&
+            (lane.state === "queued" || lane.state === "running"))
+            .sort(compareNewest)[0];
+        if (liveDescendant) {
+            throw new LanesError("worker_lane_busy", `Provider thread lineage is active in lane ${liveDescendant.lane_id}`, {
+                worker: lookup.worker,
+                lane_id: liveDescendant.lane_id,
+                state: liveDescendant.state,
+                provider_session_id: previousSessionId,
+            });
+        }
+    }
+    // Only clean, resumable terminal outcomes are safe for automatic reuse.
+    if (previous.state !== "done" && previous.state !== "interrupted") {
+        return { previous, resumable: false, fallbackReason: "state_unsafe" };
+    }
+    if (!providerSupportsSessionResume(lookup.provider)) {
+        return { previous, resumable: false, fallbackReason: "provider_unsupported" };
+    }
+    if (!previous.provider_session_id?.trim()) {
+        return { previous, resumable: false, fallbackReason: "session_id_missing" };
+    }
+    return { previous, resumable: true };
+}
+export function workerContinuityPrompt(previous, resultSummary, resultRef) {
+    const summary = resultSummary?.trim();
+    const resultPath = resultRef?.trim()
+        ? `workspace/lanes-runs/${previous.lane_id}/${resultRef.trim()}`
+        : `workspace/lanes-runs/${previous.lane_id}/envelopes/`;
+    return [
+        "## Previous worker lane",
+        `Continue the provider session from lane ${previous.lane_id}. Its latest result is recorded at ${resultPath}; read that result before acting.`,
+        ...(summary ? [`Previous result summary: ${summary}`] : []),
+        "The current brief below is the instruction for this turn.",
+        "",
+    ].join("\n");
+}
+//# sourceMappingURL=worker-continuity.js.map

package/dist/lib/lanes/worker-process.d.ts

@@ -0,0 +1,4 @@
+export declare const LANE_WORKER_EXIT_PATH_ENV = "HQ_LANE_WORKER_EXIT_PATH";
+/** Runs one lane worker process and persists its terminal process status. */
+export declare function runLaneWorkerProcess(command: string, args: string[], env?: NodeJS.ProcessEnv, cwd?: string): Promise<number>;
+//# sourceMappingURL=worker-process.d.ts.map

package/dist/lib/lanes/worker-process.js

@@ -0,0 +1,77 @@
+import * as childProcess from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+export const LANE_WORKER_EXIT_PATH_ENV = "HQ_LANE_WORKER_EXIT_PATH";
+function exitCodeFor(code, signal) {
+    if (code !== null)
+        return code;
+    return signal ? 128 + (os.constants.signals[signal] ?? 0) : 1;
+}
+function recordExit(pathname, code, signal) {
+    const tempPath = `${pathname}.${process.pid}.tmp`;
+    fs.writeFileSync(tempPath, `${JSON.stringify({
+        exit_code: exitCodeFor(code, signal),
+        ...(signal ? { signal } : {}),
+        ended_at: new Date().toISOString(),
+    })}\n`, { mode: 0o600 });
+    fs.renameSync(tempPath, pathname);
+}
+/** Runs one lane worker process and persists its terminal process status. */
+export function runLaneWorkerProcess(command, args, env = process.env, cwd = process.cwd()) {
+    const exitPath = env[LANE_WORKER_EXIT_PATH_ENV];
+    const childEnv = { ...env };
+    delete childEnv[LANE_WORKER_EXIT_PATH_ENV];
+    const child = childProcess.spawn(command, args, { cwd, env: childEnv, stdio: "inherit" });
+    let settled = false;
+    const finish = (code, signal) => {
+        if (!settled && exitPath) {
+            try {
+                recordExit(exitPath, code, signal);
+            }
+            catch (error) {
+                process.stderr.write(`hq lanes: could not persist worker exit status: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        }
+        settled = true;
+        return exitCodeFor(code, signal);
+    };
+    return new Promise((resolve) => {
+        const signals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+        const handlers = new Map();
+        const cleanup = () => {
+            for (const [signal, handler] of handlers)
+                process.removeListener(signal, handler);
+        };
+        for (const signal of signals) {
+            const handler = () => child.kill(signal);
+            handlers.set(signal, handler);
+            process.on(signal, handler);
+        }
+        child.once("error", (error) => {
+            process.stderr.write(`hq lanes: worker process could not start: ${error.message}\n`);
+            if (!settled) {
+                cleanup();
+                resolve(finish(127, null));
+            }
+        });
+        child.once("exit", (code, signal) => {
+            if (!settled) {
+                cleanup();
+                resolve(finish(code, signal));
+            }
+        });
+    });
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    const [command, ...args] = process.argv.slice(2);
+    if (!command) {
+        process.stderr.write("hq lanes: worker process command is missing\n");
+        process.exitCode = 2;
+    }
+    else {
+        process.exitCode = await runLaneWorkerProcess(command, args);
+    }
+}
+//# sourceMappingURL=worker-process.js.map

package/dist/main.js

@@ -47,7 +47,7 @@ import { enforceVersionGate, getVersionGatePhase, isLocalDependencyInstall, reso
 import { autoUpdateAndReexec } from "./utils/self-update.js";
 import { CLI_VERSION } from "./cli-version.js";
 import { findLazyCommand, registerCommandCatalog } from "./lazy-commands.js";
-import { emitCliFirstSyncNextStepOutcome, emitCliLimitNoticeEngagement, emitCliLimitNoticeExposure, emitCliInviteNudgeEvent, emitCliSessionStarted, emitPlanLimitInviteTeammateExposure, isCliLimitResourceKind, queueCliLimitNoticeEngagement, queueCliLimitNoticeExposure, takeFirstSyncStepOutcomes, takeCliLimitNoticeEngagements, takeCliLimitNoticeExposures, takeCliInviteNudgeEvents, takePlanLimitInviteTeammateExposures, maybeShowFirstSyncNextStep, } from "./utils/cli-telemetry.js";
+import { emitCliFirstSyncNextStepOutcome, emitCliFeatureUsed, emitCliLimitNoticeEngagement, emitCliLimitNoticeExposure, emitCliInviteNudgeEvent, emitCliSessionStarted, emitPlanLimitInviteTeammateExposure, isCliLimitResourceKind, queueCliLimitNoticeEngagement, queueCliLimitNoticeExposure, takeFirstSyncStepOutcomes, takeCliFeatureUsages, takeCliLimitNoticeEngagements, takeCliLimitNoticeExposures, takeCliInviteNudgeEvents, takePlanLimitInviteTeammateExposures, maybeShowFirstSyncNextStep, } from "./utils/cli-telemetry.js";
 import { reportCliClientHealthInvocation } from "./utils/client-health.js";
 import { settleWithin } from "./utils/settle-with-timeout.js";
 import { isVersionRequest } from "./version-request.js";
@@ -298,7 +298,9 @@ export async function runCli() {
         await releasePackageUseLeaseAfterCommandLoad(process.argv);
         await program.parseAsync();
         commandParsed = true;
-        maybeShowFirstSyncNextStep();
+        if (process.exitCode === undefined || process.exitCode === 0) {
+            maybeShowFirstSyncNextStep();
+        }
     }
     catch (err) {
         await handleTopLevelError(err);
@@ -316,7 +318,10 @@ export async function runCli() {
             // lifecycle boundary for this invocation. The budget reserves this 500 ms
             // slice even when the command itself was long-running.
             const releaseHealthTimeoutMs = foregroundNetworkBudget.timeoutFor(FINALIZATION_FOREGROUND_WAIT_MS);
-            const firstSyncOutcomeFlushes = takeFirstSyncStepOutcomes().map((outcome) => emitCliFirstSyncNextStepOutcome(outcome, releaseHealthTimeoutMs));
+            const firstSyncOutcomeFlushes = process.exitCode === undefined || process.exitCode === 0
+                ? takeFirstSyncStepOutcomes().map((outcome) => emitCliFirstSyncNextStepOutcome(outcome, releaseHealthTimeoutMs))
+                : [];
+            const featureUsageFlushes = takeCliFeatureUsages().map((usage) => emitCliFeatureUsed(usage, releaseHealthTimeoutMs));
             const inviteNudgeOutcomeFlushes = takeCliInviteNudgeEvents().map((event) => emitCliInviteNudgeEvent(event, releaseHealthTimeoutMs));
             const inviteTeammateExposureFlushes = takePlanLimitInviteTeammateExposures().map((companyUid) => emitPlanLimitInviteTeammateExposure(companyUid, releaseHealthTimeoutMs));
             const limitNoticeExposureFlushes = takeCliLimitNoticeExposures().map((exposure) => emitCliLimitNoticeExposure(exposure, releaseHealthTimeoutMs));
@@ -343,6 +348,7 @@ export async function runCli() {
                 ...(cachedVersionNudge ? [cachedVersionNudge] : []),
                 Sentry.flush(releaseHealthTimeoutMs),
                 ...firstSyncOutcomeFlushes,
+                ...featureUsageFlushes,
                 ...inviteNudgeOutcomeFlushes,
                 ...inviteTeammateExposureFlushes,
                 ...limitNoticeExposureFlushes,

package/dist/utils/cli-telemetry.d.ts

@@ -46,7 +46,7 @@ export declare function queueCliInviteNudgeEvent(companyUid: string, outcome: Cl
 export declare function takeCliInviteNudgeEvents(): CliInviteNudgeEvent[];
 /** Emit a bounded CLI session fact through the existing product-telemetry path. */
 export declare function emitCliInviteNudgeEvent(event: CliInviteNudgeEvent, timeoutMs?: number): Promise<void>;
-export type CliFeatureKind = "secret_read" | "lane_create" | "lane_resume";
+export type CliFeatureKind = "secret_read" | "lane_create" | "lane_resume" | "members_invite";
 export type CliFeatureOutcome = "success" | "failure";
 export interface CliFeatureUsage {
     kind: CliFeatureKind;
@@ -54,6 +54,9 @@ export interface CliFeatureUsage {
     /** Only company UIDs are accepted; names and slugs are never telemetry fields. */
     companyUid?: string;
 }
+/** Queue privacy-limited feature telemetry for the bounded CLI finalization flush. */
+export declare function queueCliFeatureUsed(usage: CliFeatureUsage): void;
+export declare function takeCliFeatureUsages(): CliFeatureUsage[];
 export declare function isCliLimitResourceKind(value: string): value is CliLimitResourceKind;
 /**
  * Emit one bounded, privacy-limited feature-use event with a cached identity.

package/dist/utils/cli-telemetry.js

@@ -142,6 +142,14 @@ export async function emitCliInviteNudgeEvent(event, timeoutMs = TELEMETRY_TIMEO
         console.error(`hq: Could not prepare invite prompt telemetry (${errorClass}).`);
     }
 }
+const pendingCliFeatureUsages = [];
+/** Queue privacy-limited feature telemetry for the bounded CLI finalization flush. */
+export function queueCliFeatureUsed(usage) {
+    pendingCliFeatureUsages.push({ ...usage });
+}
+export function takeCliFeatureUsages() {
+    return pendingCliFeatureUsages.splice(0, pendingCliFeatureUsages.length);
+}
 const COMPANY_UID_PATTERN = /^cmp_[A-Za-z0-9_-]{1,128}$/;
 export function isCliLimitResourceKind(value) {
     return ["users", "integrations", "secrets", "agents", "deployments", "storageBytes"].includes(value);

package/dist/utils/jq-windows-compat.d.ts

@@ -0,0 +1,13 @@
+export type JqResult = {
+    code: number;
+    stdout?: string;
+    stderr?: string;
+    stdoutBytes?: Buffer;
+    stderrBytes?: Buffer;
+};
+export type JqInvoke = (args: string[], input: Buffer | string | undefined, cwd: string, options: {
+    stdout?: "capture" | "ignore";
+    stderr?: "pipe" | "ignore";
+}) => JqResult;
+export declare function createShellCompatibleJqInvoker(invoke: JqInvoke, platform: NodeJS.Platform, env: NodeJS.ProcessEnv, resolveShellType: (cwd: string) => string | undefined): JqInvoke;
+//# sourceMappingURL=jq-windows-compat.d.ts.map

package/dist/utils/jq-windows-compat.js

@@ -0,0 +1,48 @@
+function stripCarriageReturnBeforeLineFeed(bytes) {
+    const output = Buffer.allocUnsafe(bytes.length);
+    let length = 0;
+    for (let index = 0; index < bytes.length; index += 1) {
+        const byte = bytes[index];
+        if (byte === 0x0d && bytes[index + 1] === 0x0a)
+            continue;
+        output[length] = byte ?? 0;
+        length += 1;
+    }
+    return output.subarray(0, length);
+}
+function normalizeResult(result) {
+    const stdoutBytes = stripCarriageReturnBeforeLineFeed(result.stdoutBytes ?? Buffer.from(result.stdout ?? ""));
+    const stderrBytes = stripCarriageReturnBeforeLineFeed(result.stderrBytes ?? Buffer.from(result.stderr ?? ""));
+    return {
+        ...result,
+        stdoutBytes,
+        stderrBytes,
+        stdout: stdoutBytes.toString("utf8"),
+        stderr: stderrBytes.toString("utf8"),
+    };
+}
+export function createShellCompatibleJqInvoker(invoke, platform, env, resolveShellType) {
+    let binaryOptionSupported;
+    let shellTypeResolved = false;
+    let shellType;
+    return (args, input, cwd, options) => {
+        if (platform !== "win32")
+            return invoke(args, input, cwd, options);
+        if (!shellTypeResolved) {
+            shellType = resolveShellType(cwd);
+            shellTypeResolved = true;
+        }
+        const msysMode = /^msys/i.test(shellType ?? "") || /^MINGW/i.test(env.MSYSTEM ?? "");
+        if (!msysMode)
+            return invoke(args, input, cwd, options);
+        if (binaryOptionSupported === undefined) {
+            binaryOptionSupported = invoke(["--binary", "-n", "null"], undefined, cwd, {
+                stdout: "ignore",
+                stderr: "ignore",
+            }).code === 0;
+        }
+        const result = invoke(binaryOptionSupported ? ["--binary", ...args] : args, input, cwd, options);
+        return binaryOptionSupported ? result : normalizeResult(result);
+    };
+}
+//# sourceMappingURL=jq-windows-compat.js.map

package/dist/utils/run-bundled-script.d.ts

@@ -29,6 +29,7 @@
  *   - signals are surfaced as the conventional 128+n. A caller that kills a
  *     script needs to see termination, not a success code.
  */
+export { resolveWindowsBash } from "./windows-bash.js";
 /**
  * Which interpreter runs a bundled asset, chosen by extension.
  *
@@ -57,6 +58,8 @@ export type RunBundledScriptOptions = {
     captureOutput?: boolean;
     /** Bytes supplied on stdin. With no value, stdin is inherited as before. */
     stdin?: string | Buffer;
+    /** Start the bundled Bash script with descriptor 0 closed. */
+    closeStdin?: boolean;
     /** Optional child-process deadline for callers that need bounded script execution. */
     timeoutMs?: number;
 };

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

@@ -34,6 +34,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "path";
 import { resolveBundledAsset } from "./hq-roots-core.js";
+import { resolveWindowsBash } from "./windows-bash.js";
+export { resolveWindowsBash } from "./windows-bash.js";
 /**
  * Which interpreter runs a bundled asset, chosen by extension.
  *
@@ -52,85 +54,6 @@ function scriptPathForBash(script) {
     const drivePath = normalized.match(/^([A-Za-z]):\/(.*)$/);
     return drivePath ? `/${drivePath[1].toLowerCase()}/${drivePath[2]}` : normalized;
 }
-function envValue(env, name) {
-    const key = Object.keys(env).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
-    return key ? env[key] : undefined;
-}
-function isFile(file, lookupErrors) {
-    try {
-        return fs.statSync(file).isFile();
-    }
-    catch (error) {
-        // Missing PATH candidates are expected during lookup; retain the cause so
-        // the final actionable error can expose why no interpreter was resolved.
-        lookupErrors.push(error);
-        return false;
-    }
-}
-function isWithinWindowsDirectory(file, directory) {
-    const normalizedFile = path.win32.resolve(file).toLowerCase();
-    const normalizedDirectory = path.win32.resolve(directory).toLowerCase();
-    return (normalizedFile === normalizedDirectory ||
-        normalizedFile.startsWith(`${normalizedDirectory}${path.win32.sep}`));
-}
-function isExcludedWindowsBash(file, env) {
-    if (path.win32.basename(file).toLowerCase() !== "bash.exe")
-        return false;
-    const windowsDir = envValue(env, "SystemRoot") ?? envValue(env, "WINDIR") ?? "C:\\Windows";
-    const systemBash = path.win32.resolve(windowsDir, "System32", "bash.exe");
-    if (path.win32.resolve(file).toLowerCase() === systemBash.toLowerCase())
-        return true;
-    const localAppData = envValue(env, "LOCALAPPDATA");
-    return Boolean(localAppData &&
-        isWithinWindowsDirectory(file, path.win32.resolve(localAppData, "Microsoft", "WindowsApps")));
-}
-function findOnWindowsPath(executable, env, lookupErrors) {
-    const pathValue = envValue(env, "PATH") ?? "";
-    const extensions = executable.includes(".")
-        ? [""]
-        : (envValue(env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD")
-            .split(";")
-            .filter(Boolean)
-            .map((ext) => ext.toLowerCase());
-    for (const entry of pathValue.split(";").filter(Boolean)) {
-        const directory = entry.trim().replace(/^"|"$/g, "");
-        for (const extension of extensions) {
-            const candidate = path.win32.join(directory, `${executable}${extension}`);
-            if (!isExcludedWindowsBash(candidate, env) && isFile(candidate, lookupErrors))
-                return candidate;
-        }
-    }
-    return undefined;
-}
-function resolveWindowsBash(env) {
-    const lookupErrors = [];
-    const configured = envValue(env, "CLAUDE_CODE_GIT_BASH_PATH");
-    if (configured && !isExcludedWindowsBash(configured, env) && isFile(configured, lookupErrors)) {
-        return { executable: configured, cause: lookupErrors.at(-1) };
-    }
-    const pathBash = findOnWindowsPath("bash", env, lookupErrors);
-    if (pathBash)
-        return { executable: pathBash, cause: lookupErrors.at(-1) };
-    const gitExe = findOnWindowsPath("git.exe", env, lookupErrors);
-    if (gitExe) {
-        const derived = path.win32.resolve(path.win32.dirname(gitExe), "..", "bin", "bash.exe");
-        if (!isExcludedWindowsBash(derived, env) && isFile(derived, lookupErrors)) {
-            return { executable: derived, cause: lookupErrors.at(-1) };
-        }
-    }
-    const programFiles = envValue(env, "ProgramFiles") ?? "C:\\Program Files";
-    const localAppData = envValue(env, "LOCALAPPDATA");
-    const standardPaths = [
-        path.win32.join(programFiles, "Git", "bin", "bash.exe"),
-        ...(localAppData ? [path.win32.join(localAppData, "Programs", "Git", "bin", "bash.exe")] : []),
-    ];
-    const executable = standardPaths.find((candidate) => !isExcludedWindowsBash(candidate, env) && isFile(candidate, lookupErrors));
-    return {
-        executable,
-        cause: lookupErrors.at(-1) ??
-            Object.assign(new Error("Bash was not found (ENOENT)"), { code: "ENOENT" }),
-    };
-}
 function bashNotFoundError(asset, cause) {
     const isHandoff = asset.replaceAll("\\", "/").endsWith("core/scripts/handoff-finalize.sh");
     const recovery = isHandoff
@@ -185,7 +108,13 @@ export function runBundledScript(opts) {
                 ? [stdinStdio, "inherit", "inherit"]
                 : "inherit";
         const scriptArg = interpreter === "bash" && opts.msysScriptPath ? scriptPathForBash(script) : script;
-        result = spawnSync(executable, [scriptArg, ...(opts.args ?? [])], {
+        if (opts.closeStdin && (interpreter !== "bash" || inputDescriptor !== undefined)) {
+            throw new Error("closeStdin requires a Bash asset without supplied stdin");
+        }
+        const commandArgs = opts.closeStdin
+            ? ["-c", 'exec 0<&-; exec "$BASH" "$@"', "hq-bundled-script", scriptArg, ...(opts.args ?? [])]
+            : [scriptArg, ...(opts.args ?? [])];
+        result = spawnSync(executable, commandArgs, {
             cwd: opts.cwd,
             env,
             stdio,