@indigoai-us/hq-cli 5.125.0 → 5.127.0

package/dist/commands/lanes.js

@@ -0,0 +1,2969 @@
+/**
+ * `hq lanes` — worker lane management and decision queue (spec §5–§7, §10–§11).
+ *
+ * Every command prints JSON on stdout and takes no interactive input, except
+ * `accounts login`, which hands the terminal to the vendor's own sign-in.
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { parseUserYaml } from "../utils/user-yaml-error.js";
+import { vaultApiFetch } from "../utils/vault-api.js";
+import { openMeshTransport } from "../lib/mesh/client.js";
+import { createLaneMesh, emitLaneDecisionEvents, } from "../lib/lanes/mesh-events.js";
+import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
+import { AccountResolutionError, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountMaxRunning, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, isLoggedOut, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { questionBodyAbsPath } from "../lib/lanes/questions.js";
+import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
+import { providerCompactAfterMs } from "../lib/lanes/config.js";
+import { parseCliEffort, resolveLaneEffort } from "../lib/lanes/effort.js";
+import { LanesError } from "../lib/lanes/errors.js";
+import { accountQuotaView, loadQuotaState } from "../lib/lanes/quota.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+export { spawnLaneWorker };
+export { questionBodyAbsPath };
+export const MAX_LANE_DEPTH = 2;
+export const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
+export const OUTPOST_DIR = "/etc/outpost";
+export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
+const VENDOR_LOGIN = {
+    claude: { command: "claude", args: ["auth", "login"] },
+    codex: { command: "codex", args: ["login"] },
+    grok: { command: "grok", args: ["login"] },
+};
+export { emitLaneDecisionEvents };
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function failJson(err) {
+    if (isLanesError(err)) {
+        printJson(err.toJSON());
+        process.exit(1);
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`hq lanes: ${message}${err instanceof Error && err.stack ? `\n${err.stack}` : ""}\n`);
+    printJson({ error: "internal", message });
+    process.exit(1);
+}
+function wrap(action) {
+    return async (...args) => {
+        try {
+            await action(...args);
+        }
+        catch (err) {
+            failJson(err);
+        }
+    };
+}
+function collectRepeatable(value, previous = []) {
+    return previous.concat(value);
+}
+async function defaultResolveCompany(company) {
+    const { company: mesh } = await openMeshTransport({ company });
+    return { slug: mesh.companySlug, uid: mesh.companyUid };
+}
+function defaultOutpostsClient() {
+    return createOutpostsClient({
+        transport: vaultApiFetch,
+        token: () => ensureCognitoToken({ interactive: false }),
+    });
+}
+async function defaultListOutpostIds() {
+    const rows = await defaultOutpostsClient().list();
+    return rows.map((row) => row.outpostId);
+}
+async function defaultStageOutpostPayload(outpostId, bytes) {
+    return stageOutpostPayload(defaultOutpostsClient(), outpostId, bytes);
+}
+async function defaultDispatchOutpostExec(input) {
+    try {
+        return await dispatchOutpostPickup(defaultOutpostsClient(), input);
+    }
+    catch (err) {
+        if (err instanceof LanesError)
+            throw err;
+        throw new LanesError("outpost_dispatch_failed", `Outpost exec failed: ${dispatchErrorMessage(err)}`, { outpost_id: input.outpostId, message: dispatchErrorMessage(err) });
+    }
+}
+async function defaultFetchText(url) {
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new LanesError("outpost_payload_invalid", `Failed to download pickup payload: HTTP ${res.status}`, { status: res.status });
+    }
+    return res.text();
+}
+export function readOutpostIdentity(existsSync = (p) => fs.existsSync(p), readFileSync = (p) => fs.readFileSync(p, "utf8")) {
+    const hasMarker = existsSync(OUTPOST_ID_PATH);
+    const hasDir = existsSync(OUTPOST_DIR);
+    if (hasMarker) {
+        let text;
+        try {
+            text = readFileSync(OUTPOST_ID_PATH);
+        }
+        catch (err) {
+            process.stderr.write(`hq lanes: failed to read ${OUTPOST_ID_PATH}: ${err instanceof Error ? err.message : String(err)}\n`);
+            throw err;
+        }
+        const id = text.trim();
+        if (!id)
+            return hasDir ? { kind: "unknown" } : { kind: "not_outpost" };
+        return { kind: "id", id };
+    }
+    if (hasDir)
+        return { kind: "unknown" };
+    return { kind: "not_outpost" };
+}
+function defaultSpawnLogin(opts) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(opts.command, opts.args, {
+            env: opts.env,
+            cwd: opts.cwd,
+            stdio: "inherit",
+        });
+        child.on("error", (err) => {
+            reject(err);
+        });
+        child.on("close", (code) => {
+            resolve({ status: code ?? 1 });
+        });
+    });
+}
+function createDefaultMesh() {
+    // Interactive: the command runs in the operator's shell, where a browser
+    // login is acceptable. The watcher builds its own non-interactive mesh.
+    return createLaneMesh({ interactive: true });
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function resolveCallerPath(callerCwd, filePath) {
+    return path.resolve(callerCwd, filePath);
+}
+function resolveDeps(deps = {}) {
+    const env = deps.env ?? process.env;
+    const cwd = deps.cwd ?? (() => process.cwd());
+    let capturedCallerCwd;
+    const callerCwd = () => {
+        if (capturedCallerCwd === undefined)
+            capturedCallerCwd = cwd();
+        return capturedCallerCwd;
+    };
+    const bindProcessCwd = deps.hqRoot === undefined;
+    const resolveRoot = deps.hqRoot ?? (() => resolveLanesHqRoot({ env, cwd: cwd() }));
+    const hqRoot = () => {
+        callerCwd();
+        const root = resolveRoot();
+        if (bindProcessCwd && process.cwd() !== root) {
+            process.chdir(root);
+        }
+        return root;
+    };
+    return {
+        cwd,
+        callerCwd,
+        hqRoot,
+        env,
+        now: deps.now ?? (() => new Date()),
+        hostname: deps.hostname ?? (() => os.hostname()),
+        resolveCompany: deps.resolveCompany ?? defaultResolveCompany,
+        listOutpostIds: deps.listOutpostIds ?? defaultListOutpostIds,
+        readOutpostIdentity: deps.readOutpostIdentity ?? (() => readOutpostIdentity()),
+        spawnLogin: deps.spawnLogin ?? defaultSpawnLogin,
+        throttleDeps: deps.throttleDeps ?? defaultThrottleDeps(env),
+        existsSync: deps.existsSync ?? ((p) => fs.existsSync(p)),
+        readFileSync: deps.readFileSync ?? ((p, encoding) => fs.readFileSync(p, encoding)),
+        homedir: deps.homedir ?? (() => os.homedir()),
+        mesh: deps.mesh ?? createDefaultMesh(),
+        sleep: deps.sleep ?? defaultSleep,
+        spawnProcess: deps.spawnProcess,
+        proveDetached: deps.proveDetached,
+        killProcess: deps.killProcess,
+        isAlive: deps.isAlive,
+        stopSleepMs: deps.stopSleepMs,
+        livenessDeps: deps.livenessDeps,
+        presenceConnected: deps.presenceConnected,
+        systemdRoot: deps.systemdRoot,
+        runSystemctl: deps.runSystemctl ??
+            ((command, args) => {
+                const result = spawnSync(command, args, { encoding: "utf8" });
+                return {
+                    status: result.status ?? 1,
+                    stdout: result.stdout ?? "",
+                    stderr: result.stderr ??
+                        (result.error instanceof Error ? result.error.message : ""),
+                };
+            }),
+        resolveMachineIdentity: deps.resolveMachineIdentity ?? lookupMachineIdentity,
+        runCompaction: deps.runCompaction,
+        locateTranscript: deps.locateTranscript,
+        stageOutpostPayload: deps.stageOutpostPayload ?? defaultStageOutpostPayload,
+        dispatchOutpostExec: deps.dispatchOutpostExec ?? defaultDispatchOutpostExec,
+        fetchText: deps.fetchText ?? defaultFetchText,
+    };
+}
+function livenessDepsFromCtx(ctx) {
+    const base = ctx.livenessDeps ?? defaultLivenessDeps();
+    return {
+        ...base,
+        now: () => ctx.now().getTime(),
+        homedir: ctx.homedir,
+        env: ctx.env,
+        existsSync: ctx.existsSync,
+        readFileSync: ctx.readFileSync,
+    };
+}
+function reconcileHostFromCtx(ctx) {
+    const identity = ctx.readOutpostIdentity();
+    return {
+        hostname: ctx.hostname(),
+        outpostId: identity.kind === "id" ? identity.id : null,
+    };
+}
+export function parseSeniorRef(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        throw new LanesError("unknown_senior_kind", `Unknown senior ref ${JSON.stringify(raw)}. Accepted kinds: ${SENIOR_KINDS.join(", ")}`, { accepted: [...SENIOR_KINDS], value: raw });
+    }
+    if (trimmed === "user")
+        return { kind: "user" };
+    const colon = trimmed.indexOf(":");
+    if (colon <= 0) {
+        throw new LanesError("unknown_senior_kind", `Unknown senior ref ${JSON.stringify(raw)}. Accepted kinds: ${SENIOR_KINDS.join(", ")}`, { accepted: [...SENIOR_KINDS], value: raw });
+    }
+    const kindRaw = trimmed.slice(0, colon);
+    const id = trimmed.slice(colon + 1);
+    const kind = parseSeniorKind(kindRaw);
+    if (kind === "user") {
+        if (id.length > 0) {
+            throw new LanesError("invalid_senior_ref", "Senior kind user takes no id", { value: raw });
+        }
+        return { kind: "user" };
+    }
+    if (id.length === 0) {
+        throw new LanesError("invalid_senior_ref", `Senior kind ${kind} requires an id (got ${JSON.stringify(raw)})`, { kind, value: raw });
+    }
+    return { kind, id };
+}
+function seniorKey(ref) {
+    return ref.kind === "user" ? "user" : `${ref.kind}:${ref.id ?? ""}`;
+}
+export function resolveAnswerChoice(choice, options, freeform) {
+    const trimmed = choice.trim();
+    if (/^[0-9]+$/.test(trimmed)) {
+        const index = Number(trimmed);
+        if (Number.isInteger(index) && index >= 1 && index <= options.length) {
+            return options[index - 1];
+        }
+    }
+    if (options.includes(trimmed) || options.includes(choice)) {
+        return options.includes(trimmed) ? trimmed : choice;
+    }
+    if (freeform)
+        return choice;
+    throw new LanesError("off_menu_choice", `Choice ${JSON.stringify(choice)} is not on the menu. Pass --freeform to allow it.`, { choice, options });
+}
+function parsePriority(raw) {
+    if (raw === undefined || raw === null || raw === "")
+        return 1;
+    const n = typeof raw === "number" ? raw : Number(String(raw));
+    if (!Number.isInteger(n)) {
+        throw new LanesError("invalid_priority", `--priority must be an integer`, {
+            value: raw,
+        });
+    }
+    return n;
+}
+function parseOptionalInt(raw, flag) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    const n = typeof raw === "number" ? raw : Number(String(raw));
+    if (!Number.isInteger(n) || n < 0) {
+        throw new LanesError("invalid_integer", `${flag} must be a non-negative integer`, { flag, value: raw });
+    }
+    return n;
+}
+function runDir(hqRoot, laneId) {
+    return path.join(hqRoot, LANES_RUNS_REL, laneId);
+}
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function writeJsonFile(filePath, value) {
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function readJsonFile(filePath) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+function parseQuestionBody(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const options = Array.isArray(obj.options)
+        ? obj.options.filter((item) => typeof item === "string")
+        : [];
+    const body = {
+        question: typeof obj.question === "string" ? obj.question : "",
+        context: typeof obj.context === "string" ? obj.context : "",
+        options,
+    };
+    if (typeof obj.recommended === "string")
+        body.recommended = obj.recommended;
+    if (typeof obj.notes === "string")
+        body.notes = obj.notes;
+    return body;
+}
+function readQuestionBodyFile(hqRoot, question) {
+    const filePath = questionBodyAbsPath(hqRoot, question);
+    let serialized;
+    try {
+        serialized = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return null;
+        throw err;
+    }
+    const digest = sha256Text(serialized);
+    let parsed;
+    try {
+        parsed = JSON.parse(serialized);
+    }
+    catch (err) {
+        throw new LanesError("question_body_unreadable", `Question body at ${filePath} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`, { question_id: question.question_id, path: filePath });
+    }
+    const body = parseQuestionBody(parsed);
+    if (!body) {
+        throw new LanesError("question_body_unreadable", `Question body at ${filePath} is not an object`, { question_id: question.question_id, path: filePath });
+    }
+    return { body, digest, serialized };
+}
+function readQuestionBody(hqRoot, question) {
+    const stored = readQuestionBodyFile(hqRoot, question);
+    if (!stored)
+        return null;
+    if (question.body.digest && stored.digest !== question.body.digest) {
+        throw new LanesError("question_body_digest_mismatch", `Question body digest does not match the routing record for ${question.question_id}`, {
+            question_id: question.question_id,
+            expected: question.body.digest,
+            actual: stored.digest,
+        });
+    }
+    return stored.body;
+}
+function requireQuestionBody(hqRoot, question) {
+    const body = readQuestionBody(hqRoot, question);
+    if (!body) {
+        throw new LanesError("question_body_unavailable", `Question body is not available on this host for ${question.question_id}`, {
+            question_id: question.question_id,
+            store: question.body.store,
+            ref: question.body.ref,
+        });
+    }
+    return body;
+}
+function loadAllLanes(hqRoot) {
+    return listLaneIds(hqRoot).map((id) => readLane(hqRoot, id));
+}
+function loadAllQuestions(hqRoot) {
+    return listQuestionIds(hqRoot).map((id) => readQuestion(hqRoot, id));
+}
+function sessionMetaPath(hqRoot, sessionId) {
+    return path.join(hqRoot, "workspace", "sessions", sessionId, "meta.yaml");
+}
+function loadSessionMeta(hqRoot, sessionId, ctx) {
+    const filePath = sessionMetaPath(hqRoot, sessionId);
+    if (!ctx.existsSync(filePath))
+        return { status: "missing" };
+    let text;
+    try {
+        text = ctx.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: failed to read session meta ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        return { status: "unreadable" };
+    }
+    let doc;
+    try {
+        doc = parseUserYaml(text, filePath);
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: failed to parse session meta ${filePath}: ${err instanceof Error ? err.message : String(err)}\n`);
+        return { status: "malformed" };
+    }
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc)) {
+        return { status: "malformed" };
+    }
+    return { status: "ok", doc: doc };
+}
+function readSessionMeta(hqRoot, sessionId, ctx) {
+    const loaded = loadSessionMeta(hqRoot, sessionId, ctx);
+    if (loaded.status !== "ok")
+        return null;
+    return loaded.doc;
+}
+function seniorOfSession(hqRoot, sessionId, ctx) {
+    const meta = readSessionMeta(hqRoot, sessionId, ctx);
+    if (!meta)
+        return { kind: "user" };
+    const senior = meta.senior;
+    if (typeof senior === "string" && senior.trim()) {
+        return parseSeniorRef(senior);
+    }
+    if (senior !== null && typeof senior === "object" && !Array.isArray(senior)) {
+        const rec = senior;
+        const kind = parseSeniorKind(rec.kind);
+        if (kind === "user")
+            return { kind: "user" };
+        if (typeof rec.id === "string" && rec.id.length > 0) {
+            return { kind, id: rec.id };
+        }
+        throw new LanesError("invalid_senior_ref", `Session ${sessionId} senior is missing an id`, { session_id: sessionId });
+    }
+    return { kind: "user" };
+}
+function seniorExists(hqRoot, ref, ctx) {
+    if (ref.kind === "user")
+        return true;
+    if (!ref.id)
+        return false;
+    if (ref.kind === "lane")
+        return tryReadLane(hqRoot, ref.id) !== null;
+    const dir = path.join(hqRoot, "workspace", "sessions", ref.id);
+    if (ctx.existsSync(dir))
+        return true;
+    try {
+        const index = loadLivenessIndex(hqRoot);
+        return index.sessions[ref.id] !== undefined;
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: liveness index read failed while checking session ${ref.id}: ${err instanceof Error ? err.message : String(err)}\n`);
+        throw err;
+    }
+}
+function assertSeniorExists(hqRoot, ref, ctx) {
+    if (seniorExists(hqRoot, ref, ctx))
+        return;
+    throw new LanesError("unknown_senior", `Senior ${seniorKey(ref)} does not exist`, { senior: ref });
+}
+function depthOfRef(hqRoot, ref, ctx, visited = new Set(), override) {
+    if (ref.kind === "user")
+        return 0;
+    const key = seniorKey(ref);
+    if (visited.has(key)) {
+        throw new LanesError("senior_cycle", `Cycle in senior chain at ${key}`, {
+            at: ref,
+        });
+    }
+    visited.add(key);
+    if (ref.kind === "lane" && override && ref.id === override.laneId) {
+        return override.depth;
+    }
+    if (ref.kind === "session") {
+        if (!ref.id) {
+            throw new LanesError("invalid_senior_ref", "Session senior is missing an id", {
+                senior: ref,
+            });
+        }
+        return depthOfRef(hqRoot, seniorOfSession(hqRoot, ref.id, ctx), ctx, visited, override) + 1;
+    }
+    if (!ref.id) {
+        throw new LanesError("invalid_senior_ref", "Lane senior is missing an id", {
+            senior: ref,
+        });
+    }
+    const lane = readLane(hqRoot, ref.id);
+    return depthOfRef(hqRoot, lane.senior, ctx, visited, override) + 1;
+}
+function derivedLaneDepth(hqRoot, senior, ctx, override) {
+    return depthOfRef(hqRoot, senior, ctx, new Set(), override) + 1;
+}
+function callerDepth(hqRoot, ctx) {
+    const laneId = ctx.env.HQ_LANE_ID?.trim();
+    if (laneId) {
+        const lane = tryReadLane(hqRoot, laneId);
+        if (!lane) {
+            throw new LanesError("lane_not_found", `Caller lane ${laneId} not found`, {
+                lane_id: laneId,
+            });
+        }
+        return derivedLaneDepth(hqRoot, lane.senior, ctx);
+    }
+    const sessionId = sessionIdFromEnv(ctx.env);
+    if (sessionId) {
+        return depthOfRef(hqRoot, { kind: "session", id: sessionId }, ctx);
+    }
+    return 0;
+}
+function defaultSenior(ctx) {
+    const parent = ctx.env.HQ_PARENT_SESSION_ID?.trim();
+    if (parent)
+        return { kind: "session", id: parent };
+    const sessionId = sessionIdFromEnv(ctx.env);
+    if (sessionId)
+        return { kind: "session", id: sessionId };
+    return { kind: "user" };
+}
+function companyOfSenior(hqRoot, ref, ctx) {
+    if (ref.kind === "user")
+        return { binding: "unknown" };
+    if (ref.kind === "lane") {
+        if (!ref.id)
+            return { binding: "unknown" };
+        const lane = readLane(hqRoot, ref.id);
+        if (!lane.company)
+            return { binding: "none" };
+        return {
+            binding: "company",
+            slug: lane.company.slug,
+            uid: lane.company.uid,
+        };
+    }
+    if (!ref.id)
+        return { binding: "unknown" };
+    const loaded = loadSessionMeta(hqRoot, ref.id, ctx);
+    if (loaded.status !== "ok")
+        return { binding: "unknown" };
+    return companyBindingFromSessionMeta(loaded.doc);
+}
+function companyBindingFromSessionMeta(meta) {
+    const slugRaw = meta.company_slug;
+    const uidRaw = meta.company_uid;
+    if (slugRaw !== undefined && slugRaw !== null && typeof slugRaw !== "string") {
+        return { binding: "unknown" };
+    }
+    if (uidRaw !== undefined && uidRaw !== null && typeof uidRaw !== "string") {
+        return { binding: "unknown" };
+    }
+    const slug = typeof slugRaw === "string" ? slugRaw : undefined;
+    const uid = typeof uidRaw === "string" ? uidRaw : undefined;
+    if (!slug && !uid)
+        return { binding: "none" };
+    return { binding: "company", slug, uid };
+}
+function serializeSeniorCompany(seniorCompany) {
+    if (seniorCompany.binding === "unknown")
+        return null;
+    if (seniorCompany.binding === "none")
+        return { kind: "none" };
+    const out = {};
+    if (seniorCompany.slug)
+        out.slug = seniorCompany.slug;
+    if (seniorCompany.uid)
+        out.uid = seniorCompany.uid;
+    return out;
+}
+function sameTenant(laneCompany, senior, seniorCompany) {
+    if (senior.kind === "user")
+        return true;
+    // Unknown company stays a refusal for every lane, including no-company.
+    if (seniorCompany.binding === "unknown")
+        return false;
+    if (!laneCompany) {
+        return seniorCompany.binding === "none";
+    }
+    if (seniorCompany.binding !== "company")
+        return false;
+    if (seniorCompany.uid && seniorCompany.uid === laneCompany.uid)
+        return true;
+    if (seniorCompany.slug && seniorCompany.slug === laneCompany.slug)
+        return true;
+    return false;
+}
+function assertSameTenant(laneCompany, senior, seniorCompany, extra = {}) {
+    if (sameTenant(laneCompany, senior, seniorCompany))
+        return;
+    throw new LanesError("tenancy_mismatch", seniorCompany.binding === "unknown"
+        ? "Cannot attach a lane to a senior whose company is unknown"
+        : "Cannot attach a lane to a senior in a different company", {
+        lane_company: laneCompany,
+        senior,
+        senior_company: serializeSeniorCompany(seniorCompany),
+        ...extra,
+    });
+}
+function recordMatchesCompany(recordCompany, filter) {
+    if (!recordCompany)
+        return false;
+    return recordCompany.uid === filter.uid || recordCompany.slug === filter.slug;
+}
+function walkHitsLane(hqRoot, start, laneId, ctx) {
+    const seen = new Set();
+    let current = start;
+    while (current.kind !== "user") {
+        const key = seniorKey(current);
+        if (seen.has(key)) {
+            throw new LanesError("senior_cycle", `Cycle in senior chain at ${key}`, {
+                at: current,
+            });
+        }
+        seen.add(key);
+        if (current.kind === "lane" && current.id === laneId)
+            return true;
+        if (current.kind === "lane") {
+            if (!current.id)
+                return false;
+            const rec = tryReadLane(hqRoot, current.id);
+            if (!rec)
+                return false;
+            current = rec.senior;
+            continue;
+        }
+        if (!current.id)
+            return false;
+        current = seniorOfSession(hqRoot, current.id, ctx);
+    }
+    return false;
+}
+function resolveAudience(hqRoot, question, ctx) {
+    let current = { kind: "lane", id: question.origin.id };
+    for (let hop = 0; hop < question.hop; hop += 1) {
+        if (current.kind === "user")
+            return current;
+        if (current.kind === "lane") {
+            if (!current.id)
+                return current;
+            const lane = tryReadLane(hqRoot, current.id);
+            if (!lane)
+                return current;
+            current = lane.senior;
+            continue;
+        }
+        if (!current.id)
+            return current;
+        current = seniorOfSession(hqRoot, current.id, ctx);
+    }
+    return current;
+}
+function audienceMatches(audience, filter) {
+    if (filter.kind === "me") {
+        return audience.kind === "session" && audience.id === filter.id;
+    }
+    if (filter.kind === "user")
+        return audience.kind === "user";
+    return audience.kind === filter.kind && audience.id === filter.id;
+}
+function parseForFilter(raw, ctx) {
+    const trimmed = raw.trim();
+    if (trimmed === "me") {
+        const sessionId = sessionIdFromEnv(ctx.env);
+        if (!sessionId) {
+            throw new LanesError("missing_session_id", "--for me requires a current session id (HQ_SESSION_ID)", {});
+        }
+        return { kind: "me", id: sessionId };
+    }
+    return parseSeniorRef(trimmed);
+}
+function timeoutPath(hqRoot, laneId) {
+    return path.join(runDir(hqRoot, laneId), "timeout.json");
+}
+function isOverdue(hqRoot, laneId, now) {
+    const raw = readJsonFile(timeoutPath(hqRoot, laneId));
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return false;
+    const deadline = raw.deadline_at;
+    if (typeof deadline !== "string")
+        return false;
+    const at = Date.parse(deadline);
+    if (!Number.isFinite(at))
+        return false;
+    return now.getTime() > at;
+}
+function compareQueueOrder(a, b) {
+    if (b.priority !== a.priority)
+        return b.priority - a.priority;
+    return a.created_at.localeCompare(b.created_at);
+}
+function admitCreate(input) {
+    const { hqRoot, provider, pinnedAccount, priority, createdAt, config } = input;
+    const providerCfg = config.providers[provider];
+    const lanes = loadAllLanes(hqRoot).filter((lane) => lane.lane_id !== input.excludeLaneId);
+    const runningProvider = lanes.filter((lane) => lane.provider === provider && lane.state === "running");
+    const queuedSame = lanes.filter((lane) => {
+        if (lane.provider !== provider || lane.state !== "queued")
+            return false;
+        if (pinnedAccount)
+            return lane.account === pinnedAccount;
+        return !lane.account;
+    });
+    const runningCount = pinnedAccount
+        ? runningProvider.filter((lane) => lane.account === pinnedAccount).length
+        : runningProvider.length;
+    const providerRunning = runningProvider.length;
+    const queuedCount = queuedSame.length;
+    const maxQueued = providerCfg.max_queued;
+    const atCap = providerRunning >= providerCfg.max_running ||
+        (pinnedAccount !== undefined &&
+            runningCount >= accountMaxRunning(providerCfg, pinnedAccount));
+    const synthetic = {
+        schema_version: "hq-lane.v1",
+        lane_id: "__incoming__",
+        company: { slug: "", uid: "" },
+        project_id: "",
+        story_id: "",
+        depth: 1,
+        senior: { kind: "user" },
+        senior_history: [],
+        state: "queued",
+        priority,
+        provider,
+        account: pinnedAccount,
+        host: { kind: "local", id: "local" },
+        version: 0,
+        created_at: createdAt,
+        updated_at: createdAt,
+        attribution_history: [],
+    };
+    const ranked = [...queuedSame, synthetic].sort(compareQueueOrder);
+    const first = ranked[0];
+    const isHead = first?.lane_id === "__incoming__";
+    const wouldStart = !atCap && isHead;
+    if (wouldStart)
+        return { action: "start" };
+    if (queuedCount >= maxQueued) {
+        return {
+            action: "refuse",
+            error: new LanesError("lane_queue_full", `Lane queue is full for ${pinnedAccount ? `account ${pinnedAccount}` : provider}`, {
+                provider,
+                ...(pinnedAccount ? { account: pinnedAccount } : {}),
+                running: pinnedAccount ? runningCount : providerRunning,
+                queued: queuedCount,
+            }),
+        };
+    }
+    if (atCap) {
+        return { action: "queue", reason: isHead ? "cap" : "queue_position" };
+    }
+    return { action: "queue", reason: "queue_position" };
+}
+async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccount) {
+    if (current.action !== "start")
+        return current;
+    const { decision } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
+    if (decision.admit)
+        return current;
+    const providerCfg = config.providers[provider];
+    const queuedCount = loadAllLanes(hqRoot).filter((lane) => {
+        if (lane.provider !== provider || lane.state !== "queued")
+            return false;
+        if (pinnedAccount)
+            return lane.account === pinnedAccount;
+        return !lane.account;
+    }).length;
+    if (queuedCount >= providerCfg.max_queued) {
+        const running = loadAllLanes(hqRoot).filter((lane) => lane.provider === provider && lane.state === "running").length;
+        return {
+            action: "refuse",
+            error: new LanesError("lane_queue_full", `Lane queue is full for ${pinnedAccount ? `account ${pinnedAccount}` : provider}`, {
+                provider,
+                ...(pinnedAccount ? { account: pinnedAccount } : {}),
+                running,
+                queued: queuedCount,
+            }),
+        };
+    }
+    return { action: "queue", reason: "throttle" };
+}
+function assertKnownOutpost(requested, known) {
+    if (!known.includes(requested)) {
+        throw new LanesError("unknown_outpost", `Unknown Outpost ${JSON.stringify(requested)}. Accepted: ${known.join(", ") || "(none)"}`, { accepted: known, value: requested });
+    }
+}
+function copyHookRails(fromHome, toHome) {
+    const src = path.join(fromHome, "hooks");
+    if (!fs.existsSync(src))
+        return false;
+    fs.cpSync(src, path.join(toHome, "hooks"), { recursive: true });
+    return true;
+}
+function railsPresent(home) {
+    return fs.existsSync(path.join(home, "hooks"));
+}
+const ADMISSION_LOCK_STALE_MS = 30_000;
+const ADMISSION_LOCK_TIMEOUT_MS = 5_000;
+/**
+ * Spec §5.1: `hq lanes ask` from inside a lane can hit a binary or dist
+ * being replaced mid-call (ENOENT / ETXTBSY / a module that no longer
+ * resolves) or a record written by a newer CLI. Three attempts, waits of
+ * 5 s then 15 s, 20 s of backoff in total, inside the 30 s bound.
+ */
+export const ASK_BACKOFF_MS = [5_000, 15_000];
+export const ASK_ATTEMPTS = ASK_BACKOFF_MS.length + 1;
+function yieldEventLoop() {
+    return new Promise((resolve) => {
+        setImmediate(resolve);
+    });
+}
+function admissionLockPath(hqRoot, provider, pinnedAccount) {
+    const name = pinnedAccount
+        ? `${provider}-${pinnedAccount}`
+        : `${provider}-unpinned`;
+    return path.join(hqRoot, LANES_RUNS_REL, ".admission-locks", `${name}.lock`);
+}
+async function withAdmissionLock(lockPath, fn, sleep) {
+    ensureDir(path.dirname(lockPath));
+    const started = Date.now();
+    while (true) {
+        let fd;
+        try {
+            fd = fs.openSync(lockPath, "wx");
+            try {
+                fs.writeSync(fd, Buffer.from(`${process.pid}\n${Date.now()}\n`, "utf8"));
+            }
+            catch (err) {
+                fs.closeSync(fd);
+                fd = undefined;
+                throw err;
+            }
+            try {
+                await yieldEventLoop();
+                return await fn();
+            }
+            finally {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch (err) {
+                    process.stderr.write(`hq lanes: admission lock close failed for ${lockPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+                }
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch (err) {
+                    const code = err.code;
+                    if (code !== "ENOENT") {
+                        process.stderr.write(`hq lanes: admission lock unlink failed for ${lockPath}: ${err instanceof Error ? err.message : String(err)}\n`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "EEXIST")
+                throw err;
+            if (Date.now() - started > ADMISSION_LOCK_TIMEOUT_MS) {
+                throw new LanesError("store_lock_timeout", `Timed out waiting for admission lock ${lockPath}`, { path: lockPath });
+            }
+            try {
+                const raw = fs.readFileSync(lockPath, "utf8");
+                const tsLine = raw.split("\n")[1];
+                const ts = tsLine ? Number(tsLine) : NaN;
+                if (Number.isFinite(ts) && Date.now() - ts > ADMISSION_LOCK_STALE_MS) {
+                    try {
+                        fs.unlinkSync(lockPath);
+                    }
+                    catch (unlinkErr) {
+                        const unlinkCode = unlinkErr.code;
+                        if (unlinkCode !== "ENOENT")
+                            throw unlinkErr;
+                    }
+                    continue;
+                }
+            }
+            catch (statErr) {
+                const statCode = statErr.code;
+                if (statCode !== "ENOENT") {
+                    process.stderr.write(`hq lanes: stale admission-lock probe failed for ${lockPath}: ${statErr instanceof Error ? statErr.message : String(statErr)}\n`);
+                }
+            }
+            await sleep(10);
+            await yieldEventLoop();
+        }
+    }
+}
+function withCasRetry(fn, attempts = 5) {
+    let last;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            return fn();
+        }
+        catch (err) {
+            last = err;
+            if (!isLaneVersionConflict(err) || i === attempts - 1)
+                throw err;
+        }
+    }
+    throw last;
+}
+export function casUpdateQuestion(hqRoot, questionId, updater) {
+    return withCasRetry(() => {
+        const current = readQuestion(hqRoot, questionId);
+        return updateQuestion(hqRoot, questionId, current.version, updater);
+    });
+}
+export function casUpdateLane(hqRoot, laneId, updater) {
+    return withCasRetry(() => {
+        const current = readLane(hqRoot, laneId);
+        return updateLane(hqRoot, laneId, current.version, "command", updater);
+    });
+}
+function throwIfQuestionNotPending(current) {
+    if (current.status === "pending")
+        return;
+    throw new LanesError("question_not_pending", `Question ${current.question_id} is ${current.status}`, { question_id: current.question_id, status: current.status });
+}
+function formatUnknownValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (typeof item === "string" ? `- ${item}` : `- ${JSON.stringify(item)}`))
+            .join("\n");
+    }
+    if (value && typeof value === "object") {
+        return JSON.stringify(value, null, 2);
+    }
+    return "";
+}
+/**
+ * Spec §5.3: an approval gate ends the run. The lane stops at each
+ * checkpoint with a `decision: ask` envelope whose question names it; the
+ * reconcile pass resumes the lane once every question is answered.
+ */
+export function checkpointInstruction(worker) {
+    const names = [
+        ...(worker.approvalRequired ? ["approval_required"] : []),
+        ...worker.humanCheckpoints,
+    ];
+    if (names.length === 0)
+        return "";
+    return [
+        "Each checkpoint above is an approval gate that ends this run. When you reach a checkpoint, " +
+            "stop and write the envelope with decision \"ask\" and story_status \"in_progress\". " +
+            "Put exactly one entry in questions for the checkpoint; its question text must start with " +
+            "the checkpoint name, followed by what you need approved, and its options must include \"approve\". " +
+            "Do not continue past a checkpoint in the same run. When this run is resumed, the answer to " +
+            "that question is an operator decision that outranks the brief; continue from the checkpoint.",
+        "Checkpoint names, in order:",
+        ...names.map((name) => `- ${name}`),
+    ].join("\n");
+}
+export function composeWorkerBrief(worker, taskBrief) {
+    const yaml = worker.workerYaml;
+    const name = yaml.worker?.name ?? worker.id;
+    const description = yaml.worker?.description ?? worker.description ?? "";
+    const checkpoints = [
+        worker.approvalRequired ? "- approval_required: true" : "",
+        ...worker.humanCheckpoints.map((item) => `- ${item}`),
+    ]
+        .filter(Boolean)
+        .join("\n");
+    return [
+        `# ${name}`,
+        description,
+        "",
+        "## Standing instructions",
+        formatUnknownValue(yaml.instructions) || "(none)",
+        "",
+        "## Skills",
+        worker.skillFiles.map((item) => `- ${item}`).join("\n") || "(none)",
+        "",
+        "## Context (resolved)",
+        worker.resolvedContextBase.map((item) => `- ${item}`).join("\n") || "(none)",
+        "",
+        "## Knowledge",
+        formatUnknownValue(yaml.knowledge) || "(none)",
+        "",
+        "## Verification checkpoints",
+        checkpoints || "(none)",
+        ...(checkpoints ? ["", checkpointInstruction(worker)] : []),
+        "",
+        "## Task",
+        taskBrief.replace(/\s+$/, ""),
+        "",
+        "## Standing authorization",
+        STANDING_AUTHORIZATION,
+        "",
+        FOREGROUND_ONLY_RULE,
+        "",
+    ].join("\n");
+}
+/**
+ * A lane with no worker still carries the standing authorization paragraph
+ * and the foreground-only rule.
+ */
+export function composeGeneralBrief(taskBrief) {
+    return [
+        taskBrief.replace(/\s+$/, ""),
+        "",
+        "## Standing authorization",
+        STANDING_AUTHORIZATION,
+        "",
+        FOREGROUND_ONLY_RULE,
+        "",
+    ].join("\n");
+}
+export function parseMaxRuntimeSeconds(raw, workerId) {
+    if (raw === undefined || raw === null || raw === "")
+        return undefined;
+    if (typeof raw === "number") {
+        if (!Number.isFinite(raw) || raw < 0 || !Number.isInteger(raw)) {
+            throw new LanesError("invalid_worker_timeout", `Worker ${workerId} execution.max_runtime is not a non-negative integer number of seconds`, { worker: workerId, value: raw });
+        }
+        return raw;
+    }
+    if (typeof raw !== "string") {
+        throw new LanesError("invalid_worker_timeout", `Worker ${workerId} execution.max_runtime is not a duration`, { worker: workerId, value: raw });
+    }
+    const trimmed = raw.trim();
+    if (/^\d+$/.test(trimmed))
+        return Number(trimmed);
+    const seconds = /^(\d+)\s*s$/i.exec(trimmed);
+    if (seconds)
+        return Number(seconds[1]);
+    const minutes = /^(\d+)\s*m$/i.exec(trimmed);
+    if (minutes)
+        return Number(minutes[1]) * 60;
+    const hours = /^(\d+)\s*h$/i.exec(trimmed);
+    if (hours)
+        return Number(hours[1]) * 3600;
+    throw new LanesError("invalid_worker_timeout", `Worker ${workerId} execution.max_runtime ${JSON.stringify(raw)} is not a recognised duration`, { worker: workerId, value: raw });
+}
+function askDeliveryFailedPath(hqRoot, laneId) {
+    return path.join(runDir(hqRoot, laneId), "ask_delivery_failed.json");
+}
+async function emitLaneMeshEvent(ctx, company, threadId, event, payload) {
+    if (!threadId || !company)
+        return;
+    await ctx.mesh.appendThreadEvent(company, threadId, event, payload);
+}
+export const PICKUP_TERMINAL_REASONS = [
+    "account_not_logged_in",
+    "unknown_account",
+    "account_disabled",
+];
+export const DISPATCH_TERMINAL_REASON = "outpost_dispatch_failed";
+function parsePickupTerminalReason(value) {
+    if (PICKUP_TERMINAL_REASONS.includes(value)) {
+        return value;
+    }
+    throw new LanesError("unknown_pickup_reason", `Unknown Outpost pickup reason ${JSON.stringify(value)}. Accepted: ${PICKUP_TERMINAL_REASONS.join(", ")}`, { accepted: [...PICKUP_TERMINAL_REASONS], value });
+}
+function markDispatchFailure(hqRoot, laneId, details) {
+    return casUpdateLane(hqRoot, laneId, (current) => {
+        if (isTerminalLaneState(current.state) || current.state === "running") {
+            return current;
+        }
+        return {
+            ...current,
+            state: "failed",
+            queued_reason: undefined,
+            terminal_reason: DISPATCH_TERMINAL_REASON,
+            terminal_details: details,
+        };
+    });
+}
+function markPickupFailure(hqRoot, laneId, reasonRaw, details) {
+    const reason = parsePickupTerminalReason(reasonRaw);
+    return casUpdateLane(hqRoot, laneId, (current) => {
+        const existing = current
+            .terminal_reason;
+        if (isTerminalLaneState(current.state) && existing === reason) {
+            return current;
+        }
+        return {
+            ...current,
+            state: "failed",
+            queued_reason: undefined,
+            terminal_reason: reason,
+            terminal_details: details,
+        };
+    });
+}
+/**
+ * Outpost-side account bind (spec §5.2). Writes a named terminal reason,
+ * never a plain `failed`.
+ */
+export function applyOutpostAccountPickup(hqRoot, laneId) {
+    const lane = readLane(hqRoot, laneId);
+    const config = loadLanesConfig(hqRoot);
+    try {
+        const resolved = resolveAccount(lane.provider, lane.account, config, {
+            hqRoot,
+        });
+        const status = accountStatus(lane.provider, resolved.id, config);
+        if (isLoggedOut(status)) {
+            return markPickupFailure(hqRoot, laneId, "account_not_logged_in", {
+                provider: lane.provider,
+                account: resolved.id,
+            });
+        }
+        if (lane.account === resolved.id)
+            return lane;
+        // The bind is the executing host's pre-spawn account resolution, the same
+        // write spawnLaneWorker makes for a local lane, so it carries the spawn
+        // writer. `account` stays closed to `command`: an operator command never
+        // re-pins the account of a lane it does not execute.
+        return retryUpdateLane(hqRoot, laneId, "spawn", (current) => {
+            if (current.account === resolved.id)
+                return current;
+            return { ...current, account: resolved.id };
+        });
+    }
+    catch (err) {
+        if (err instanceof AccountResolutionError) {
+            if (err.error === "unknown_account") {
+                return markPickupFailure(hqRoot, laneId, "unknown_account", err.details);
+            }
+            if (err.error === "account_disabled") {
+                return markPickupFailure(hqRoot, laneId, "account_disabled", err.details);
+            }
+            if (err.error === "no_enabled_account") {
+                return markPickupFailure(hqRoot, laneId, "account_disabled", err.details);
+            }
+        }
+        throw err;
+    }
+}
+function pendingQuestionsForLane(hqRoot, laneId) {
+    return loadAllQuestions(hqRoot).filter((q) => q.origin.id === laneId && q.status === "pending");
+}
+export function cancelPendingQuestionsForLane(hqRoot, laneId, nowIso, operatorReason) {
+    const cancelled = [];
+    for (const question of pendingQuestionsForLane(hqRoot, laneId)) {
+        const next = casUpdateQuestion(hqRoot, question.question_id, (current) => {
+            if (current.status !== "pending")
+                return current;
+            const entry = {
+                hop: current.hop,
+                audience: { kind: "user" },
+                at: nowIso,
+                reason: "cancelled",
+                ...(operatorReason ? { detail: operatorReason } : {}),
+            };
+            return {
+                ...current,
+                status: "cancelled",
+                routing_history: appendCappedHistory(current.routing_history, entry),
+            };
+        });
+        cancelled.push(next);
+    }
+    return cancelled;
+}
+function mintMessageId() {
+    return `msg_${Date.now().toString(36)}_${randomBytes(3).toString("hex")}`;
+}
+async function runCreate(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const companyFlag = opts.company?.trim();
+    const project = opts.project?.trim();
+    const story = opts.story?.trim();
+    const briefFile = opts.briefFile?.trim();
+    if (!project) {
+        throw new LanesError("missing_project", "--project is required", {});
+    }
+    if (!story) {
+        throw new LanesError("missing_story", "--story is required", {});
+    }
+    if (!briefFile) {
+        throw new LanesError("missing_brief_file", "--brief-file is required", {});
+    }
+    const provider = opts.provider
+        ? parseLaneProvider(opts.provider)
+        : parseLaneProvider("codex");
+    if (opts.outpost !== undefined && opts.outpost !== "") {
+        const requested = opts.outpost.trim();
+        let known;
+        try {
+            known = await ctx.listOutpostIds();
+        }
+        catch (err) {
+            throw new LanesError("outpost_list_unavailable", `Failed to list Outpost ids: ${err instanceof Error ? err.message : String(err)}`, {});
+        }
+        assertKnownOutpost(requested, known);
+    }
+    const depth = callerDepth(hqRoot, ctx);
+    if (depth >= MAX_LANE_DEPTH) {
+        throw new LanesError("max_lane_depth", `A depth-${depth} caller may not spawn lanes (cap ${MAX_LANE_DEPTH})`, { depth, max: MAX_LANE_DEPTH });
+    }
+    const senior = opts.senior ? parseSeniorRef(opts.senior) : defaultSenior(ctx);
+    assertSeniorExists(hqRoot, senior, ctx);
+    const laneDepth = derivedLaneDepth(hqRoot, senior, ctx);
+    if (laneDepth > MAX_LANE_DEPTH) {
+        throw new LanesError("max_lane_depth", `Lane depth ${laneDepth} exceeds cap ${MAX_LANE_DEPTH}`, { depth: laneDepth, max: MAX_LANE_DEPTH });
+    }
+    // A no-company lane must not call company resolution (openMeshTransport).
+    const company = companyFlag
+        ? await ctx.resolveCompany(companyFlag)
+        : null;
+    const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
+    assertSameTenant(company, senior, seniorCompany);
+    let resolvedWorker;
+    if (opts.worker) {
+        resolvedWorker = resolveLaneWorker(hqRoot, opts.worker, company?.slug);
+    }
+    const briefAbs = resolveCallerPath(ctx.callerCwd(), briefFile);
+    if (!ctx.existsSync(briefAbs)) {
+        throw new LanesError("brief_not_found", `Brief file not found: ${briefAbs}`, {
+            path: briefAbs,
+        });
+    }
+    const config = loadLanesConfig(hqRoot);
+    const outpostId = opts.outpost?.trim() || undefined;
+    let originHost;
+    let originHostSource;
+    if (outpostId) {
+        const identity = ctx.resolveMachineIdentity();
+        if (identity.status !== "ok") {
+            throw new LanesError("origin_host_unresolvable", "Cannot record origin_host; this machine's identity is unresolvable", { identity });
+        }
+        originHost = identity.id;
+        originHostSource = identity.source;
+    }
+    const cliModel = parseCliModel(opts.model);
+    // Validated here because `claude --effort <unknown>` only warns and runs.
+    const cliEffort = parseCliEffort(provider, opts.effort);
+    let pinnedAccount;
+    const accountWasExplicit = Boolean(opts.account && opts.account.trim() !== "");
+    if (outpostId) {
+        if (accountWasExplicit) {
+            pinnedAccount = opts.account.trim();
+        }
+    }
+    else if (opts.account !== undefined) {
+        const requested = opts.account.trim();
+        if (!requested) {
+            throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(opts.account)} for ${provider}`, { provider, account: opts.account, enabled: [] });
+        }
+        const resolved = resolveAccount(provider, requested, config, {
+            hqRoot,
+            cliModel,
+        });
+        pinnedAccount = resolved.id;
+    }
+    const priority = parsePriority(opts.priority);
+    let timeoutSecs = parseOptionalInt(opts.timeout, "--timeout");
+    if (timeoutSecs === undefined && resolvedWorker) {
+        timeoutSecs = parseMaxRuntimeSeconds(resolvedWorker.defaultTimeout, resolvedWorker.id);
+    }
+    const now = ctx.now();
+    const createdAt = now.toISOString();
+    const threadId = company
+        ? await ctx.mesh.ensureProjectThread(company, project)
+        : undefined;
+    const persist = async () => {
+        let admission;
+        let validation;
+        if (!outpostId && pinnedAccount === undefined) {
+            pinnedAccount = resolveAccount(provider, undefined, config, {
+                hqRoot,
+                existsSync: ctx.existsSync,
+                cliModel,
+            }).id;
+        }
+        const accountCfg = pinnedAccount !== undefined
+            ? config.providers[provider].accounts[pinnedAccount]
+            : undefined;
+        const model = resolveLaneModel({
+            cliModel,
+            accountModel: accountCfg?.model,
+            providerModel: config.providers[provider].model,
+        });
+        // Recorded now so a queued lane already shows it; spawn re-resolves
+        // every source except `cli`.
+        const effort = resolveLaneEffort({
+            cliEffort,
+            accountEffort: accountCfg?.effort,
+            providerEffort: config.providers[provider].effort,
+            model,
+        });
+        if (outpostId) {
+            admission = { action: "queue" };
+            validation = "pending";
+        }
+        else {
+            admission = admitCreate({
+                hqRoot,
+                provider,
+                pinnedAccount,
+                priority,
+                createdAt,
+                config,
+            });
+            if (admission.action === "refuse" && admission.error) {
+                throw admission.error;
+            }
+            admission = await applyThrottle(hqRoot, config, ctx, admission, provider, pinnedAccount);
+            if (admission.action === "refuse" && admission.error) {
+                throw admission.error;
+            }
+        }
+        const host = outpostId !== undefined
+            ? { kind: "outpost", id: outpostId }
+            : { kind: "local", id: ctx.hostname() };
+        const queuedReason = admission.action === "queue" ? admission.reason : undefined;
+        const lane = createLane(hqRoot, {
+            company,
+            project_id: project,
+            story_id: story,
+            thread_id: threadId,
+            depth: laneDepth,
+            senior,
+            senior_history: [],
+            state: "queued",
+            queued_reason: queuedReason,
+            priority,
+            worker: resolvedWorker?.id ?? opts.worker,
+            ...(resolvedWorker ? { worker_path: resolvedWorker.path } : {}),
+            ...(resolvedWorker?.pack ? { worker_pack: resolvedWorker.pack } : {}),
+            provider,
+            account: pinnedAccount,
+            ...(model !== undefined ? { model } : {}),
+            ...(effort.effort !== undefined ? { effort: effort.effort } : {}),
+            effort_source: effort.source,
+            host,
+            ...(originHost !== undefined ? { origin_host: originHost } : {}),
+            ...(originHostSource !== undefined
+                ? { origin_host_source: originHostSource }
+                : {}),
+            attribution_history: [],
+        });
+        return { lane, admission, validation };
+    };
+    let persisted;
+    if (outpostId) {
+        persisted = await persist();
+    }
+    else {
+        persisted = await withAdmissionLock(admissionLockPath(hqRoot, provider, accountWasExplicit ? pinnedAccount : undefined), persist, ctx.sleep);
+    }
+    const { lane, admission, validation } = persisted;
+    const dest = runDir(hqRoot, lane.lane_id);
+    ensureDir(path.join(dest, "logs"));
+    ensureDir(path.join(dest, "envelopes"));
+    ensureDir(path.join(dest, "dropbox"));
+    ensureDir(path.join(dest, "questions"));
+    const taskBrief = fs.readFileSync(briefAbs, "utf8");
+    const briefText = resolvedWorker
+        ? composeWorkerBrief(resolvedWorker, taskBrief)
+        : composeGeneralBrief(taskBrief);
+    fs.writeFileSync(path.join(dest, "brief.md"), briefText);
+    if (timeoutSecs !== undefined) {
+        writeJsonFile(timeoutPath(hqRoot, lane.lane_id), {
+            timeout_secs: timeoutSecs,
+            deadline_at: new Date(now.getTime() + timeoutSecs * 1000).toISOString(),
+        });
+    }
+    let started = lane;
+    if (admission.action === "start") {
+        started = spawnLaneWorker(hqRoot, lane, {
+            env: ctx.env,
+            existsSync: ctx.existsSync,
+            spawnProcess: ctx.spawnProcess,
+            proveDetached: ctx.proveDetached,
+            killProcess: ctx.killProcess,
+            now: ctx.now,
+            resolveMachineIdentity: ctx.resolveMachineIdentity,
+            runCompaction: ctx.runCompaction,
+            locateTranscript: ctx.locateTranscript,
+        });
+        if (company) {
+            await emitLaneMeshEvent(ctx, company, threadId, "lane_started", {
+                lane_id: started.lane_id,
+                project_id: project,
+                story_id: story,
+            });
+            await ctx.mesh.patchStoryStatus(company, project, story, "in_progress");
+        }
+    }
+    else if (outpostId) {
+        started = await dispatchCreatedOutpostLane(ctx, {
+            hqRoot,
+            lane,
+            outpostId,
+            briefText,
+            timeout: timeoutSecs !== undefined
+                ? {
+                    timeout_secs: timeoutSecs,
+                    deadline_at: new Date(now.getTime() + timeoutSecs * 1000).toISOString(),
+                }
+                : undefined,
+        });
+    }
+    printJson({
+        ok: true,
+        action: "create",
+        lane_id: started.lane_id,
+        state: started.state,
+        queued_reason: started.queued_reason ?? null,
+        priority: started.priority,
+        provider: started.provider,
+        account: started.account ?? null,
+        model: started.model ?? null,
+        effort: started.effort ?? null,
+        effort_source: started.effort_source ?? null,
+        host: started.host,
+        company: started.company,
+        project_id: started.project_id,
+        story_id: started.story_id,
+        thread_id: started.thread_id ?? null,
+        senior: started.senior,
+        depth: started.depth,
+        timeout_secs: timeoutSecs ?? null,
+        ...(validation ? { validation } : {}),
+        ...(started.outpost_command_id
+            ? {
+                outpost_command_id: started
+                    .outpost_command_id,
+            }
+            : {}),
+        lane: started,
+    });
+}
+async function dispatchCreatedOutpostLane(ctx, input) {
+    const { hqRoot, lane, outpostId, briefText, timeout } = input;
+    const payload = {
+        lane,
+        brief: briefText,
+        timeout,
+    };
+    const bytes = Buffer.from(`${JSON.stringify(payload)}\n`, "utf8");
+    try {
+        const staged = await ctx.stageOutpostPayload(outpostId, bytes);
+        const command = buildOutpostPickupCommand(staged.getUrl);
+        const dispatched = await ctx.dispatchOutpostExec({ outpostId, command });
+        const remote = parseRemotePickupJson(dispatched.stdout);
+        if (remote?.error === "outpost_self_target") {
+            return casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+                ...current,
+                state: "cancelled",
+                queued_reason: undefined,
+                terminal_reason: "outpost_self_target",
+                outpost_command_id: dispatched.commandId,
+            }));
+        }
+        const stdoutTrimmed = dispatched.stdout.trim();
+        if (remote === null && stdoutTrimmed !== "" && dispatched.status !== "Success") {
+            const failed = markDispatchFailure(hqRoot, lane.lane_id, {
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+                exit_code: dispatched.exitCode,
+                status: dispatched.status,
+                stderr: dispatched.stderr.slice(0, 2000),
+                parse_error: "unparseable_pickup_stdout",
+            });
+            throw new LanesError(DISPATCH_TERMINAL_REASON, "Outpost pickup command failed", {
+                outpost_id: outpostId,
+                lane_id: failed.lane_id,
+                state: failed.state,
+                terminal_reason: DISPATCH_TERMINAL_REASON,
+                command_id: dispatched.commandId,
+            });
+        }
+        const dispatchOk = dispatched.status === "Success" || dispatched.exitCode === 0;
+        if (!dispatchOk) {
+            const failed = markDispatchFailure(hqRoot, lane.lane_id, {
+                outpost_id: outpostId,
+                command_id: dispatched.commandId,
+                exit_code: dispatched.exitCode,
+                status: dispatched.status,
+                stderr: dispatched.stderr.slice(0, 2000),
+            });
+            throw new LanesError(DISPATCH_TERMINAL_REASON, "Outpost pickup command failed", {
+                outpost_id: outpostId,
+                lane_id: failed.lane_id,
+                state: failed.state,
+                terminal_reason: DISPATCH_TERMINAL_REASON,
+                command_id: dispatched.commandId,
+            });
+        }
+        return casUpdateLane(hqRoot, lane.lane_id, (current) => ({
+            ...current,
+            outpost_command_id: dispatched.commandId,
+        }));
+    }
+    catch (err) {
+        if (isLanesError(err) &&
+            err.error === DISPATCH_TERMINAL_REASON &&
+            readLane(hqRoot, lane.lane_id).state === "failed") {
+            throw err;
+        }
+        const message = dispatchErrorMessage(err);
+        const failed = markDispatchFailure(hqRoot, lane.lane_id, {
+            outpost_id: outpostId,
+            message,
+        });
+        throw new LanesError(DISPATCH_TERMINAL_REASON, `Failed to dispatch lane to Outpost ${outpostId}: ${message}`, {
+            outpost_id: outpostId,
+            lane_id: failed.lane_id,
+            state: failed.state,
+            terminal_reason: DISPATCH_TERMINAL_REASON,
+        });
+    }
+}
+function parseRemotePickupJson(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        process.stderr.write("hq lanes: Outpost pickup stdout is not a JSON object\n");
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: failed to parse Outpost pickup JSON: ${err instanceof Error ? err.message : String(err)}\n`);
+        return null;
+    }
+    return null;
+}
+function ingestPickupPayload(hqRoot, payload) {
+    const laneId = payload.lane.lane_id;
+    if (!laneId) {
+        throw new LanesError("outpost_payload_invalid", "Pickup payload lane.lane_id is required", {});
+    }
+    const existing = tryReadLane(hqRoot, laneId);
+    const lane = existing ?? createLane(hqRoot, payload.lane);
+    const dest = runDir(hqRoot, lane.lane_id);
+    ensureDir(path.join(dest, "logs"));
+    ensureDir(path.join(dest, "envelopes"));
+    ensureDir(path.join(dest, "dropbox"));
+    ensureDir(path.join(dest, "questions"));
+    fs.writeFileSync(path.join(dest, "brief.md"), payload.brief);
+    if (payload.timeout) {
+        writeJsonFile(timeoutPath(hqRoot, lane.lane_id), payload.timeout);
+    }
+    return lane;
+}
+async function runPickup(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const payloadFile = opts.payloadFile?.trim();
+    const payloadUrl = opts.payloadUrl?.trim();
+    if (!payloadFile && !payloadUrl) {
+        throw new LanesError("missing_payload", "--payload-file or --payload-url is required", {});
+    }
+    if (payloadFile && payloadUrl) {
+        throw new LanesError("invalid_payload", "Pass only one of --payload-file or --payload-url", {});
+    }
+    let rawText;
+    if (payloadUrl) {
+        rawText = await ctx.fetchText(payloadUrl);
+    }
+    else {
+        const abs = resolveCallerPath(ctx.callerCwd(), payloadFile);
+        if (!ctx.existsSync(abs)) {
+            throw new LanesError("brief_not_found", `Payload file not found: ${abs}`, {
+                path: abs,
+            });
+        }
+        rawText = ctx.readFileSync(abs, "utf8");
+    }
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(rawText);
+    }
+    catch (err) {
+        throw new LanesError("outpost_payload_invalid", `Pickup payload is not JSON: ${err instanceof Error ? err.message : String(err)}`, {});
+    }
+    const payload = parseOutpostPickupPayload(parsedJson);
+    const ingested = ingestPickupPayload(hqRoot, payload);
+    if (ingested.host.kind === "outpost") {
+        try {
+            refuseOutpostSelfTarget(hqRoot, ingested, {
+                resolveMachineIdentity: ctx.resolveMachineIdentity,
+                runCompaction: ctx.runCompaction,
+                locateTranscript: ctx.locateTranscript,
+            });
+        }
+        catch (err) {
+            if (isLanesError(err) && err.error === "outpost_self_target") {
+                const cancelled = readLane(hqRoot, ingested.lane_id);
+                printJson({
+                    ok: true,
+                    action: "pickup",
+                    lane_id: cancelled.lane_id,
+                    state: cancelled.state,
+                    error: "outpost_self_target",
+                    lane: cancelled,
+                });
+                return;
+            }
+            throw err;
+        }
+    }
+    const afterAccount = applyOutpostAccountPickup(hqRoot, ingested.lane_id);
+    if (isTerminalLaneState(afterAccount.state)) {
+        printJson({
+            ok: true,
+            action: "pickup",
+            lane_id: afterAccount.lane_id,
+            state: afterAccount.state,
+            terminal_reason: afterAccount
+                .terminal_reason,
+            lane: afterAccount,
+        });
+        return;
+    }
+    const config = loadLanesConfig(hqRoot);
+    let admission = admitCreate({
+        hqRoot,
+        provider: afterAccount.provider,
+        pinnedAccount: afterAccount.account,
+        priority: afterAccount.priority,
+        createdAt: afterAccount.created_at,
+        config,
+        excludeLaneId: afterAccount.lane_id,
+    });
+    if (admission.action === "refuse" && admission.error) {
+        throw admission.error;
+    }
+    admission = await applyThrottle(hqRoot, config, ctx, admission, afterAccount.provider, afterAccount.account);
+    if (admission.action === "refuse" && admission.error) {
+        throw admission.error;
+    }
+    let started;
+    if (admission.action === "queue") {
+        started = casUpdateLane(hqRoot, afterAccount.lane_id, (current) => {
+            if (isTerminalLaneState(current.state))
+                return current;
+            return {
+                ...current,
+                state: "queued",
+                queued_reason: admission.reason,
+            };
+        });
+    }
+    else {
+        try {
+            started = spawnLaneWorker(hqRoot, afterAccount, {
+                env: ctx.env,
+                existsSync: ctx.existsSync,
+                spawnProcess: ctx.spawnProcess,
+                proveDetached: ctx.proveDetached,
+                killProcess: ctx.killProcess,
+                now: ctx.now,
+                resolveMachineIdentity: ctx.resolveMachineIdentity,
+                runCompaction: ctx.runCompaction,
+                locateTranscript: ctx.locateTranscript,
+            });
+        }
+        catch (err) {
+            if (isLanesError(err) && err.error === "outpost_self_target") {
+                const cancelled = readLane(hqRoot, afterAccount.lane_id);
+                printJson({
+                    ok: true,
+                    action: "pickup",
+                    lane_id: cancelled.lane_id,
+                    state: cancelled.state,
+                    error: "outpost_self_target",
+                    lane: cancelled,
+                });
+                return;
+            }
+            throw err;
+        }
+    }
+    printJson({
+        ok: true,
+        action: "pickup",
+        lane_id: started.lane_id,
+        state: started.state,
+        queued_reason: started.queued_reason ?? null,
+        lane: started,
+    });
+}
+async function runList(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const state = opts.state ? parseLaneState(opts.state) : undefined;
+    const senior = opts.senior ? parseSeniorRef(opts.senior) : undefined;
+    let company;
+    if (opts.company) {
+        company = await ctx.resolveCompany(opts.company);
+    }
+    const now = ctx.now();
+    const lanes = loadAllLanes(hqRoot)
+        .filter((lane) => {
+        if (state && lane.state !== state)
+            return false;
+        if (opts.project && lane.project_id !== opts.project)
+            return false;
+        if (opts.story && lane.story_id !== opts.story)
+            return false;
+        if (company && !recordMatchesCompany(lane.company, company)) {
+            return false;
+        }
+        if (senior && seniorKey(lane.senior) !== seniorKey(senior))
+            return false;
+        return true;
+    })
+        .sort(compareQueueOrder)
+        .map((lane) => ({
+        ...lane,
+        overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
+        stalled: Boolean(lane.stalled),
+        // Listing is observational. Reconcile owns durable liveness transitions.
+        senior_lost: lane.state === "running" && lane.senior.kind === "session" && lane.senior.id
+            ? (() => {
+                const state = sessionLiveness(hqRoot, lane.senior.id, {
+                    nowMs: now.getTime(),
+                    deps: livenessDepsFromCtx(ctx),
+                    presenceConnected: ctx.presenceConnected,
+                });
+                return state === null || state === "ended" || state === "lost";
+            })()
+            : false,
+    }));
+    printJson({ ok: true, action: "list", lanes });
+}
+async function runShow(ctx, laneId) {
+    const hqRoot = ctx.hqRoot();
+    const lane = readLane(hqRoot, laneId);
+    const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
+    printJson({
+        ok: true,
+        action: "show",
+        lane,
+        overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, ctx.now()),
+        stalled: Boolean(lane.stalled),
+        stalled_at: lane.stalled_at ?? null,
+        stalled_reason: lane.stalled_reason ?? null,
+        ask_delivery_failed: askDeliveryFailed,
+        delivery: laneDeliveryMechanism(lane),
+        provider_session_id: lane.provider_session_id ?? null,
+        provider_session_id_absent: lane.provider_session_id_absent ?? null,
+        envelope_repair_mode: lane.envelope_repair?.mode ?? null,
+        last_resume: lane.last_resume ?? null,
+        last_run_usage: lane.last_run_usage ?? null,
+        model: lane.model ?? null,
+        effort: lane.effort ?? null,
+        effort_source: lane.effort_source ?? null,
+        last_message_at: lane.last_message_at ?? null,
+        last_compaction: lane.last_compaction
+            ? { ...lane.last_compaction, after: compactionAfterUsage(lane) }
+            : null,
+    });
+}
+async function runMessage(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const text = opts.text;
+    if (!text) {
+        throw new LanesError("missing_text", "--text is required", {});
+    }
+    const lane = readLane(hqRoot, laneId);
+    // One decision point for how a follow-up reaches this lane (delivery.ts).
+    // `none` refuses before anything is written: no inbox append, no spawn.
+    const mechanism = laneDeliveryMechanism(lane);
+    if (mechanism === "none") {
+        const message = deliveryRefusalReason(lane);
+        throw new LanesError("lane_not_accepting_messages", message, {
+            lane_id: laneId,
+            state: lane.state,
+            provider: lane.provider,
+            message,
+        });
+    }
+    const messageId = mintMessageId();
+    const at = ctx.now().toISOString();
+    const projectId = opts.project?.trim() || lane.project_id;
+    const storyId = opts.story?.trim() || lane.story_id;
+    const dropboxMessage = {
+        at,
+        message_id: messageId,
+        text,
+        project_id: projectId,
+        story_id: storyId,
+    };
+    let resumed = null;
+    if (mechanism === "dropbox") {
+        // Live (or about-to-be-live) process: the PreToolUse drain delivers it.
+        if (!laneAcceptsOperatorMessage(lane)) {
+            throw new LanesError("lane_not_accepting_messages", operatorMessageRefusalReason(lane.state), { lane_id: laneId, state: lane.state });
+        }
+        appendDropboxMessage(hqRoot, laneId, dropboxMessage);
+    }
+    else {
+        // Exited Claude worker with a recorded session: the message becomes the
+        // next turn of that session. It is archived under delivered/ (never the
+        // inbox, which would hand it to the drain hook a second time) and the
+        // spawn happens before any attribution write so a failed spawn leaves
+        // the record untouched.
+        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+        resumed = spawnLaneWorker(hqRoot, lane, {
+            env: ctx.env,
+            existsSync: ctx.existsSync,
+            spawnProcess: ctx.spawnProcess,
+            proveDetached: ctx.proveDetached,
+            killProcess: ctx.killProcess,
+            now: ctx.now,
+            resolveMachineIdentity: ctx.resolveMachineIdentity,
+            runCompaction: ctx.runCompaction,
+            locateTranscript: ctx.locateTranscript,
+        }, {
+            trigger: { kind: "message", text, message_id: messageId },
+            compact: opts.compact !== false,
+        });
+    }
+    // Every accepted message moves the compaction reference forward.
+    let next = casUpdateLane(hqRoot, laneId, (current) => ({
+        ...current,
+        last_message_at: at,
+    }));
+    if (projectId !== lane.project_id || storyId !== lane.story_id) {
+        next = casUpdateLane(hqRoot, laneId, (current) => {
+            const already = current.attribution_history.some((entry) => entry.message_id === messageId);
+            if (already)
+                return current;
+            return {
+                ...current,
+                project_id: projectId,
+                story_id: storyId,
+                attribution_history: appendCappedHistory(current.attribution_history, {
+                    project_id: projectId,
+                    story_id: storyId,
+                    message_id: messageId,
+                    at,
+                }),
+            };
+        });
+    }
+    // What this command can claim when it returns: the message is durably
+    // written (accepted). Delivery to the model is asynchronous in both
+    // mechanisms. `dropbox` delivers on the worker's next tool call, and only
+    // if the drain hook is registered in the account home the worker was
+    // started from; `resume` has started a new worker with the message as its
+    // prompt. Neither is "delivered", so the response never says so.
+    const drainHook = drainHookStatusFor(ctx, next);
+    const deliveryStatus = mechanism === "dropbox" ? "awaiting_next_tool_call" : "worker_spawned";
+    const warning = mechanism === "dropbox" && drainHook !== null && !drainHook.registered
+        ? `The drain hook is not registered in ${drainHook.path}; the running worker will not receive this message. It stays in the inbox and is delivered on the lane's next start.`
+        : mechanism === "dropbox" && next.stalled === true
+            ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
+            : null;
+    printJson({
+        ok: true,
+        action: "message",
+        lane_id: laneId,
+        message_id: messageId,
+        accepted: true,
+        delivered: false,
+        delivery: mechanism,
+        delivery_status: deliveryStatus,
+        inbox_path: mechanism === "dropbox" ? dropboxInboxPath(hqRoot, laneId) : null,
+        drain_hook: drainHook,
+        warning,
+        resumed_session_id: resumed?.last_resume?.session_id ?? null,
+        compaction: resumed?.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
+            ? resumed.last_compaction
+            : null,
+        project_id: next.project_id,
+        story_id: next.story_id,
+        lane: next,
+    });
+}
+/**
+ * `hq lanes resume <lane-id> [--text <msg>]`: the explicit opt-in that
+ * continues a lane in `interrupted`, `done` or `blocked` on its recorded
+ * provider session. `hq lanes message` keeps refusing `interrupted`; this
+ * command is the path its refusal names. The launch is the same
+ * `spawnLaneWorker` a message resume uses, so the resume-time compaction
+ * rule and the watcher's mesh events are the same. The record gains
+ * `last_resume` with `trigger: "resume"`, `resumed_from` and the text.
+ */
+async function runResume(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const lane = readLane(hqRoot, laneId);
+    const refusal = resumeCommandRefusal(lane);
+    if (refusal !== null) {
+        throw new LanesError(refusal.error, refusal.message, {
+            lane_id: laneId,
+            state: lane.state,
+            provider: lane.provider,
+            message: refusal.message,
+        });
+    }
+    const resumedFrom = lane.state;
+    const text = opts.text?.trim() ? opts.text : undefined;
+    const at = ctx.now().toISOString();
+    const projectId = opts.project?.trim() || lane.project_id;
+    const storyId = opts.story?.trim() || lane.story_id;
+    const attributionChanged = projectId !== lane.project_id || storyId !== lane.story_id;
+    const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
+    const resumed = spawnLaneWorker(hqRoot, lane, {
+        env: ctx.env,
+        existsSync: ctx.existsSync,
+        spawnProcess: ctx.spawnProcess,
+        proveDetached: ctx.proveDetached,
+        killProcess: ctx.killProcess,
+        now: ctx.now,
+        resolveMachineIdentity: ctx.resolveMachineIdentity,
+        runCompaction: ctx.runCompaction,
+        locateTranscript: ctx.locateTranscript,
+    }, {
+        trigger: {
+            kind: "resume",
+            from: resumedFrom,
+            ...(text !== undefined ? { text } : {}),
+            ...(messageId !== undefined ? { message_id: messageId } : {}),
+        },
+        compact: opts.compact !== false,
+    });
+    if (text !== undefined && messageId !== undefined) {
+        // Same audit copy a message resume leaves; nothing drains it. Archive only
+        // after a successful spawn so a concurrent resume cannot leave a phantom.
+        archiveResumeMessage(hqRoot, laneId, {
+            at,
+            message_id: messageId,
+            text,
+            project_id: projectId,
+            story_id: storyId,
+            resumed_from: resumedFrom,
+        });
+    }
+    let next = resumed;
+    if (text !== undefined) {
+        // An operator text moves the compaction reference forward, as a message does.
+        next = casUpdateLane(hqRoot, laneId, (current) => ({
+            ...current,
+            last_message_at: at,
+        }));
+    }
+    if (messageId !== undefined && attributionChanged) {
+        next = casUpdateLane(hqRoot, laneId, (current) => {
+            const already = current.attribution_history.some((entry) => entry.message_id === messageId);
+            if (already)
+                return current;
+            return {
+                ...current,
+                project_id: projectId,
+                story_id: storyId,
+                attribution_history: appendCappedHistory(current.attribution_history, {
+                    project_id: projectId,
+                    story_id: storyId,
+                    message_id: messageId,
+                    at,
+                }),
+            };
+        });
+    }
+    printJson({
+        ok: true,
+        action: "resume",
+        lane_id: laneId,
+        resumed_from: resumedFrom,
+        message_id: messageId ?? null,
+        text: text ?? null,
+        delivery: "resume",
+        delivery_status: "worker_spawned",
+        resumed_session_id: resumed.last_resume?.session_id ?? null,
+        last_resume: next.last_resume ?? null,
+        compaction: resumed.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
+            ? resumed.last_compaction
+            : null,
+        project_id: next.project_id,
+        story_id: next.story_id,
+        lane: next,
+    });
+}
+/**
+ * Registration state of the drain hook in the lane's account home, read the
+ * way the provider reads it. Null when the lane has no bound account yet
+ * (queued): spawn installs the hook before the worker starts.
+ */
+function drainHookStatusFor(ctx, lane) {
+    if (lane.account === undefined)
+        return null;
+    const hqRoot = ctx.hqRoot();
+    const config = loadLanesConfig(hqRoot);
+    const account = config.providers[lane.provider].accounts[lane.account];
+    if (account === undefined)
+        return null;
+    const home = canonicalizeHome(account.home, {
+        homedir: ctx.homedir,
+        realpathSync: (p) => fs.realpathSync(p),
+        existsSync: (p) => fs.existsSync(p),
+    });
+    const probe = probeDrainHookRegistration(lane.provider, home);
+    return { registered: probe.registered, kind: probe.kind, path: probe.path };
+}
+/** Audit copy of a message delivered by resume. Not the inbox: nothing drains this. */
+function archiveResumeMessage(hqRoot, laneId, message) {
+    const dir = path.join(dropboxDir(hqRoot, laneId), "delivered");
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, `${message.message_id}.resume.jsonl`), `${JSON.stringify(message)}\n`, "utf8");
+}
+async function runReparent(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    if (!opts.senior) {
+        throw new LanesError("missing_senior", "--senior is required", {});
+    }
+    const nextSenior = parseSeniorRef(opts.senior);
+    assertSeniorExists(hqRoot, nextSenior, ctx);
+    const lane = readLane(hqRoot, laneId);
+    if (isTerminalLaneState(lane.state)) {
+        throw new LanesError("lane_terminal", `Cannot re-parent a lane in terminal state ${lane.state}`, { lane_id: laneId, state: lane.state });
+    }
+    const seniorCompany = companyOfSenior(hqRoot, nextSenior, ctx);
+    assertSameTenant(lane.company, nextSenior, seniorCompany, { lane_id: laneId });
+    if (walkHitsLane(hqRoot, nextSenior, laneId, ctx)) {
+        throw new LanesError("senior_cycle", `Re-parent would create a cycle through ${laneId}`, { lane_id: laneId, senior: nextSenior });
+    }
+    const newDepth = derivedLaneDepth(hqRoot, nextSenior, ctx);
+    if (newDepth > MAX_LANE_DEPTH) {
+        throw new LanesError("max_lane_depth", `Re-parent would put lane at depth ${newDepth} (cap ${MAX_LANE_DEPTH})`, { depth: newDepth, max: MAX_LANE_DEPTH });
+    }
+    const pending = pendingQuestionsForLane(hqRoot, laneId);
+    const oldDepth = derivedLaneDepth(hqRoot, lane.senior, ctx);
+    if (newDepth > oldDepth && pending.length > 0) {
+        throw new LanesError("demotion_with_pending_questions", "Cannot increase a lane's depth while it has pending questions", { lane_id: laneId, from_depth: oldDepth, to_depth: newDepth });
+    }
+    const override = { laneId, senior: nextSenior, depth: newDepth };
+    for (const other of loadAllLanes(hqRoot)) {
+        if (other.lane_id === laneId)
+            continue;
+        if (!walkHitsLane(hqRoot, other.senior, laneId, ctx))
+            continue;
+        const d = derivedLaneDepth(hqRoot, other.senior, ctx, override);
+        if (d > MAX_LANE_DEPTH) {
+            throw new LanesError("max_lane_depth", `Re-parent would put descendant ${other.lane_id} at depth ${d}`, { lane_id: other.lane_id, depth: d, max: MAX_LANE_DEPTH });
+        }
+    }
+    const at = ctx.now().toISOString();
+    const updated = casUpdateLane(hqRoot, laneId, (current) => {
+        const already = current.senior_history.some((entry) => entry.at === at && entry.reason === (opts.reason ?? "reparent"));
+        if (already && current.depth === newDepth)
+            return current;
+        return {
+            ...current,
+            senior: nextSenior,
+            depth: newDepth,
+            senior_history: appendCappedHistory(current.senior_history, {
+                from: current.senior,
+                to: nextSenior,
+                at,
+                by: sessionIdFromEnv(ctx.env) ?? "user",
+                reason: opts.reason ?? "reparent",
+            }),
+        };
+    });
+    for (const question of pending) {
+        casUpdateQuestion(hqRoot, question.question_id, (current) => {
+            const already = current.routing_history.some((entry) => entry.reason === "reparented" && entry.at === at);
+            if (already)
+                return current;
+            return {
+                ...current,
+                routing_history: appendCappedHistory(current.routing_history, {
+                    hop: current.hop,
+                    audience: resolveAudience(hqRoot, current, ctx),
+                    at,
+                    reason: "reparented",
+                }),
+            };
+        });
+    }
+    printJson({
+        ok: true,
+        action: "reparent",
+        lane: updated,
+        pending_questions: pending.length,
+    });
+}
+const CANONICAL_LOG_STREAMS = [
+    "watcher.err",
+    "watcher.out",
+    "worker.err",
+    "worker.out",
+];
+async function runLogs(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    readLane(hqRoot, laneId);
+    const logsDir = path.join(runDir(hqRoot, laneId), "logs");
+    const tail = parseOptionalInt(opts.tail, "--tail");
+    if (tail === 0) {
+        throw new LanesError("invalid_integer", "--tail must be a positive integer", { flag: "--tail", value: opts.tail });
+    }
+    const names = new Set(CANONICAL_LOG_STREAMS);
+    if (fs.existsSync(logsDir)) {
+        for (const name of fs.readdirSync(logsDir)) {
+            if (!name.startsWith("."))
+                names.add(name);
+        }
+    }
+    const streams = [...names].sort().map((name) => {
+        const filePath = path.join(logsDir, name);
+        let bytes = 0;
+        let text = "";
+        try {
+            const st = fs.statSync(filePath);
+            if (st.isFile()) {
+                bytes = st.size;
+                text = fs.readFileSync(filePath, "utf8");
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code !== "ENOENT")
+                throw err;
+        }
+        const lines = text.split("\n").filter((line) => line.length > 0);
+        const sliced = tail === undefined ? lines : lines.slice(-tail);
+        return { name, path: filePath, bytes, lines: sliced };
+    });
+    printJson({ ok: true, action: "logs", lane_id: laneId, streams });
+}
+export function stopCommittedState(state) {
+    return state === "queued" ? "cancelled" : "killed";
+}
+async function runStop(ctx, laneId) {
+    const hqRoot = ctx.hqRoot();
+    const lane = readLane(hqRoot, laneId);
+    if (isTerminalLaneState(lane.state)) {
+        throw new LanesError("already_terminal", `Lane ${laneId} is already ${lane.state}`, { lane_id: laneId, state: lane.state });
+    }
+    const at = ctx.now().toISOString();
+    const updated = casUpdateLane(hqRoot, laneId, (current) => {
+        if (isTerminalLaneState(current.state)) {
+            throw new LanesError("already_terminal", `Lane ${laneId} is already ${current.state}`, { lane_id: laneId, state: current.state });
+        }
+        return {
+            ...current,
+            state: stopCommittedState(current.state),
+            queued_reason: undefined,
+        };
+    });
+    if (updated.state === "killed") {
+        stopLaneProcesses(hqRoot, laneId, {
+            killProcess: ctx.killProcess,
+            isAlive: ctx.isAlive,
+            sleepMs: ctx.stopSleepMs,
+        });
+    }
+    const cancelled = cancelPendingQuestionsForLane(hqRoot, laneId, at);
+    printJson({
+        ok: true,
+        action: "stop",
+        lane: updated,
+        cancelled_questions: cancelled.map((q) => q.question_id),
+    });
+}
+async function runAsk(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const laneId = ctx.env.HQ_LANE_ID?.trim();
+    if (!laneId) {
+        throw new LanesError("missing_lane_id", "hq lanes ask requires HQ_LANE_ID in the environment", {});
+    }
+    const questionText = opts.question?.trim();
+    if (!questionText) {
+        throw new LanesError("missing_question", "--question is required", {});
+    }
+    const lane = readLane(hqRoot, laneId);
+    const optionList = Array.isArray(opts.option)
+        ? opts.option
+        : opts.option
+            ? [opts.option]
+            : [];
+    const body = {
+        question: questionText,
+        context: opts.context ?? "",
+        options: optionList,
+    };
+    if (opts.recommended !== undefined)
+        body.recommended = opts.recommended;
+    const at = ctx.now().toISOString();
+    let questionId;
+    let lastErr;
+    const attempts = ASK_ATTEMPTS;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            const withBody = raiseLaneQuestion({
+                hqRoot,
+                lane,
+                body,
+                raisedVia: "cli",
+                at,
+                questionId,
+            });
+            questionId = withBody.question_id;
+            await emitLaneMeshEvent(ctx, lane.company, lane.thread_id, "lane_question", {
+                lane_id: lane.lane_id,
+                question_id: withBody.question_id,
+                hop: withBody.hop,
+            });
+            const audience = resolveAudience(hqRoot, withBody, ctx);
+            if (audience.kind === "user") {
+                await emitLaneMeshEvent(ctx, lane.company, lane.thread_id, "lane_question_at_user", {
+                    lane_id: lane.lane_id,
+                    question_id: withBody.question_id,
+                });
+            }
+            printJson({
+                ok: true,
+                action: "ask",
+                question: withBody,
+                lane_id: lane.lane_id,
+                lane_state: lane.state,
+            });
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            process.stderr.write(`hq lanes ask: attempt ${i + 1}/${attempts} failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
+            if (i === attempts - 1)
+                break;
+            await ctx.sleep(ASK_BACKOFF_MS[i] ?? ASK_BACKOFF_MS[ASK_BACKOFF_MS.length - 1]);
+        }
+    }
+    const failure = {
+        schema_version: "hq-lane-ask-delivery-failed.v1",
+        at: ctx.now().toISOString(),
+        lane_id: lane.lane_id,
+        question_id: questionId ?? null,
+        error: lastErr instanceof Error
+            ? { name: lastErr.name, message: lastErr.message }
+            : { name: "Error", message: String(lastErr) },
+    };
+    try {
+        writeJsonFile(askDeliveryFailedPath(hqRoot, lane.lane_id), failure);
+    }
+    catch (writeErr) {
+        process.stderr.write(`hq lanes: failed to write ask_delivery_failed for ${lane.lane_id}: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}\n`);
+    }
+    throw new LanesError("ask_delivery_failed", `Failed to deliver ask for lane ${lane.lane_id}`, {
+        lane_id: lane.lane_id,
+        lane_state: lane.state,
+        ask_delivery_failed: failure,
+    });
+}
+async function runQuestionsList(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const status = opts.status ? parseQuestionStatus(opts.status) : undefined;
+    const forFilter = opts.for ? parseForFilter(opts.for, ctx) : undefined;
+    let company;
+    if (opts.company)
+        company = await ctx.resolveCompany(opts.company);
+    const questions = loadAllQuestions(hqRoot)
+        .filter((q) => {
+        if (status && q.status !== status)
+            return false;
+        if (opts.from && q.lane_id !== opts.from && q.origin.id !== opts.from)
+            return false;
+        if (opts.project && q.project_id !== opts.project)
+            return false;
+        if (opts.story && q.story_id !== opts.story)
+            return false;
+        if (company && !recordMatchesCompany(q.company, company)) {
+            return false;
+        }
+        if (forFilter) {
+            const audience = resolveAudience(hqRoot, q, ctx);
+            if (!audienceMatches(audience, forFilter))
+                return false;
+        }
+        return true;
+    })
+        .map((q) => ({
+        ...q,
+        audience: resolveAudience(hqRoot, q, ctx),
+        ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
+    }));
+    printJson({ ok: true, action: "questions.list", questions });
+}
+async function runQuestionsShow(ctx, questionId) {
+    const hqRoot = ctx.hqRoot();
+    const question = readQuestion(hqRoot, questionId);
+    const body = readQuestionBody(hqRoot, question);
+    printJson({
+        ok: true,
+        action: "questions.show",
+        question,
+        audience: resolveAudience(hqRoot, question, ctx),
+        body,
+    });
+}
+async function runQuestionsAnswer(ctx, questionId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const question = readQuestion(hqRoot, questionId);
+    throwIfQuestionNotPending(question);
+    await yieldEventLoop();
+    const body = requireQuestionBody(hqRoot, question);
+    // A trimmed-empty --freeform is absent: it must not win over --choice and
+    // must not become a freeform answer of "".
+    const freeform = opts.freeform?.trim() || undefined;
+    if (freeform !== undefined && body.options.length === 0) {
+        throw new LanesError("freeform_not_allowed", "--freeform is only allowed for a question with options", { question_id: questionId });
+    }
+    if (!freeform && !opts.choice) {
+        throw new LanesError("missing_choice", "--choice or --freeform is required", {});
+    }
+    const choice = freeform ?? resolveAnswerChoice(opts.choice, body.options, false);
+    const at = ctx.now().toISOString();
+    const answeredBy = sessionIdFromEnv(ctx.env)
+        ? `session:${sessionIdFromEnv(ctx.env)}`
+        : "user";
+    const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+        throwIfQuestionNotPending(current);
+        let notesRef;
+        let nextBody = current.body;
+        if (opts.notes) {
+            const stored = writeQuestionBody(hqRoot, current, {
+                ...body,
+                notes: opts.notes,
+            });
+            notesRef = stored.ref;
+            nextBody = stored;
+        }
+        return {
+            ...current,
+            body: nextBody,
+            status: "answered",
+            answer: {
+                choice,
+                answer_kind: freeform ? "freeform" : "option",
+                notes_ref: notesRef,
+                answered_by: answeredBy,
+                answered_at: at,
+                answered_level: current.hop,
+            },
+        };
+    });
+    const delivery = deliverAnswerToAskingLane(hqRoot, updated, choice, at);
+    printJson({
+        ok: true,
+        action: "questions.answer",
+        question: updated,
+        delivery: delivery.status,
+    });
+}
+function writeAnswerDeliveryFailed(hqRoot, laneId, questionId, err, at) {
+    const failure = {
+        schema_version: "hq-lane-ask-delivery-failed.v1",
+        at,
+        lane_id: laneId,
+        question_id: questionId,
+        error: err instanceof Error
+            ? { name: err.name, message: err.message }
+            : { name: "Error", message: String(err) },
+    };
+    try {
+        writeJsonFile(askDeliveryFailedPath(hqRoot, laneId), failure);
+    }
+    catch (writeErr) {
+        process.stderr.write(`hq lanes: failed to write ask_delivery_failed for ${laneId}: ${writeErr instanceof Error ? writeErr.message : String(writeErr)}\n`);
+    }
+}
+/**
+ * Record is already durable. Delivery is best-effort onto the asking lane's
+ * drop box (spec §6.5). Target is question.lane_id, never a project/story lookup.
+ */
+function deliverAnswerToAskingLane(hqRoot, question, choice, at) {
+    const laneId = laneIdForAnswerDelivery(question);
+    try {
+        const lane = readLane(hqRoot, laneId);
+        if (!laneAcceptsDropboxDelivery(lane)) {
+            return { status: "recorded_only" };
+        }
+        appendDropboxMessage(hqRoot, laneId, answerDropboxMessage(question, choice, at, mintMessageId()));
+        return { status: "dropped" };
+    }
+    catch (err) {
+        writeAnswerDeliveryFailed(hqRoot, laneId, question.question_id, err, at);
+        return { status: "failed" };
+    }
+}
+async function runQuestionsEscalate(ctx, questionId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const question = readQuestion(hqRoot, questionId);
+    throwIfQuestionNotPending(question);
+    await yieldEventLoop();
+    const originalHop = question.hop;
+    const audience = resolveAudience(hqRoot, question, ctx);
+    if (audience.kind === "user") {
+        throw new LanesError("already_at_top_authority", "Cannot escalate past the user", { question_id: questionId });
+    }
+    const at = ctx.now().toISOString();
+    if (opts.note) {
+        requireQuestionBody(hqRoot, question);
+    }
+    const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+        throwIfQuestionNotPending(current);
+        if (current.hop !== originalHop) {
+            throw new LanesError("question_already_escalated", `Question ${questionId} hop already advanced`, {
+                question_id: questionId,
+                hop: current.hop,
+                expected_hop: originalHop,
+            });
+        }
+        let nextBody = current.body;
+        if (opts.note) {
+            const body = requireQuestionBody(hqRoot, current);
+            nextBody = writeQuestionBody(hqRoot, current, {
+                ...body,
+                notes: [body.notes, opts.note].filter(Boolean).join("\n"),
+            });
+        }
+        const nextHop = current.hop + 1;
+        return {
+            ...current,
+            body: nextBody,
+            hop: nextHop,
+            routing_history: appendCappedHistory(current.routing_history, {
+                hop: nextHop,
+                audience: resolveAudience(hqRoot, { ...current, hop: nextHop }, ctx),
+                at,
+                reason: "escalated",
+            }),
+        };
+    });
+    const nextAudience = resolveAudience(hqRoot, updated, ctx);
+    if (nextAudience.kind === "user") {
+        const lane = readLane(hqRoot, updated.lane_id);
+        await emitLaneMeshEvent(ctx, lane.company, lane.thread_id, "lane_question_at_user", { lane_id: lane.lane_id, question_id: updated.question_id });
+    }
+    printJson({ ok: true, action: "questions.escalate", question: updated });
+}
+async function runQuestionsCancel(ctx, questionId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const question = readQuestion(hqRoot, questionId);
+    throwIfQuestionNotPending(question);
+    await yieldEventLoop();
+    const at = ctx.now().toISOString();
+    const updated = casUpdateQuestion(hqRoot, questionId, (current) => {
+        throwIfQuestionNotPending(current);
+        const entry = {
+            hop: current.hop,
+            audience: resolveAudience(hqRoot, current, ctx),
+            at,
+            reason: "cancelled",
+            ...(opts.reason ? { detail: opts.reason } : {}),
+        };
+        return {
+            ...current,
+            status: "cancelled",
+            routing_history: appendCappedHistory(current.routing_history, entry),
+        };
+    });
+    printJson({ ok: true, action: "questions.cancel", question: updated });
+}
+async function runAccountsList(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const config = loadLanesConfig(hqRoot);
+    const providers = opts.provider
+        ? [parseLaneProvider(opts.provider)]
+        : [...LANE_PROVIDERS];
+    // model and effort are what a spawn on each account would start from
+    // (spec: --model/--effort, then the account, then the provider).
+    const quota = loadQuotaState(hqRoot);
+    const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config).map((status) => {
+        const accountCfg = config.providers[provider].accounts[status.id];
+        const model = resolveLaneModel({
+            accountModel: accountCfg?.model,
+            providerModel: config.providers[provider].model,
+        });
+        const effort = resolveLaneEffort({
+            accountEffort: accountCfg?.effort,
+            providerEffort: config.providers[provider].effort,
+            model,
+        });
+        return {
+            ...status,
+            model: accountCfg?.model ?? null,
+            effort: accountCfg?.effort ?? null,
+            effective_model: model ?? null,
+            effective_effort: effort.effort ?? null,
+            effective_effort_source: effort.source,
+            ...accountQuotaView(quota, provider, status.id),
+        };
+    }));
+    const providerDefaults = providers.map((provider) => ({
+        provider,
+        model: config.providers[provider].model ?? null,
+        effort: config.providers[provider].effort ?? null,
+        compact_after_ms: providerCompactAfterMs(config.providers[provider]),
+    }));
+    printJson({
+        ok: true,
+        action: "accounts.list",
+        providers: providerDefaults,
+        accounts,
+    });
+}
+async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
+    const callerCwd = ctx.callerCwd();
+    const hqRoot = ctx.hqRoot();
+    const provider = parseLaneProvider(providerRaw);
+    const config = loadLanesConfig(hqRoot);
+    const id = accountId.trim();
+    if (!id) {
+        throw new LanesError("invalid_account", "account-id must be non-empty", {});
+    }
+    const homeRaw = opts.home?.trim() ||
+        (id === "a"
+            ? DEFAULT_ACCOUNT_HOMES[provider]
+            : `~/.${provider}-${id}`);
+    const homeResolved = homeRaw.startsWith("~") || path.isAbsolute(homeRaw)
+        ? homeRaw
+        : resolveCallerPath(callerCwd, homeRaw);
+    const home = canonicalizeHome(homeResolved, {
+        homedir: ctx.homedir,
+        realpathSync: (p) => fs.realpathSync(p),
+        existsSync: (p) => fs.existsSync(p),
+    });
+    for (const [existingId, account] of Object.entries(config.providers[provider].accounts)) {
+        if (existingId === id)
+            continue;
+        if (account.home === home) {
+            throw new LanesError("duplicate_account_home", `Home ${home} is already registered as ${provider} account ${existingId}`, { provider, accounts: [existingId, id], home });
+        }
+    }
+    ensureDir(home);
+    const defaultId = config.providers[provider].default_account;
+    const defaultHome = (defaultId !== undefined
+        ? config.providers[provider].accounts[defaultId]?.home
+        : undefined) ??
+        Object.values(config.providers[provider].accounts).find((account) => account.enabled)
+            ?.home ??
+        canonicalizeHome(DEFAULT_ACCOUNT_HOMES[provider], {
+            homedir: ctx.homedir,
+            realpathSync: (p) => fs.realpathSync(p),
+            existsSync: (p) => fs.existsSync(p),
+        });
+    const copied = defaultHome !== home ? copyHookRails(defaultHome, home) : railsPresent(home);
+    installDrainHook(provider, home);
+    const envVar = PROVIDER_HOME_ENV[provider];
+    const login = VENDOR_LOGIN[provider];
+    const result = await ctx.spawnLogin({
+        command: login.command,
+        args: login.args,
+        env: { ...ctx.env, [envVar]: home },
+        cwd: home,
+    });
+    if (result.status !== 0) {
+        throw new LanesError("login_failed", `${login.command} ${login.args.join(" ")} exited ${result.status}`, { provider, account: id, status: result.status });
+    }
+    const grokNeedsRails = provider === "grok";
+    if ((grokNeedsRails || copied) && !railsPresent(home)) {
+        throw new LanesError("rails_missing", `Hook rails are missing under ${home}; account not enabled`, { provider, account: id, home });
+    }
+    config.providers[provider].accounts[id] = {
+        home,
+        enabled: true,
+    };
+    writeLanesConfig(hqRoot, config);
+    const status = accountStatus(provider, id, loadLanesConfig(hqRoot));
+    printJson({ ok: true, action: "accounts.login", account: status });
+}
+async function runAccountsEnable(ctx, providerRaw, accountId) {
+    const hqRoot = ctx.hqRoot();
+    const provider = parseLaneProvider(providerRaw);
+    const config = loadLanesConfig(hqRoot);
+    const account = config.providers[provider].accounts[accountId];
+    if (!account) {
+        throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(accountId)} for ${provider}`, {
+            provider,
+            account: accountId,
+            enabled: Object.entries(config.providers[provider].accounts)
+                .filter(([, a]) => a.enabled)
+                .map(([id]) => id),
+        });
+    }
+    account.enabled = true;
+    delete account.disabled_reason;
+    writeLanesConfig(hqRoot, config);
+    printJson({
+        ok: true,
+        action: "accounts.enable",
+        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot)),
+    });
+}
+async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
+    const hqRoot = ctx.hqRoot();
+    const provider = parseLaneProvider(providerRaw);
+    const config = loadLanesConfig(hqRoot);
+    const account = config.providers[provider].accounts[accountId];
+    if (!account) {
+        throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(accountId)} for ${provider}`, {
+            provider,
+            account: accountId,
+            enabled: Object.entries(config.providers[provider].accounts)
+                .filter(([, a]) => a.enabled)
+                .map(([id]) => id),
+        });
+    }
+    account.enabled = false;
+    if (opts.reason)
+        account.disabled_reason = opts.reason;
+    writeLanesConfig(hqRoot, config);
+    printJson({
+        ok: true,
+        action: "accounts.disable",
+        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot)),
+    });
+}
+async function runSessionsList(ctx, opts) {
+    const hqRoot = ctx.hqRoot();
+    const state = opts.state ? parseLivenessState(opts.state) : undefined;
+    const livenessDeps = livenessDepsFromCtx(ctx);
+    const presenceConnected = ctx.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
+    const rows = listSessionLiveness(hqRoot, {
+        nowMs: ctx.now().getTime(),
+        presenceConnected,
+        deps: livenessDeps,
+    }).filter((row) => {
+        if (state && row.state !== state)
+            return false;
+        if (!opts.company)
+            return true;
+        const meta = readSessionMeta(hqRoot, row.sessionId, ctx);
+        const slug = typeof meta?.company_slug === "string" ? meta.company_slug : "";
+        const uid = typeof meta?.company_uid === "string" ? meta.company_uid : "";
+        return slug === opts.company || uid === opts.company;
+    });
+    printJson({ ok: true, action: "sessions.list", sessions: rows });
+}
+async function runSessionsShow(ctx, sessionId) {
+    const hqRoot = ctx.hqRoot();
+    const livenessDeps = livenessDepsFromCtx(ctx);
+    const presenceConnected = ctx.presenceConnected ?? readDaemonPresenceConnected(livenessDeps);
+    const state = sessionLiveness(hqRoot, sessionId, {
+        nowMs: ctx.now().getTime(),
+        presenceConnected,
+        deps: livenessDeps,
+    });
+    if (state === null) {
+        throw new LanesError("session_not_found", `Session ${sessionId} is not in the liveness index`, { session_id: sessionId });
+    }
+    const meta = readSessionMeta(hqRoot, sessionId, ctx);
+    printJson({
+        ok: true,
+        action: "sessions.show",
+        session_id: sessionId,
+        state,
+        senior: meta ? seniorOfSession(hqRoot, sessionId, ctx) : { kind: "user" },
+        company_slug: typeof meta?.company_slug === "string" ? meta.company_slug : null,
+    });
+}
+async function runReconcile(ctx, opts) {
+    const fromEnv = ctx.env.HQ_ROOT?.trim();
+    const hqRoot = fromEnv && ctx.existsSync(fromEnv) ? fromEnv : ctx.hqRoot();
+    const summary = await runReconcilePass(hqRoot, {
+        now: ctx.now,
+        host: reconcileHostFromCtx(ctx),
+        dryRun: Boolean(opts.dryRun),
+        spawnLaneDeps: {
+            env: ctx.env,
+            existsSync: ctx.existsSync,
+            spawnProcess: ctx.spawnProcess,
+            proveDetached: ctx.proveDetached,
+            killProcess: ctx.killProcess,
+            now: ctx.now,
+            resolveMachineIdentity: ctx.resolveMachineIdentity,
+            runCompaction: ctx.runCompaction,
+            locateTranscript: ctx.locateTranscript,
+        },
+        throttleDeps: ctx.throttleDeps,
+        livenessDeps: livenessDepsFromCtx(ctx),
+        presenceConnected: ctx.presenceConnected,
+        env: ctx.env,
+    });
+    printJson(summary);
+    if (!summary.ok) {
+        process.exit(1);
+    }
+}
+async function runReconcileInstall(ctx, opts) {
+    const callerCwd = ctx.callerCwd();
+    const systemdRootRaw = opts.systemdRoot ?? ctx.systemdRoot ?? defaultSystemdUserDir(ctx.homedir());
+    const systemdRoot = opts.systemdRoot !== undefined
+        ? resolveCallerPath(callerCwd, opts.systemdRoot)
+        : systemdRootRaw;
+    const config = loadLanesConfig(ctx.hqRoot());
+    const activeProviders = LANE_PROVIDERS.filter((provider) => Object.values(config.providers[provider].accounts).some((account) => account.enabled));
+    const providerPath = providerPathEnv(activeProviders, ctx.env.PATH);
+    const result = installReconcileTimer({
+        systemdRoot,
+        hqRoot: ctx.hqRoot(),
+        enable: Boolean(opts.enable),
+        runCommand: opts.enable ? ctx.runSystemctl : undefined,
+        pathEnv: providerPath.path,
+    });
+    printJson({
+        ...result,
+        providers_resolved: providerPath.resolved,
+        providers_unresolved: providerPath.unresolved,
+        ...(providerPath.unresolved.length > 0
+            ? {
+                warnings: providerPath.unresolved.map((provider) => `provider binary ${provider} is not on PATH; lanes for ${provider} stay queued with provider_binary_missing until it is installed and the timer is reinstalled`),
+            }
+            : {}),
+    });
+}
+async function runReconcileUninstall(ctx, opts) {
+    const callerCwd = ctx.callerCwd();
+    const systemdRootRaw = opts.systemdRoot ?? ctx.systemdRoot ?? defaultSystemdUserDir(ctx.homedir());
+    const systemdRoot = opts.systemdRoot !== undefined
+        ? resolveCallerPath(callerCwd, opts.systemdRoot)
+        : systemdRootRaw;
+    const result = uninstallReconcileTimer({
+        systemdRoot,
+        disable: Boolean(opts.disable),
+        runCommand: opts.disable ? ctx.runSystemctl : undefined,
+    });
+    printJson(result);
+}
+function commandHasAction(cmd) {
+    return (typeof cmd._actionHandler ===
+        "function");
+}
+/** Spec §7: every command prints JSON. Accept `--json` as a no-op everywhere. */
+function attachJsonNoop(cmd) {
+    const hasJson = (cmd.options ?? []).some((opt) => opt.long === "--json");
+    if (commandHasAction(cmd) && !hasJson) {
+        cmd.option("--json", "JSON on stdout (always)");
+    }
+    for (const child of cmd.commands)
+        attachJsonNoop(child);
+}
+export function registerLanesCommand(parent, deps = {}) {
+    const ctx = resolveDeps(deps);
+    const lanes = parent
+        .command("lanes", { hidden: true })
+        .description("Create, supervise, and steer worker lanes; routed decision queue");
+    lanes
+        .command("create")
+        .description("Register a lane, run admission, and return immediately")
+        .option("--company <slug|uid>", "Company slug or cloud uid; omit for a core/personal lane")
+        .requiredOption("--project <slug>", "HQ project slug")
+        .requiredOption("--story <id>", "Story id from the project's prd.json")
+        .requiredOption("--brief-file <path>", "Path to the lane brief")
+        .option("--worker <name>", "HQ worker id from the registry")
+        .option("--provider <name>", "claude | codex | grok")
+        .option("--account <id>", "Provider account id")
+        .option("--model <id>", "Model id for the provider CLI")
+        .option("--effort <level>", "Effort level; claude: low|medium|high|xhigh|max, codex: minimal|low|medium|high|xhigh|max|ultra, grok: low|medium|high|xhigh")
+        .option("--senior <ref>", "session:<id> | lane:<id> | user")
+        .option("--timeout <secs>", "Deadline in seconds (warns, does not kill)")
+        .option("--priority <n>", "Queue priority; higher runs first", "1")
+        .option("--outpost <id>", "Run on this Outpost instead of the local host")
+        .action(wrap(async (opts) => {
+        await runCreate(ctx, opts);
+    }));
+    lanes
+        .command("list")
+        .description("List lanes")
+        .option("--company <slug|uid>", "Filter by company")
+        .option("--project <slug>", "Filter by project")
+        .option("--story <id>", "Filter by story")
+        .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
+        .option("--senior <ref>", "Filter by senior ref")
+        .option("--json", "JSON on stdout (always)")
+        .action(wrap(async (opts) => {
+        await runList(ctx, opts);
+    }));
+    lanes
+        .command("show")
+        .description("Show one lane")
+        .argument("<lane-id>", "Lane id")
+        .action(wrap(async (laneId) => {
+        await runShow(ctx, laneId);
+    }));
+    lanes
+        .command("message")
+        .description("Send a follow-up message to a lane")
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--text <msg>", "Message text")
+        .option("--project <slug>", "Re-point project attribution from this message")
+        .option("--story <id>", "Re-point story attribution from this message")
+        .option("--no-compact", "Skip the resume-time compaction check for this message")
+        .action(wrap(async (laneId, opts) => {
+        await runMessage(ctx, laneId, opts);
+    }));
+    lanes
+        .command("resume")
+        .description("Resume an interrupted, done or blocked lane on its recorded provider session")
+        .argument("<lane-id>", "Lane id")
+        .option("--text <msg>", "Operator message for the resumed turn")
+        .option("--project <slug>", "Re-point project attribution from this resume")
+        .option("--story <id>", "Re-point story attribution from this resume")
+        .option("--no-compact", "Skip the resume-time compaction check for this resume")
+        .action(wrap(async (laneId, opts) => {
+        await runResume(ctx, laneId, opts);
+    }));
+    lanes
+        .command("reparent")
+        .description("Rewrite a lane's senior edge")
+        .argument("<lane-id>", "Lane id")
+        .requiredOption("--senior <ref>", "session:<id> | lane:<id> | user")
+        .option("--reason <text>", "Why the senior changed")
+        .action(wrap(async (laneId, opts) => {
+        await runReparent(ctx, laneId, opts);
+    }));
+    lanes
+        .command("logs")
+        .description("Print a lane's local logs")
+        .argument("<lane-id>", "Lane id")
+        .option("--tail <n>", "Last N lines")
+        .action(wrap(async (laneId, opts) => {
+        await runLogs(ctx, laneId, opts);
+    }));
+    lanes
+        .command("stop")
+        .description("Cancel a queued lane or kill a running one")
+        .argument("<lane-id>", "Lane id")
+        .action(wrap(async (laneId) => {
+        await runStop(ctx, laneId);
+    }));
+    lanes
+        .command("ask")
+        .description("Queue a mid-run question without blocking the lane")
+        .requiredOption("--question <text>", "Question text")
+        .option("--context <text>", "Context for the audience")
+        .option("--option <text>", "Answer choice (repeatable)", collectRepeatable)
+        .option("--recommended <text>", "Recommended option")
+        .action(wrap(async (opts) => {
+        await runAsk(ctx, opts);
+    }));
+    const questions = lanes
+        .command("questions")
+        .description("Routed decision queue");
+    questions
+        .command("list")
+        .description("List questions")
+        .option("--for <ref>", "Who must decide (ref | me | user)")
+        .option("--from <lane-id>", "Which lane asked")
+        .option("--company <slug|uid>", "Filter by company")
+        .option("--project <slug>", "Filter by project")
+        .option("--story <id>", "Filter by story")
+        .option("--status <status>", `Filter by status (${QUESTION_STATUSES.join("|")})`)
+        .action(wrap(async (opts) => {
+        await runQuestionsList(ctx, opts);
+    }));
+    questions
+        .command("show")
+        .description("Show one question")
+        .argument("<question-id>", "Question id")
+        .action(wrap(async (questionId) => {
+        await runQuestionsShow(ctx, questionId);
+    }));
+    questions
+        .command("answer")
+        .description("Answer a pending question")
+        .argument("<question-id>", "Question id")
+        .option("--choice <label|N>", "1-based index or option label")
+        .option("--notes <text>", "Free-text notes stored with the body")
+        .option("--freeform <text>", "Supply a free-form answer for a question with options")
+        .action(wrap(async (questionId, opts) => {
+        await runQuestionsAnswer(ctx, questionId, opts);
+    }));
+    questions
+        .command("escalate")
+        .description("Advance a question one hop")
+        .argument("<question-id>", "Question id")
+        .option("--note <text>", "Note recorded with the escalation")
+        .action(wrap(async (questionId, opts) => {
+        await runQuestionsEscalate(ctx, questionId, opts);
+    }));
+    questions
+        .command("cancel")
+        .description("Cancel a pending question")
+        .argument("<question-id>", "Question id")
+        .option("--reason <text>", "Why it was cancelled")
+        .action(wrap(async (questionId, opts) => {
+        await runQuestionsCancel(ctx, questionId, opts);
+    }));
+    const accounts = lanes
+        .command("accounts")
+        .description("Provider account registry (configured vs logged in)");
+    accounts
+        .command("list")
+        .description("List accounts")
+        .option("--provider <name>", "claude | codex | grok")
+        .action(wrap(async (opts) => {
+        await runAccountsList(ctx, opts);
+    }));
+    accounts
+        .command("login")
+        .description("Create a home, run the vendor login, and register the account")
+        .argument("<provider>", "claude | codex | grok")
+        .argument("<account-id>", "Open-ended account id")
+        .option("--home <path>", "Account home directory")
+        .action(wrap(async (provider, accountId, opts) => {
+        await runAccountsLogin(ctx, provider, accountId, opts);
+    }));
+    accounts
+        .command("enable")
+        .description("Enable an account without touching credentials")
+        .argument("<provider>", "claude | codex | grok")
+        .argument("<account-id>", "Account id")
+        .action(wrap(async (provider, accountId) => {
+        await runAccountsEnable(ctx, provider, accountId);
+    }));
+    accounts
+        .command("disable")
+        .description("Disable an account without touching credentials")
+        .argument("<provider>", "claude | codex | grok")
+        .argument("<account-id>", "Account id")
+        .option("--reason <text>", "Why the account is disabled")
+        .action(wrap(async (provider, accountId, opts) => {
+        await runAccountsDisable(ctx, provider, accountId, opts);
+    }));
+    const sessions = lanes
+        .command("sessions")
+        .description("Session liveness from the work-mesh spool");
+    sessions
+        .command("list")
+        .description("List sessions")
+        .option("--state <state>", `live | idle | ended | lost`)
+        .option("--company <slug>", "Filter by session meta company_slug")
+        .action(wrap(async (opts) => {
+        await runSessionsList(ctx, opts);
+    }));
+    sessions
+        .command("show")
+        .description("Show one session's liveness")
+        .argument("<session-id>", "Session id")
+        .action(wrap(async (sessionId) => {
+        await runSessionsShow(ctx, sessionId);
+    }));
+    lanes
+        .command("pickup", { hidden: true })
+        .description("Ingest an Outpost-dispatched lane payload and start it on this host")
+        .option("--payload-file <path>", "Local pickup payload JSON")
+        .option("--payload-url <url>", "HTTPS URL of a staged pickup payload")
+        .action(wrap(async (opts) => {
+        await runPickup(ctx, opts);
+    }));
+    const reconcile = lanes
+        .command("reconcile", { hidden: true })
+        .description("Run one machine-owned reconcile pass and exit")
+        .option("--dry-run", "Report what would change and write nothing")
+        .action(wrap(async (opts) => {
+        await runReconcile(ctx, opts);
+    }));
+    reconcile
+        .command("install")
+        .description("Write systemd user unit and timer files (idempotent)")
+        .option("--systemd-root <dir>", "Directory for unit files (default ~/.config/systemd/user)")
+        .option("--enable", "Enable the timer via systemctl --user")
+        .action(wrap(async (opts) => {
+        await runReconcileInstall(ctx, opts);
+    }));
+    reconcile
+        .command("uninstall")
+        .description("Remove systemd user unit and timer files (idempotent)")
+        .option("--systemd-root <dir>", "Directory for unit files")
+        .option("--disable", "Disable the timer via systemctl --user")
+        .action(wrap(async (opts) => {
+        await runReconcileUninstall(ctx, opts);
+    }));
+    attachJsonNoop(lanes);
+    return lanes;
+}
+//# sourceMappingURL=lanes.js.map