@indigoai-us/hq-cli 5.345.54 → 5.345.56

package/dist/commands/lanes-session-start.js

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
+import { LANE_CONDUCT_SESSION_START_FLAG } from "../lib/lanes/flag-keys.js";
+function enabledFromSettings(root) {
+    const personal = path.join(root, "personal", "settings", "orchestrator.yaml");
+    const settings = fs.existsSync(personal) ? personal : path.join(root, "core", "settings", "orchestrator.yaml");
+    if (!fs.existsSync(settings))
+        return false;
+    const text = fs.readFileSync(settings, "utf8");
+    const block = /^conduct:\s*(?:#.*)?\r?\n((?:[ \t]+.*\r?\n?)*)/m.exec(text)?.[1] ?? "";
+    const value = /^\s+default_enabled:\s*["']?(true|false|yes|no|on|off|1|0)["']?\s*(?:#.*)?$/mi.exec(block)?.[1]?.toLowerCase();
+    return value === "true" || value === "yes" || value === "on" || value === "1";
+}
+function sessionWasDisabled(root, env, payloadSessionId) {
+    const sessionId = payloadSessionId || env.HQ_SESSION_ID;
+    if (!sessionId || !/^[A-Za-z0-9_-]+$/.test(sessionId))
+        return false;
+    const meta = path.join(root, "workspace", "sessions", sessionId, "meta.yaml");
+    if (!fs.existsSync(meta))
+        return false;
+    const text = fs.readFileSync(meta, "utf8");
+    return /^\s*(?:conduct_mode|conduct_enabled|conduct_default):\s*(?:off|false|no|0)\s*(?:#.*)?$/mi.test(text) ||
+        /^\s*conduct_engine:\s*(?:""|''|#.*)?\s*$/mi.test(text);
+}
+function extractConductorBlock(core) {
+    const start = core.indexOf("<!-- inject:start -->");
+    const end = core.indexOf("<!-- inject:end -->");
+    if (start < 0 || end < 0 || end <= start)
+        return null;
+    return core.slice(start + "<!-- inject:start -->".length, end).replace(/^\r?\n/, "").replace(/\r?\n$/, "");
+}
+const ORPHAN_SWEEP_LOCK_TTL_MS = 15 * 60_000;
+/** Starts the CL-4 read-only orphan report once per host, without holding SessionStart open. */
+export function startSessionStartOrphanSweep(root, env = process.env, spawnDetached = spawn) {
+    const stateRoot = env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+    const host = os.hostname().replace(/[^A-Za-z0-9._-]/g, "_") || "unknown-host";
+    const stateDir = path.join(stateRoot, "hq-cli", "lanes-session-start", host);
+    const lockPath = path.join(stateDir, "orphan-sweep.lock");
+    const reportDir = path.join(stateRoot, "hq-cli", "lanes-orphan-reports", host);
+    const ownerToken = randomUUID();
+    try {
+        fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+        fs.mkdirSync(reportDir, { recursive: true, mode: 0o700 });
+        let fd;
+        try {
+            fd = fs.openSync(lockPath, "wx", 0o600);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                return;
+            let previous = {};
+            try {
+                previous = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+            }
+            catch { /* malformed lease can be reclaimed */ }
+            const age = Date.now() - Number(previous.started_at || 0);
+            let running = false;
+            if (Number.isInteger(previous.pid) && Number(previous.pid) > 0) {
+                try {
+                    process.kill(Number(previous.pid), 0);
+                    running = true;
+                }
+                catch {
+                    running = false;
+                }
+            }
+            if (age < ORPHAN_SWEEP_LOCK_TTL_MS && running)
+                return;
+            fs.rmSync(lockPath, { force: true });
+            try {
+                fd = fs.openSync(lockPath, "wx", 0o600);
+            }
+            catch {
+                return;
+            }
+        }
+        const startedAt = Date.now();
+        fs.writeFileSync(fd, JSON.stringify({ pid: process.pid, started_at: startedAt, owner_token: ownerToken }));
+        fs.closeSync(fd);
+        const cli = process.argv[1];
+        if (!cli) {
+            fs.rmSync(lockPath, { force: true });
+            return;
+        }
+        const wrapper = [
+            "const cp=require('node:child_process'),fs=require('node:fs'),path=require('node:path');",
+            "const [cli,lock,root,token,report]=process.argv.slice(1);",
+            "const cleanup=()=>{try{const lease=JSON.parse(fs.readFileSync(lock,'utf8'));if(lease.owner_token===token)fs.rmSync(lock,{force:true})}catch{}};",
+            "const start=()=>{let lease;try{lease=JSON.parse(fs.readFileSync(lock,'utf8'))}catch{}if(lease?.owner_token!==token){if(Date.now()<Number(lease?.started_at||0)+1000)return setTimeout(start,10);process.exit(0)}",
+            "try{fs.writeFileSync(lock,JSON.stringify({...lease,pid:process.pid}))}catch{}",
+            "const tmp=report+'.tmp';let output;try{output=fs.createWriteStream(tmp,{flags:'wx',mode:0o600})}catch{cleanup();process.exit(0)}",
+            "const child=cp.spawn(process.execPath,[cli,'lanes','_reap','--json'],{stdio:['ignore','pipe','ignore'],env:{...process.env,HQ_ROOT:root,HQ_NO_UPDATE_CHECK:'1'}});",
+            "child.stdout.pipe(output);child.on('error',()=>{output.destroy();try{fs.rmSync(tmp,{force:true})}catch{}cleanup()});",
+            "child.on('exit',(code)=>output.end(()=>{try{if(code===0)fs.renameSync(tmp,report);else fs.rmSync(tmp,{force:true})}catch{}cleanup()}));};start();",
+        ].join("");
+        const reportPath = path.join(reportDir, `orphans-${startedAt}-${ownerToken}.json`);
+        const launcher = spawnDetached(process.execPath, ["-e", wrapper, cli, lockPath, root, ownerToken, reportPath], {
+            detached: true,
+            stdio: "ignore",
+            env: { ...env, HQ_ROOT: root, HQ_NO_UPDATE_CHECK: "1" },
+        });
+        if (launcher.pid) {
+            try {
+                fs.writeFileSync(lockPath, JSON.stringify({ pid: launcher.pid, started_at: startedAt, owner_token: ownerToken }));
+            }
+            catch { /* TTL lease still bounds an orphaned lock */ }
+        }
+        launcher.on("error", () => {
+            try {
+                const lease = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+                if (lease.owner_token === ownerToken)
+                    fs.rmSync(lockPath, { force: true });
+            }
+            catch { /* The lease may already have been reclaimed. */ }
+        });
+        launcher.unref();
+    }
+    catch {
+        // SessionStart's orphan report is advisory and must never block startup.
+    }
+}
+/** SessionStart-compatible, fail-open conduct bootstrap. */
+export async function runLaneSessionStart(options = {}) {
+    const env = options.env ?? process.env;
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    let debugLineWritten = false;
+    const debug = (message) => {
+        if (env.HQ_LANES_DEBUG === "1" && !debugLineWritten) {
+            debugLineWritten = true;
+            stderr.write(`${message}\n`);
+        }
+    };
+    try {
+        const chunks = [];
+        for await (const chunk of stdin)
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        const input = Buffer.concat(chunks).toString("utf8");
+        let source = "startup";
+        let payloadSessionId;
+        try {
+            const payload = JSON.parse(input);
+            source = payload.source || "startup";
+            payloadSessionId = payload.session_id;
+        }
+        catch { /* malformed hook input uses startup default */ }
+        if (source !== "startup")
+            return;
+        const disabledHooks = `,${env.HQ_DISABLED_HOOKS ?? ""},`.replace(/\s/g, "");
+        if (/(^|,)auto-conduct(,|$)/.test(disabledHooks))
+            return;
+        const root = (options.resolveRoot ?? ((e, cwd) => resolveLanesHqRoot({ env: e, cwd })))(env, options.cwd);
+        const flagEnabled = await readLanesRegistryFlagFailOpen(LANE_CONDUCT_SESSION_START_FLAG, {
+            env,
+            defaultValue: true,
+            reportFailure: (error) => {
+                const kind = error instanceof Error ? error.name : "Error";
+                debug(`hq lanes session-start: flag read failed (${kind})`);
+            },
+        });
+        if (!flagEnabled)
+            return;
+        (options.startSweep ?? ((r, e) => startSessionStartOrphanSweep(r, e, spawn)))(root, env);
+        if (sessionWasDisabled(root, env, payloadSessionId))
+            return;
+        let enabled = enabledFromSettings(root);
+        if (/^(1|true|on|yes)$/i.test(env.HQ_AUTO_CONDUCT ?? ""))
+            enabled = true;
+        else if (/^(0|false|off|no)$/i.test(env.HQ_AUTO_CONDUCT ?? ""))
+            enabled = false;
+        if (!enabled)
+            return;
+        const core = path.join(root, ".claude", "skills", "conduct", "conductor-core.md");
+        if (!fs.existsSync(core))
+            return;
+        const block = extractConductorBlock(fs.readFileSync(core, "utf8"));
+        if (block)
+            stdout.write(`${block}\n`);
+    }
+    catch {
+        debug("hq lanes session-start: bootstrap failed");
+    }
+}
+export function registerLaneSessionStartCommand(lanes) {
+    lanes.command("session-start", { hidden: true })
+        .description("Internal SessionStart bootstrap")
+        .action(async () => runLaneSessionStart());
+}
+//# sourceMappingURL=lanes-session-start.js.map

package/dist/commands/lanes-shared.d.ts

@@ -1,4 +1,4 @@
-import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneHireLocks } from "../lib/lanes/index.js";
+import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneAdmissionLock, withLaneHireLocks } from "../lib/lanes/index.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import type { OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import type { CpuBusySource } from "../lib/lanes/throttle.js";
@@ -313,6 +313,7 @@ export interface Ctx {
     storyLedgerEnabled: () => boolean;
     isSsmOwnerDispatch: () => boolean;
     withGrantHireLocks: typeof withLaneHireLocks;
+    withAdmissionLock: typeof withLaneAdmissionLock;
     mergeHoldEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }

package/dist/commands/lanes-watch.d.ts

@@ -1,4 +1,6 @@
+import { type MonitorEngine } from "../lib/lanes/index.js";
 import type { Ctx, MonitorCheckOptions, LaneWaitCommandOptions, LaneWatchHandlerDeps, LaneWatchOptions } from "./lanes-shared.js";
+export declare function resolveMonitorEngine(requested: string | undefined, env: NodeJS.ProcessEnv): MonitorEngine;
 export declare function createLaneWatchHandlers(deps: LaneWatchHandlerDeps): {
     runWatch: (ctx: Ctx, laneIds: string[], opts: LaneWatchOptions) => Promise<number>;
     runMonitorCheck: (ctx: Ctx, opts: MonitorCheckOptions) => Promise<number>;

package/dist/commands/lanes-watch.js

@@ -10,8 +10,9 @@ const MONITOR_ACTIVE_LANE_STATES = new Set([
     "awaiting_input",
     "blocked",
 ]);
-function resolveMonitorEngine(requested, env) {
+export function resolveMonitorEngine(requested, env) {
     const value = requested?.trim().toLowerCase() ||
+        env.HQ_LANE_ENGINE?.trim().toLowerCase() ||
         env.HQ_CONDUCT_ENGINE?.trim().toLowerCase() ||
         "claude";
     if (!MONITOR_ENGINES.includes(value)) {

package/dist/commands/lanes.d.ts

@@ -17,7 +17,7 @@ export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/
 export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents } from "../lib/lanes/mesh-events.js";
-import { MAX_LANE_DEPTH, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
+import { MAX_LANE_DEPTH, withLaneAdmissionLock, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { type RunCompactionFn } from "../lib/lanes/compaction.js";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
@@ -106,6 +106,8 @@ export interface LanesCommandDeps {
     isSsmOwnerDispatch?: () => boolean;
     /** Test seam for changing a lane between pre-lock and locked grant reads. */
     withGrantHireLocks?: typeof withLaneHireLocks;
+    /** Test seam proving create admission encloses the worker busy check. */
+    withAdmissionLock?: typeof withLaneAdmissionLock;
     /** Test seam for the review-before-merge registry flag. */
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
     /** Test seam for the repository-merge-hold registry flag. */

package/dist/commands/lanes.js

@@ -33,13 +33,16 @@ import { registerLaneReviewCommand } from "./lanes-review.js";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { withCliFeatureUsed } from "../utils/cli-telemetry.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { registerLaneSessionStartCommand } from "./lanes-session-start.js";
 import { laneDepthCap } from "../lib/lanes/depth-cap.js";
 import { isSsmRunCommandProcess } from "../lib/lanes/ssm-command-context.js";
 import { runResidentCommandWithPackageLease } from "../utils/resident-package-preload.js";
 import { readLanesFlagLocalOverride, readLanesRegistryFlag, readLanesRegistryFlagFailOff, readLanesRegistryFlagFailOpen } from "../lib/lanes/registry-flag.js";
+import { readLaneStatusRowFields } from "../lib/lanes/status-fields.js";
 import { appendProjectFocusOverride, readProjectStoryFocusData, removeProjectFocusOverride } from "../lib/lanes/story-ledger.js";
 import { appendLaneFocusOverride, assertFocusGuardAllows, makeFocusOverride } from "../lib/lanes/focus-guard.js";
-import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, } from "../lib/lanes/flag-keys.js";
+import { LANE_FOCUS_GUARD_FLAG, LANE_FOCUS_DASHBOARD_FLAG, LANE_HIRE_GRANT_FINISHED_LANES_FLAG, LANE_LIST_SKIP_REMOTE_REFRESH_FLAG, LANE_MESSAGE_ROUTE_OWNER_HOST_FLAG, LANE_ORPHANED_BARE_ID_DROPBOX_REPAIR_FLAG, LANE_PROFILE_PIN_EXHAUSTED_FALLBACK_FLAG, LANE_STATUS_ROW_FIELDS_FLAG, LANE_REAP_STOP_FLAG, LANE_REUSE_REFRESHES_PROFILE_FLAG, LANE_WORKER_CONTINUITY_FLAG, } from "../lib/lanes/flag-keys.js";
+import { findWorkerContinuityLane, sameLaneHost, workerContinuityPrompt } from "../lib/lanes/worker-continuity.js";
 import { configuredCodexRolloutHomes, retainCodexRollouts } from "../lib/lanes/disk-guard.js";
 import { isControllerAliasOutpostId } from "../lib/lanes/admission-host.js";
 import { runLeadAutopilotPass } from "../lib/lanes/autopilot.js";
@@ -461,6 +464,7 @@ function resolveDeps(deps = {}) {
         focusGuardEnabled: deps.focusGuardEnabled,
         isSsmOwnerDispatch: deps.isSsmOwnerDispatch ?? (() => isSsmRunCommandProcess()),
         withGrantHireLocks: deps.withGrantHireLocks ?? withLaneHireLocks,
+        withAdmissionLock: deps.withAdmissionLock ?? withLaneAdmissionLock,
         mergeReviewEnabled: deps.mergeReviewEnabled,
         mergeHoldEnabled: deps.mergeHoldEnabled,
     };
@@ -3364,6 +3368,16 @@ async function runCreate(ctx, opts) {
     const provider = explicitProvider ??
         profile?.meta.provider ??
         parseLaneProvider("codex");
+    const continuityEnabled = opts.worker !== undefined && await readLanesRegistryFlagFailOpen(LANE_WORKER_CONTINUITY_FLAG, { company: company ?? meshCompany, env: ctx.env });
+    let workerContinuity = continuityEnabled
+        ? findWorkerContinuityLane(loadAllLanes(hqRoot), {
+            senior,
+            worker: resolvedWorker?.id ?? opts.worker,
+            provider,
+            company: company ?? meshCompany,
+            freshThread: opts.freshThread,
+        })
+        : { resumable: false };
     const profileDefaultsApply = profile !== undefined && profile.meta.provider === provider;
     const cliModel = parseCliModel(opts.model);
     // Validated here because `claude --effort <unknown>` only warns and runs.
@@ -3738,6 +3752,24 @@ async function runCreate(ctx, opts) {
     // The lane id is created in `persist`; its Work Mesh thread is ensured
     // immediately afterward from that stable identity.
     const persist = async () => {
+        const host = placementHostOverride ?? (outpostId !== undefined
+            ? { kind: "outpost", id: outpostId }
+            : { kind: "local", id: ctx.hostname() });
+        // Repeat the busy check while holding provider admission serialization so
+        // two concurrent creates cannot both claim one worker's provider thread.
+        if (continuityEnabled) {
+            workerContinuity = findWorkerContinuityLane(loadAllLanes(hqRoot), {
+                senior,
+                worker: resolvedWorker?.id ?? opts.worker,
+                provider,
+                company: company ?? meshCompany,
+                freshThread: opts.freshThread,
+            });
+            if (workerContinuity.resumable && workerContinuity.previous &&
+                !sameLaneHost(workerContinuity.previous.host, host)) {
+                workerContinuity = { previous: workerContinuity.previous, resumable: false, fallbackReason: "host_mismatch" };
+            }
+        }
         let admission;
         let validation;
         if (!outpostId && provider === "claude" && explicitBalanceAccount === undefined &&
@@ -3841,9 +3873,6 @@ async function runCreate(ctx, opts) {
                 throw admission.error;
             }
         }
-        const host = placementHostOverride ?? (outpostId !== undefined
-            ? { kind: "outpost", id: outpostId }
-            : { kind: "local", id: ctx.hostname() });
         const queuedReason = admission.action === "queue" ? admission.reason : undefined;
         const admissionReservedAt = admission.action === "start" ? ctx.now().toISOString() : undefined;
         const laneInit = {
@@ -3887,6 +3916,18 @@ async function runCreate(ctx, opts) {
             keep_alive: keepAlive,
             ...(keepAlive ? { keep_alive_opted_in_at: createdAt } : {}),
             provider,
+            ...(workerContinuity.resumable && workerContinuity.previous
+                ? {
+                    provider_session_id: workerContinuity.previous.provider_session_id,
+                    last_message_at: workerContinuity.previous.last_message_at ?? workerContinuity.previous.created_at,
+                    pending_resume: {
+                        session_id: workerContinuity.previous.provider_session_id,
+                        at: createdAt,
+                        trigger: "resume",
+                        resumed_from: workerContinuity.previous.state,
+                    },
+                }
+                : {}),
             provider_source: explicitProvider !== undefined
                 ? "cli"
                 : profile?.meta.provider !== undefined
@@ -3956,12 +3997,7 @@ async function runCreate(ctx, opts) {
         return { lane, admission, validation };
     };
     let persisted;
-    if (outpostId) {
-        persisted = await persist();
-    }
-    else {
-        persisted = await withLaneAdmissionLock(hqRoot, provider, persist, ctx.sleep);
-    }
+    persisted = await ctx.withAdmissionLock(hqRoot, provider, persist, ctx.sleep);
     let lane = persisted.lane;
     const { admission, validation } = persisted;
     if (focusAssessment.enabled && opts.focusOverride !== undefined) {
@@ -4051,10 +4087,25 @@ async function runCreate(ctx, opts) {
     ensureDir(path.join(dest, "dropbox"));
     ensureDir(path.join(dest, "questions"));
     const taskBrief = fs.readFileSync(briefAbs, "utf8");
-    const briefText = resolvedWorker
+    const previousResult = workerContinuity.previous
+        ? readLatestEnvelopeRecord(hqRoot, workerContinuity.previous.lane_id)
+        : undefined;
+    const briefText = `${workerContinuity.resumable && workerContinuity.previous
+        ? workerContinuityPrompt(workerContinuity.previous, previousResult?.envelope.summary, previousResult?.ref)
+        : ""}${resolvedWorker
         ? composeWorkerBrief(resolvedWorker, taskBrief)
-        : composeGeneralBrief(taskBrief);
+        : composeGeneralBrief(taskBrief)}`;
     fs.writeFileSync(path.join(dest, "brief.md"), briefText);
+    if (workerContinuity.resumable && lane.pending_resume) {
+        const newBriefPath = path.join(dest, "brief.md");
+        lane = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+            ...current,
+            pending_resume: current.pending_resume ? {
+                ...current.pending_resume,
+                text: `The new brief at ${newBriefPath} is the instruction for this turn. Read and follow it.`,
+            } : undefined,
+        }));
+    }
     if (timeoutSecs !== undefined) {
         writeJsonFile(timeoutPath(hqRoot, lane.lane_id), {
             timeout_secs: timeoutSecs,
@@ -4121,6 +4172,16 @@ async function runCreate(ctx, opts) {
             stories: laneStories(started),
             story_warning: combinedStoryWarning(started, createStoryWarnings),
             thread_id: started.thread_id ?? null,
+            ...(continuityEnabled ? {
+                worker_continuity: workerContinuity.resumable
+                    ? { action: "resume", previous_lane_id: workerContinuity.previous?.lane_id }
+                    : {
+                        action: "fresh",
+                        ...(workerContinuity.previous ? { previous_lane_id: workerContinuity.previous.lane_id } : {}),
+                        ...(opts.freshThread ? { reason: "fresh_thread_requested" } : {}),
+                        ...(workerContinuity.fallbackReason ? { reason: workerContinuity.fallbackReason } : {}),
+                    },
+            } : {}),
             senior: started.senior,
             depth: started.depth,
             timeout_secs: timeoutSecs ?? null,
@@ -5342,6 +5403,24 @@ async function runPickup(ctx, opts) {
         lane: started,
     });
 }
+async function laneStatusFieldsForCommand(ctx, hqRoot, lane, now) {
+    const resolved = resolveLaneCompany(hqRoot, lane).company;
+    let enabled = true;
+    try {
+        enabled = await readLanesRegistryFlagFailOpen(LANE_STATUS_ROW_FIELDS_FLAG, {
+            ...(resolved ? { company: resolved } : {}),
+            env: ctx.env,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: status row fields flag read failed open: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    if (!enabled)
+        return {};
+    const host = reconcileHostFromCtx(ctx);
+    const local = laneRunsHere(lane, host);
+    return { ...readLaneStatusRowFields(hqRoot, lane, now.getTime(), local) };
+}
 async function runList(ctx, opts) {
     if (opts.json && opts.human) {
         throw new LanesError("conflicting_output_format", "Use either --json or --human for hq lanes list", { json: true, human: true });
@@ -5364,7 +5443,7 @@ async function runList(ctx, opts) {
             new Set(opts.hierarchy).size !== opts.hierarchy.length)) {
         throw new LanesError("lane_list_hierarchy_invalid", "--hierarchy must be repeated with distinct, non-empty lane ids without surrounding whitespace", {});
     }
-    if (opts.snapshot && (opts.human || opts.company || opts.project || opts.story || opts.state || opts.senior)) {
+    if (opts.snapshot && (opts.human || opts.company || opts.project || opts.story || opts.state || opts.senior || opts.worker)) {
         throw new LanesError("lane_list_snapshot_invalid", "--snapshot only supports owner lane filters and JSON output", {});
     }
     if (opts.hierarchy !== undefined && !opts.snapshot) {
@@ -5413,21 +5492,29 @@ async function runList(ctx, opts) {
         }
         if (senior && seniorKey(lane.senior) !== seniorKey(senior))
             return false;
+        if (opts.worker && lane.worker !== opts.worker)
+            return false;
         return true;
     };
     const selectLanes = () => laneSource
         .filter((lane) => matchesLaneFilters(lane, true))
         .sort(compareLaneQueueOrder);
     let selectedLanes = selectLanes();
+    const statusFieldsByLane = new Map();
+    const statusNow = ctx.now();
+    await Promise.all(selectedLanes.map(async (lane) => {
+        statusFieldsByLane.set(lane.lane_id, await laneStatusFieldsForCommand(ctx, hqRoot, lane, statusNow));
+    }));
     if (opts.snapshot) {
         printJson({
             ok: true,
             action: "list",
             lanes: selectedLanes.map((lane) => {
+                const fields = statusFieldsByLane.get(lane.lane_id) ?? {};
                 if (!isTerminalLaneState(lane.state))
-                    return lane;
+                    return { ...lane, ...fields };
                 const envelope = readLatestEnvelopeRecord(hqRoot, lane.lane_id)?.envelope;
-                return envelope?.summary ? { ...lane, envelope_summary: envelope.summary } : lane;
+                return { ...lane, ...fields, ...(envelope?.summary ? { envelope_summary: envelope.summary } : {}) };
             }),
         });
         return;
@@ -5531,6 +5618,7 @@ async function runList(ctx, opts) {
             !laneRunsHere(lane, host);
         return {
             ...lane,
+            ...statusFieldsByLane.get(lane.lane_id),
             ...hireByLane.get(lane.lane_id),
             ...(remoteRefresh.unverifiedRemote.has(lane.lane_id) ? { unverified_remote: true } : {}),
             stories: laneStories(lane),
@@ -5900,7 +5988,10 @@ async function runShow(ctx, laneId, hasPendingQuestionForLane, resolveLaneTarget
     })
         .slice(0, 20)
         .map(({ repo, pr, head_sha, recorded_at }) => ({ repo, pr, head_sha, recorded_at }));
-    const laneForShow = { ...lane };
+    const laneForShow = {
+        ...lane,
+        ...await laneStatusFieldsForCommand(ctx, hqRoot, storedLane, ctx.now()),
+    };
     delete laneForShow.resume_history;
     printJson({
         ok: true,
@@ -9234,8 +9325,9 @@ export function registerLanesCommand(parent, deps = {}) {
         timeoutPath,
     });
     const lanes = parent
-        .command("lanes", { hidden: true })
+        .command("lanes")
         .description("Create, supervise, and steer worker lanes; routed decision queue");
+    registerLaneSessionStartCommand(lanes);
     registerLaneChecksCommand(lanes, {
         hqRoot: ctx.hqRoot,
         resolveCompany: ctx.resolveCompany,
@@ -9246,6 +9338,15 @@ export function registerLanesCommand(parent, deps = {}) {
             presenceConnected: ctx.presenceConnected ?? false,
             deps: ctx.livenessDeps,
         }),
+        stopEnabled: (lane) => {
+            const resolution = resolveLaneCompany(ctx.hqRoot(), lane);
+            const company = resolution.company ?? undefined;
+            return readLanesRegistryFlag(LANE_REAP_STOP_FLAG, {
+                company,
+                ...(company ? { companyUidSource: laneCompanyUidSource(resolution.source) } : {}),
+                env: ctx.env,
+            });
+        },
     }, wrap);
     registerLaneDropboxRepairCommand(lanes, {
         hqRoot: ctx.hqRoot,
@@ -9311,6 +9412,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--additional-story <id>", "Additional story carried by this lane; repeatable and discouraged when active", collectRepeatable)
         .requiredOption("--brief-file <path>", "Path to the lane brief")
         .option("--worker <name>", "HQ worker or reusable profile id")
+        .option("--fresh-thread", "Skip worker continuity and start a cold provider session")
         .option("--provider <name>", "claude | codex | grok")
         .option("--account <id>", "Provider account id")
         .option("--model <id>", "Model id for the provider CLI")
@@ -9410,6 +9512,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Filter by story")
         .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
         .option("--senior <ref>", "Filter by senior ref")
+        .option("--worker <id>", "Filter by worker id")
         .option("--lane <id>", "Filter by lane id (repeatable)", (value, previous = []) => [...previous, value], [])
         .addOption(new Option("--lane-ulid <ulid>", "Filter by lane ULID for internal owner lookup").hideHelp()
         .argParser((value, previous = []) => [...previous, value]))
@@ -9506,7 +9609,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("monitor-check")
         .description("Check that active Claude senior lanes have live Monitor watch tasks")
         .option("--session <id>", "Senior session id")
-        .option("--engine <engine>", "claude | codex | grok; defaults to HQ_CONDUCT_ENGINE or claude")
+        .option("--engine <engine>", "claude | codex | grok; defaults to HQ_LANE_ENGINE (HQ_CONDUCT_ENGINE is deprecated) or claude")
         .option("--reminder", "Print the senior Monitor reminder text")
         .option("--json", "JSON on stdout")
         .action(wrapText(async (opts) => watchHandlers.runMonitorCheck(ctx, opts)));

package/dist/commands/members.d.ts

@@ -48,6 +48,8 @@ export interface InviteOptions {
     companyUid: string;
     callerUid: string;
     token: string;
+    /** Reports only whether the request returned a 2xx response. */
+    onRequestResult?: (ok: boolean) => void;
 }
 /**
  * Outcome of `hq members invite`. Two shapes depending on server schema:
@@ -96,6 +98,8 @@ export interface ResendInviteOptions {
     companyUid: string;
     callerUid: string;
     token: string;
+    /** Reports only whether the request returned a 2xx response. */
+    onRequestResult?: (ok: boolean) => void;
 }
 /**
  * Outcome of `hq members invite --resend`. No new membership row was

package/dist/commands/members.js

@@ -3,6 +3,7 @@ import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
 import { gateApiKeyCapabilities } from "../utils/api-key-command-gate.js";
 import { vaultApiFetch, getCompanyUid } from "../utils/vault-api.js";
 import { isPlanGateError } from "../utils/plan-gate-error.js";
+import { queueCliFeatureUsed } from "../utils/cli-telemetry.js";
 const EMAIL_PATTERN = /^[^\s]+@[^\s]+$/;
 const PERSON_UID_PATTERN = /^prs_[A-Za-z0-9_-]+$/;
 const AGENT_UID_PATTERN = /^agt_[A-Za-z0-9_-]+$/i;
@@ -107,6 +108,7 @@ export async function inviteMember(options) {
         body,
     });
     if (!res.ok) {
+        options.onRequestResult?.(false);
         const err = (await res.json().catch(() => ({})));
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
@@ -116,6 +118,7 @@ export async function inviteMember(options) {
         throw new Error(`Invite endpoint returned 2xx with no membership row (response keys: ${keys}). ` +
             "This is a server-side regression — file an issue.");
     }
+    options.onRequestResult?.(true);
     // Two server schemas in the wild:
     //   - Legacy (schemaVersion ≤ 1): response carries a random `inviteToken`
     //     the invitee redeems via `hq://accept/{token}`.
@@ -177,6 +180,7 @@ export async function resendInvite(options) {
         },
     });
     if (!res.ok) {
+        options.onRequestResult?.(false);
         const err = (await res.json().catch(() => ({})));
         throw new InviteHttpError(res.status, err.message ?? err.error ?? res.statusText, err.code);
     }
@@ -184,6 +188,7 @@ export async function resendInvite(options) {
     if (data.resent !== true) {
         throw new Error("Resend endpoint returned 2xx without `resent: true` — the connected hq-pro likely doesn't support `resend: true` yet. Upgrade hq-pro or re-invite without --resend.");
     }
+    options.onRequestResult?.(true);
     return {
         resent: true,
         emailSent: data.emailSent === true,
@@ -436,6 +441,7 @@ export function registerMembersCommand(program) {
         let token;
         let companyUid;
         let companySlug;
+        let outcome = "failure";
         try {
             token = (await resolveVaultCredential()).token;
             companySlug = members.opts().company;
@@ -448,6 +454,9 @@ export function registerMembersCommand(program) {
                     companyUid,
                     callerUid,
                     token,
+                    onRequestResult: (ok) => {
+                        outcome = ok ? "success" : "failure";
+                    },
                 });
                 console.log(chalk.green(`Re-fired invite email for ${target.toLowerCase()} (existing pending row left untouched)`));
                 console.log();
@@ -472,6 +481,9 @@ export function registerMembersCommand(program) {
                 companyUid,
                 callerUid,
                 token,
+                onRequestResult: (ok) => {
+                    outcome = ok ? "success" : "failure";
+                },
             });
             const agentTarget = detectTarget(target)?.isAgent === true;
             console.log(chalk.green(`Invited ${target} as ${result.membership.role} (status: ${result.membership.status})`));
@@ -612,10 +624,19 @@ export function registerMembersCommand(program) {
             }
             if (err instanceof InviteHttpError) {
                 console.error(chalk.red(formatInviteHttpError(err.status, err.message, err.code)));
-                process.exit(1);
+                process.exitCode = 1;
+                return;
             }
             console.error(chalk.red("Error:"), err instanceof Error ? err.message : String(err));
-            process.exit(1);
+            process.exitCode = 1;
+            return;
+        }
+        finally {
+            queueCliFeatureUsed({
+                kind: "members_invite",
+                outcome,
+                ...(companyUid ? { companyUid } : {}),
+            });
         }
     });
     members