@indigoai-us/hq-cli 5.124.0 → 5.126.0

package/dist/commands/lanes.js

@@ -0,0 +1,2032 @@
+/**
+ * `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 } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { OutpostsClient } from "@indigoai-us/hq-cloud/outposts";
+import { ensureCognitoToken } from "../utils/cognito-session.js";
+import { findHqRoot } from "../utils/manifest.js";
+import { parseUserYaml } from "../utils/user-yaml-error.js";
+import { vaultApiFetch } from "../utils/vault-api.js";
+import { openMeshTransport } from "../lib/mesh/client.js";
+import { appendThreadEvent, ensureProjectThread, patchStoryStatus, } from "../lib/mesh/api.js";
+import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
+import { AccountResolutionError, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_BODY_STORES, QUESTION_STATUSES, SENIOR_KINDS, accountMaxRunning, accountStatus, appendCappedHistory, canonicalizeHome, createLane, createQuestion, decideAdmission, defaultThrottleDeps, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readLane, readQuestion, resolveAccount, resolveLaneWorker, sessionLiveness, tryReadLane, updateLane, updateQuestion, writeLanesConfig, } from "../lib/lanes/index.js";
+import { LanesError } from "../lib/lanes/errors.js";
+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"] },
+};
+/**
+ * Spawn seam for the worker process (spec §5). Process spawning and the
+ * reconcile daemon are out of scope for this command surface; calling this
+ * throws rather than faking a running lane.
+ */
+export function spawnLaneWorker(lane) {
+    throw new LanesError("not_implemented", `Lane process spawn is not implemented (lane ${lane.lane_id})`, { lane_id: lane.lane_id });
+}
+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 };
+}
+async function defaultListOutpostIds() {
+    const client = new OutpostsClient({
+        transport: vaultApiFetch,
+        token: () => ensureCognitoToken({ interactive: false }),
+    });
+    const rows = await client.list();
+    return rows.map((row) => row.outpostId);
+}
+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 toMeshCompany(company) {
+    return { companyUid: company.uid, companySlug: company.slug };
+}
+function createDefaultMesh() {
+    return {
+        async ensureProjectThread(company, projectId) {
+            const { token } = await openMeshTransport({ company: company.slug });
+            const ensured = await ensureProjectThread(token, toMeshCompany(company), projectId, { summary: `HQ lane ${projectId}` });
+            return ensured.threadId;
+        },
+        async appendThreadEvent(company, threadId, eventKind, payload) {
+            const { token } = await openMeshTransport({ company: company.slug });
+            await appendThreadEvent(token, company.uid, threadId, eventKind, payload);
+        },
+        async patchStoryStatus(company, projectId, storyId, status) {
+            const { token } = await openMeshTransport({ company: company.slug });
+            await patchStoryStatus(token, company.uid, projectId, storyId, status);
+        },
+    };
+}
+function defaultSleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function resolveDeps(deps = {}) {
+    const env = deps.env ?? process.env;
+    return {
+        hqRoot: deps.hqRoot ?? (() => findHqRoot()),
+        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,
+    };
+}
+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 sha256Text(text) {
+    return `sha256:${createHash("sha256").update(text).digest("hex")}`;
+}
+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 parseQuestionBodyStore(value) {
+    if (typeof value === "string" &&
+        QUESTION_BODY_STORES.includes(value)) {
+        return value;
+    }
+    throw new LanesError("unknown_body_store", `Unknown question body store ${JSON.stringify(value)}. Accepted: ${QUESTION_BODY_STORES.join(", ")}`, { accepted: [...QUESTION_BODY_STORES], value });
+}
+function bodyStoreForLane(lane) {
+    return lane.company.slug ? "company" : "personal";
+}
+/** Tenant-store path for a question body (spec §6.2 / §10). Never the personal vault for company prose. */
+export function questionBodyAbsPath(hqRoot, question) {
+    const store = parseQuestionBodyStore(question.body.store);
+    if (store === "company") {
+        if (!question.company.slug) {
+            throw new LanesError("question_body_store_unresolved", "Company question body is missing a company slug", { question_id: question.question_id });
+        }
+        return path.join(hqRoot, "companies", question.company.slug, "lanes", "questions", `${question.question_id}.json`);
+    }
+    return path.join(hqRoot, "personal", "lanes", "questions", `${question.question_id}.json`);
+}
+function questionBodyRef(questionId) {
+    return path.posix.join("lanes", "questions", `${questionId}.json`);
+}
+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 writeQuestionBody(hqRoot, question, body) {
+    const store = parseQuestionBodyStore(question.body.store);
+    const filePath = questionBodyAbsPath(hqRoot, question);
+    const serialized = `${JSON.stringify(body, null, 2)}\n`;
+    ensureDir(path.dirname(filePath));
+    fs.writeFileSync(filePath, serialized, "utf8");
+    return {
+        store,
+        ref: questionBodyRef(question.question_id),
+        digest: sha256Text(serialized),
+    };
+}
+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 readSessionMeta(hqRoot, sessionId, ctx) {
+    const filePath = sessionMetaPath(hqRoot, sessionId);
+    if (!ctx.existsSync(filePath))
+        return null;
+    const text = ctx.readFileSync(filePath, "utf8");
+    const doc = parseUserYaml(text, filePath);
+    if (doc === null || typeof doc !== "object" || Array.isArray(doc))
+        return null;
+    return 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 null;
+    if (ref.kind === "lane") {
+        if (!ref.id)
+            return null;
+        const lane = readLane(hqRoot, ref.id);
+        return lane.company;
+    }
+    if (!ref.id)
+        return null;
+    const meta = readSessionMeta(hqRoot, ref.id, ctx);
+    if (!meta)
+        return null;
+    const slug = typeof meta.company_slug === "string" ? meta.company_slug : undefined;
+    const uid = typeof meta.company_uid === "string" ? meta.company_uid : undefined;
+    if (!slug && !uid)
+        return null;
+    return { slug, uid };
+}
+function sameTenant(laneCompany, senior, seniorCompany) {
+    if (senior.kind === "user")
+        return true;
+    if (!seniorCompany || (!seniorCompany.slug && !seniorCompany.uid))
+        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
+        ? "Cannot attach a lane to a senior in a different company"
+        : "Cannot attach a lane to a senior whose company is unknown", {
+        lane_company: laneCompany,
+        senior,
+        senior_company: seniorCompany,
+        ...extra,
+    });
+}
+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);
+    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, identity) {
+    if (!known.includes(requested)) {
+        throw new LanesError("unknown_outpost", `Unknown Outpost ${JSON.stringify(requested)}. Accepted: ${known.join(", ") || "(none)"}`, { accepted: known, value: requested });
+    }
+    if (identity.kind === "unknown") {
+        throw new LanesError("outpost_identity_unknown", "This host is an Outpost but its id is unknown; refusing all --outpost targets", { outpost: requested });
+    }
+    if (identity.kind === "id" && identity.id === requested) {
+        throw new LanesError("outpost_self_target", `A host may not target its own Outpost id ${JSON.stringify(requested)}`, { outpost: 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;
+const ASK_BACKOFF_MS = [50, 100, 200, 400];
+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, 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 "";
+}
+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)",
+        "",
+        "## Task",
+        taskBrief.replace(/\s+$/, ""),
+        "",
+    ].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, eventKind, payload) {
+    if (!threadId)
+        return;
+    await ctx.mesh.appendThreadEvent(company, threadId, eventKind, payload);
+}
+export async function emitLaneDecisionEvents(mesh, lane, decision, extra = {}) {
+    const eventKind = decision === "blocked" ? "lane_blocked" : "lane_done";
+    if (lane.thread_id) {
+        await mesh.appendThreadEvent(lane.company, lane.thread_id, eventKind, {
+            lane_id: lane.lane_id,
+            project_id: lane.project_id,
+            story_id: lane.story_id,
+            ...extra,
+        });
+    }
+    if (decision === "done") {
+        await mesh.patchStoryStatus(lane.company, lane.project_id, lane.story_id, "review");
+    }
+}
+export const PICKUP_TERMINAL_REASONS = [
+    "account_not_logged_in",
+    "unknown_account",
+    "account_disabled",
+];
+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 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);
+        const status = accountStatus(lane.provider, resolved.id, config);
+        if (!status.logged_in) {
+            return markPickupFailure(hqRoot, laneId, "account_not_logged_in", {
+                provider: lane.provider,
+                account: resolved.id,
+            });
+        }
+        if (lane.account === resolved.id)
+            return lane;
+        return casUpdateLane(hqRoot, laneId, (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 (!companyFlag) {
+        throw new LanesError("missing_company", "--company is required", {});
+    }
+    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, ctx.readOutpostIdentity());
+    }
+    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 });
+    }
+    const company = await ctx.resolveCompany(companyFlag);
+    const seniorCompany = companyOfSenior(hqRoot, senior, ctx);
+    assertSameTenant(company, senior, seniorCompany);
+    let resolvedWorker;
+    if (opts.worker) {
+        resolvedWorker = resolveLaneWorker(hqRoot, opts.worker, company.slug);
+    }
+    const briefAbs = path.resolve(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 pinnedAccount;
+    if (outpostId) {
+        if (opts.account !== undefined && opts.account.trim() !== "") {
+            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);
+        pinnedAccount = resolved.id;
+    }
+    else {
+        // Unpinned: still refuse at the bind point when every account is disabled
+        // (spec §5.5). The chosen login is not stored; admission binds later.
+        resolveAccount(provider, undefined, config);
+    }
+    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 = await ctx.mesh.ensureProjectThread(company, project);
+    const persist = async () => {
+        let admission;
+        let validation;
+        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,
+            provider,
+            account: pinnedAccount,
+            host,
+            attribution_history: [],
+        });
+        return { lane, admission, validation };
+    };
+    let persisted;
+    if (outpostId) {
+        persisted = await persist();
+    }
+    else {
+        persisted = await withAdmissionLock(admissionLockPath(hqRoot, provider, pinnedAccount), 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)
+        : 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(),
+        });
+    }
+    if (admission.action === "start") {
+        await emitLaneMeshEvent(ctx, company, threadId, "lane_started", {
+            lane_id: lane.lane_id,
+            project_id: project,
+            story_id: story,
+        });
+        await ctx.mesh.patchStoryStatus(company, project, story, "in_progress");
+    }
+    // spawnLaneWorker is the process-launch seam. Create never calls it: spawn
+    // and the watcher are owned by the reconcile daemon (spec §5.7). Admitted
+    // lanes stay queued until that seam is implemented.
+    printJson({
+        ok: true,
+        action: "create",
+        lane_id: lane.lane_id,
+        state: lane.state,
+        queued_reason: lane.queued_reason ?? null,
+        // An admitted lane still reports why it has not started. Without this a
+        // caller sees state=queued with queued_reason=null and cannot tell an
+        // admitted-but-unspawnable lane from a bug.
+        pending_start: admission.action === "start" ? "spawn_not_implemented" : null,
+        priority: lane.priority,
+        provider: lane.provider,
+        account: lane.account ?? null,
+        host: lane.host,
+        company: lane.company,
+        project_id: lane.project_id,
+        story_id: lane.story_id,
+        thread_id: lane.thread_id ?? null,
+        senior: lane.senior,
+        depth: lane.depth,
+        timeout_secs: timeoutSecs ?? null,
+        ...(validation ? { validation } : {}),
+        lane,
+    });
+}
+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 && lane.company.uid !== company.uid && lane.company.slug !== company.slug) {
+            return false;
+        }
+        if (senior && seniorKey(lane.senior) !== seniorKey(senior))
+            return false;
+        return true;
+    })
+        .sort(compareQueueOrder)
+        .map((lane) => ({
+        ...lane,
+        overdue: isOverdue(hqRoot, lane.lane_id, now),
+    }));
+    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: isOverdue(hqRoot, lane.lane_id, ctx.now()),
+        ask_delivery_failed: askDeliveryFailed,
+    });
+}
+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);
+    const messageId = mintMessageId();
+    const at = ctx.now().toISOString();
+    const drop = path.join(runDir(hqRoot, laneId), "dropbox", "inbox.jsonl");
+    ensureDir(path.dirname(drop));
+    const projectId = opts.project?.trim() || lane.project_id;
+    const storyId = opts.story?.trim() || lane.story_id;
+    fs.appendFileSync(drop, `${JSON.stringify({ at, message_id: messageId, text, project_id: projectId, story_id: storyId })}\n`, "utf8");
+    let next = lane;
+    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,
+                }),
+            };
+        });
+    }
+    printJson({
+        ok: true,
+        action: "message",
+        lane_id: laneId,
+        message_id: messageId,
+        project_id: next.project_id,
+        story_id: next.story_id,
+        lane: next,
+    });
+}
+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,
+    });
+}
+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 });
+    }
+    if (!fs.existsSync(logsDir)) {
+        printJson({ ok: true, action: "logs", lane_id: laneId, lines: [] });
+        return;
+    }
+    const files = fs
+        .readdirSync(logsDir)
+        .filter((name) => !name.startsWith("."))
+        .sort();
+    const lines = [];
+    for (const name of files) {
+        const text = fs.readFileSync(path.join(logsDir, name), "utf8");
+        for (const line of text.split("\n")) {
+            if (line.length > 0)
+                lines.push(line);
+        }
+    }
+    const sliced = tail === undefined ? lines : lines.slice(-tail);
+    printJson({ ok: true, action: "logs", lane_id: laneId, lines: sliced });
+}
+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 nextState = lane.state === "queued" ? "cancelled" : "killed";
+    const at = ctx.now().toISOString();
+    const updated = casUpdateLane(hqRoot, laneId, (current) => {
+        if (isTerminalLaneState(current.state)) {
+            if (current.state === nextState)
+                return current;
+            throw new LanesError("already_terminal", `Lane ${laneId} is already ${current.state}`, { lane_id: laneId, state: current.state });
+        }
+        return {
+            ...current,
+            state: nextState,
+            queued_reason: undefined,
+        };
+    });
+    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();
+    const store = bodyStoreForLane(lane);
+    let questionId;
+    let lastErr;
+    const attempts = ASK_BACKOFF_MS.length + 1;
+    for (let i = 0; i < attempts; i += 1) {
+        try {
+            if (!questionId) {
+                const created = createQuestion(hqRoot, {
+                    lane_id: lane.lane_id,
+                    company: lane.company,
+                    project_id: lane.project_id,
+                    story_id: lane.story_id,
+                    thread_id: lane.thread_id,
+                    raised_via: "cli",
+                    asked_at: at,
+                    origin: { kind: "lane", id: lane.lane_id },
+                    hop: 1,
+                    status: "pending",
+                    body: { store, ref: "", digest: "" },
+                    routing_history: [],
+                });
+                questionId = created.question_id;
+            }
+            const stored = writeQuestionBody(hqRoot, {
+                company: lane.company,
+                question_id: questionId,
+                body: { store, ref: "", digest: "" },
+            }, body);
+            const withBody = casUpdateQuestion(hqRoot, questionId, (current) => {
+                const asked = current.routing_history.some((entry) => entry.reason === "asked");
+                return {
+                    ...current,
+                    body: stored,
+                    routing_history: asked
+                        ? current.routing_history
+                        : appendCappedHistory(current.routing_history, {
+                            hop: 1,
+                            audience: lane.senior,
+                            at,
+                            reason: "asked",
+                        }),
+                };
+            });
+            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;
+            if (i === attempts - 1)
+                break;
+            await ctx.sleep(ASK_BACKOFF_MS[i] ?? 400);
+        }
+    }
+    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 && q.company.uid !== company.uid && q.company.slug !== company.slug) {
+            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),
+    }));
+    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();
+    if (!opts.choice) {
+        throw new LanesError("missing_choice", "--choice is required", {});
+    }
+    const question = readQuestion(hqRoot, questionId);
+    throwIfQuestionNotPending(question);
+    await yieldEventLoop();
+    const body = requireQuestionBody(hqRoot, question);
+    const choice = resolveAnswerChoice(opts.choice, body.options, Boolean(opts.freeform));
+    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,
+                notes_ref: notesRef,
+                answered_by: answeredBy,
+                answered_at: at,
+                answered_level: current.hop,
+            },
+        };
+    });
+    printJson({ ok: true, action: "questions.answer", question: updated });
+}
+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];
+    const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config));
+    printJson({ ok: true, action: "accounts.list", accounts });
+}
+async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
+    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 home = canonicalizeHome(homeRaw, {
+        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 = config.providers[provider].accounts[defaultId]?.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);
+    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 rows = listSessionLiveness(hqRoot).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 state = sessionLiveness(hqRoot, sessionId);
+    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,
+    });
+}
+export function registerLanesCommand(parent, deps = {}) {
+    const ctx = resolveDeps(deps);
+    const lanes = parent
+        .command("lanes")
+        .description("Create, supervise, and steer worker lanes; routed decision queue");
+    lanes
+        .command("create")
+        .description("Register a lane, run admission, and return immediately")
+        .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
+        .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("--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")
+        .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")
+        .action(wrap(async (laneId, opts) => {
+        await runMessage(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")
+        .requiredOption("--choice <label|N>", "1-based index or option label")
+        .option("--notes <text>", "Free-text notes stored with the body")
+        .option("--freeform", "Allow a choice that is not on the menu")
+        .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);
+    }));
+}
+//# sourceMappingURL=lanes.js.map