@indigoai-us/hq-cli 5.126.0 → 5.127.0

package/dist/commands/lanes.js

@@ -4,21 +4,29 @@
  * 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 { 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 { OutpostsClient } from "@indigoai-us/hq-cloud/outposts";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
-import { findHqRoot } from "../utils/manifest.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 { appendThreadEvent, ensureProjectThread, patchStoryStatus, } from "../lib/mesh/api.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_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 { 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";
@@ -28,14 +36,7 @@ const VENDOR_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 });
-}
+export { emitLaneDecisionEvents };
 function printJson(value) {
     console.log(JSON.stringify(value, null, 2));
 }
@@ -66,14 +67,36 @@ async function defaultResolveCompany(company) {
     const { company: mesh } = await openMeshTransport({ company });
     return { slug: mesh.companySlug, uid: mesh.companyUid };
 }
-async function defaultListOutpostIds() {
-    const client = new OutpostsClient({
+function defaultOutpostsClient() {
+    return createOutpostsClient({
         transport: vaultApiFetch,
         token: () => ensureCognitoToken({ interactive: false }),
     });
-    const rows = await client.list();
+}
+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);
@@ -110,35 +133,42 @@ function defaultSpawnLogin(opts) {
         });
     });
 }
-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);
-        },
-    };
+    // 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 {
-        hqRoot: deps.hqRoot ?? (() => findHqRoot()),
+        cwd,
+        callerCwd,
+        hqRoot,
         env,
         now: deps.now ?? (() => new Date()),
         hostname: deps.hostname ?? (() => os.hostname()),
@@ -152,6 +182,48 @@ function resolveDeps(deps = {}) {
         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) {
@@ -220,9 +292,6 @@ function parseOptionalInt(raw, flag) {
 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 });
 }
@@ -241,30 +310,6 @@ function readJsonFile(filePath) {
         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;
@@ -333,18 +378,6 @@ function requireQuestionBody(hqRoot, question) {
     }
     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));
 }
@@ -354,15 +387,36 @@ function loadAllQuestions(hqRoot) {
 function sessionMetaPath(hqRoot, sessionId) {
     return path.join(hqRoot, "workspace", "sessions", sessionId, "meta.yaml");
 }
-function readSessionMeta(hqRoot, sessionId, ctx) {
+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;
-    const text = ctx.readFileSync(filePath, "utf8");
-    const doc = parseUserYaml(text, filePath);
-    if (doc === null || typeof doc !== "object" || Array.isArray(doc))
-        return null;
-    return doc;
+    return loaded.doc;
 }
 function seniorOfSession(hqRoot, sessionId, ctx) {
     const meta = readSessionMeta(hqRoot, sessionId, ctx);
@@ -468,28 +522,63 @@ function defaultSenior(ctx) {
 }
 function companyOfSenior(hqRoot, ref, ctx) {
     if (ref.kind === "user")
-        return null;
+        return { binding: "unknown" };
     if (ref.kind === "lane") {
         if (!ref.id)
-            return null;
+            return { binding: "unknown" };
         const lane = readLane(hqRoot, ref.id);
-        return lane.company;
+        if (!lane.company)
+            return { binding: "none" };
+        return {
+            binding: "company",
+            slug: lane.company.slug,
+            uid: lane.company.uid,
+        };
     }
     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;
+        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;
-    return { slug, uid };
+    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;
-    if (!seniorCompany || (!seniorCompany.slug && !seniorCompany.uid))
+    // 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;
@@ -500,15 +589,20 @@ function sameTenant(laneCompany, senior, seniorCompany) {
 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", {
+    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: seniorCompany,
+        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;
@@ -599,7 +693,7 @@ function compareQueueOrder(a, b) {
 function admitCreate(input) {
     const { hqRoot, provider, pinnedAccount, priority, createdAt, config } = input;
     const providerCfg = config.providers[provider];
-    const lanes = loadAllLanes(hqRoot);
+    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")
@@ -686,16 +780,10 @@ async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccou
     }
     return { action: "queue", reason: "throttle" };
 }
-function assertKnownOutpost(requested, known, identity) {
+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 });
     }
-    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");
@@ -709,7 +797,14 @@ function railsPresent(home) {
 }
 const ADMISSION_LOCK_STALE_MS = 30_000;
 const ADMISSION_LOCK_TIMEOUT_MS = 5_000;
-const ASK_BACKOFF_MS = [50, 100, 200, 400];
+/**
+ * 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);
@@ -815,7 +910,7 @@ export function casUpdateQuestion(hqRoot, questionId, updater) {
 export function casUpdateLane(hqRoot, laneId, updater) {
     return withCasRetry(() => {
         const current = readLane(hqRoot, laneId);
-        return updateLane(hqRoot, laneId, current.version, updater);
+        return updateLane(hqRoot, laneId, current.version, "command", updater);
     });
 }
 function throwIfQuestionNotPending(current) {
@@ -836,6 +931,29 @@ function formatUnknownValue(value) {
     }
     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;
@@ -864,10 +982,31 @@ export function composeWorkerBrief(worker, taskBrief) {
         "",
         "## 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) {
@@ -899,36 +1038,37 @@ export function parseMaxRuntimeSeconds(raw, workerId) {
 function askDeliveryFailedPath(hqRoot, laneId) {
     return path.join(runDir(hqRoot, laneId), "ask_delivery_failed.json");
 }
-async function emitLaneMeshEvent(ctx, company, threadId, eventKind, payload) {
-    if (!threadId)
+async function emitLaneMeshEvent(ctx, company, threadId, event, payload) {
+    if (!threadId || !company)
         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");
-    }
+    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) => {
@@ -954,9 +1094,11 @@ export function applyOutpostAccountPickup(hqRoot, laneId) {
     const lane = readLane(hqRoot, laneId);
     const config = loadLanesConfig(hqRoot);
     try {
-        const resolved = resolveAccount(lane.provider, lane.account, config);
+        const resolved = resolveAccount(lane.provider, lane.account, config, {
+            hqRoot,
+        });
         const status = accountStatus(lane.provider, resolved.id, config);
-        if (!status.logged_in) {
+        if (isLoggedOut(status)) {
             return markPickupFailure(hqRoot, laneId, "account_not_logged_in", {
                 provider: lane.provider,
                 account: resolved.id,
@@ -964,7 +1106,11 @@ export function applyOutpostAccountPickup(hqRoot, laneId) {
         }
         if (lane.account === resolved.id)
             return lane;
-        return casUpdateLane(hqRoot, laneId, (current) => {
+        // 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 };
@@ -1020,9 +1166,6 @@ async function runCreate(ctx, opts) {
     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", {});
     }
@@ -1044,7 +1187,7 @@ async function runCreate(ctx, opts) {
         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());
+        assertKnownOutpost(requested, known);
     }
     const depth = callerDepth(hqRoot, ctx);
     if (depth >= MAX_LANE_DEPTH) {
@@ -1056,14 +1199,17 @@ async function runCreate(ctx, opts) {
     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);
+    // 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);
+        resolvedWorker = resolveLaneWorker(hqRoot, opts.worker, company?.slug);
     }
-    const briefAbs = path.resolve(briefFile);
+    const briefAbs = resolveCallerPath(ctx.callerCwd(), briefFile);
     if (!ctx.existsSync(briefAbs)) {
         throw new LanesError("brief_not_found", `Brief file not found: ${briefAbs}`, {
             path: briefAbs,
@@ -1071,9 +1217,23 @@ async function runCreate(ctx, opts) {
     }
     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 (opts.account !== undefined && opts.account.trim() !== "") {
+        if (accountWasExplicit) {
             pinnedAccount = opts.account.trim();
         }
     }
@@ -1082,14 +1242,12 @@ async function runCreate(ctx, opts) {
         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);
+        const resolved = resolveAccount(provider, requested, config, {
+            hqRoot,
+            cliModel,
+        });
         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) {
@@ -1097,10 +1255,35 @@ async function runCreate(ctx, opts) {
     }
     const now = ctx.now();
     const createdAt = now.toISOString();
-    const threadId = await ctx.mesh.ensureProjectThread(company, project);
+    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";
@@ -1138,9 +1321,18 @@ async function runCreate(ctx, opts) {
             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 };
@@ -1150,7 +1342,7 @@ async function runCreate(ctx, opts) {
         persisted = await persist();
     }
     else {
-        persisted = await withAdmissionLock(admissionLockPath(hqRoot, provider, pinnedAccount), persist, ctx.sleep);
+        persisted = await withAdmissionLock(admissionLockPath(hqRoot, provider, accountWasExplicit ? pinnedAccount : undefined), persist, ctx.sleep);
     }
     const { lane, admission, validation } = persisted;
     const dest = runDir(hqRoot, lane.lane_id);
@@ -1161,7 +1353,7 @@ async function runCreate(ctx, opts) {
     const taskBrief = fs.readFileSync(briefAbs, "utf8");
     const briefText = resolvedWorker
         ? composeWorkerBrief(resolvedWorker, taskBrief)
-        : taskBrief;
+        : composeGeneralBrief(taskBrief);
     fs.writeFileSync(path.join(dest, "brief.md"), briefText);
     if (timeoutSecs !== undefined) {
         writeJsonFile(timeoutPath(hqRoot, lane.lane_id), {
@@ -1169,40 +1361,323 @@ async function runCreate(ctx, opts) {
             deadline_at: new Date(now.getTime() + timeoutSecs * 1000).toISOString(),
         });
     }
+    let started = lane;
     if (admission.action === "start") {
-        await emitLaneMeshEvent(ctx, company, threadId, "lane_started", {
-            lane_id: lane.lane_id,
-            project_id: project,
-            story_id: story,
+        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,
         });
-        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,
+        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) {
@@ -1222,7 +1697,7 @@ async function runList(ctx, opts) {
             return false;
         if (opts.story && lane.story_id !== opts.story)
             return false;
-        if (company && lane.company.uid !== company.uid && lane.company.slug !== company.slug) {
+        if (company && !recordMatchesCompany(lane.company, company)) {
             return false;
         }
         if (senior && seniorKey(lane.senior) !== seniorKey(senior))
@@ -1232,7 +1707,19 @@ async function runList(ctx, opts) {
         .sort(compareQueueOrder)
         .map((lane) => ({
         ...lane,
-        overdue: isOverdue(hqRoot, lane.lane_id, now),
+        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 });
 }
@@ -1244,8 +1731,24 @@ async function runShow(ctx, laneId) {
         ok: true,
         action: "show",
         lane,
-        overdue: isOverdue(hqRoot, lane.lane_id, ctx.now()),
+        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) {
@@ -1255,14 +1758,64 @@ async function runMessage(ctx, laneId, opts) {
         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 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;
+    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);
@@ -1281,16 +1834,171 @@ async function runMessage(ctx, laneId, opts) {
             };
         });
     }
+    // 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) {
@@ -1368,6 +2076,12 @@ async function runReparent(ctx, laneId, opts) {
         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);
@@ -1376,24 +2090,37 @@ async function runLogs(ctx, laneId, opts) {
     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 names = new Set(CANONICAL_LOG_STREAMS);
+    if (fs.existsSync(logsDir)) {
+        for (const name of fs.readdirSync(logsDir)) {
+            if (!name.startsWith("."))
+                names.add(name);
         }
     }
-    const sliced = tail === undefined ? lines : lines.slice(-tail);
-    printJson({ ok: true, action: "logs", lane_id: laneId, lines: sliced });
+    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();
@@ -1401,20 +2128,24 @@ async function runStop(ctx, 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,
+            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,
@@ -1447,49 +2178,20 @@ async function runAsk(ctx, opts) {
     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;
+    const attempts = ASK_ATTEMPTS;
     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",
-                        }),
-                };
+            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,
@@ -1513,9 +2215,10 @@ async function runAsk(ctx, opts) {
         }
         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] ?? 400);
+            await ctx.sleep(ASK_BACKOFF_MS[i] ?? ASK_BACKOFF_MS[ASK_BACKOFF_MS.length - 1]);
         }
     }
     const failure = {
@@ -1556,7 +2259,7 @@ async function runQuestionsList(ctx, opts) {
             return false;
         if (opts.story && q.story_id !== opts.story)
             return false;
-        if (company && q.company.uid !== company.uid && q.company.slug !== company.slug) {
+        if (company && !recordMatchesCompany(q.company, company)) {
             return false;
         }
         if (forFilter) {
@@ -1569,6 +2272,7 @@ async function runQuestionsList(ctx, opts) {
         .map((q) => ({
         ...q,
         audience: resolveAudience(hqRoot, q, ctx),
+        ...(q.question_kind === "continue" ? { flag: "continue-loop" } : {}),
     }));
     printJson({ ok: true, action: "questions.list", questions });
 }
@@ -1586,14 +2290,20 @@ async function runQuestionsShow(ctx, questionId) {
 }
 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));
+    // 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)}`
@@ -1616,6 +2326,7 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
             status: "answered",
             answer: {
                 choice,
+                answer_kind: freeform ? "freeform" : "option",
                 notes_ref: notesRef,
                 answered_by: answeredBy,
                 answered_at: at,
@@ -1623,7 +2334,49 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
             },
         };
     });
-    printJson({ ok: true, action: "questions.answer", question: updated });
+    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();
@@ -1705,10 +2458,45 @@ async function runAccountsList(ctx, opts) {
     const providers = opts.provider
         ? [parseLaneProvider(opts.provider)]
         : [...LANE_PROVIDERS];
-    const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config));
-    printJson({ ok: true, action: "accounts.list", accounts });
+    // 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);
@@ -1720,7 +2508,10 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         (id === "a"
             ? DEFAULT_ACCOUNT_HOMES[provider]
             : `~/.${provider}-${id}`);
-    const home = canonicalizeHome(homeRaw, {
+    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),
@@ -1734,13 +2525,18 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
     }
     ensureDir(home);
     const defaultId = config.providers[provider].default_account;
-    const defaultHome = config.providers[provider].accounts[defaultId]?.home ??
+    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({
@@ -1814,7 +2610,13 @@ async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
 async function runSessionsList(ctx, opts) {
     const hqRoot = ctx.hqRoot();
     const state = opts.state ? parseLivenessState(opts.state) : undefined;
-    const rows = listSessionLiveness(hqRoot).filter((row) => {
+    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)
@@ -1828,7 +2630,13 @@ async function runSessionsList(ctx, opts) {
 }
 async function runSessionsShow(ctx, sessionId) {
     const hqRoot = ctx.hqRoot();
-    const state = sessionLiveness(hqRoot, sessionId);
+    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 });
     }
@@ -1842,21 +2650,104 @@ async function runSessionsShow(ctx, sessionId) {
         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")
+        .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")
-        .requiredOption("--company <slug|uid>", "Company slug or cloud uid")
+        .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")
@@ -1872,6 +2763,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--story <id>", "Filter by story")
         .option("--state <state>", `Filter by state (${LANE_STATES.join("|")})`)
         .option("--senior <ref>", "Filter by senior ref")
+        .option("--json", "JSON on stdout (always)")
         .action(wrap(async (opts) => {
         await runList(ctx, opts);
     }));
@@ -1889,9 +2781,21 @@ export function registerLanesCommand(parent, deps = {}) {
         .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")
@@ -1952,9 +2856,9 @@ export function registerLanesCommand(parent, deps = {}) {
         .command("answer")
         .description("Answer a pending question")
         .argument("<question-id>", "Question id")
-        .requiredOption("--choice <label|N>", "1-based index or option label")
+        .option("--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")
+        .option("--freeform <text>", "Supply a free-form answer for a question with options")
         .action(wrap(async (questionId, opts) => {
         await runQuestionsAnswer(ctx, questionId, opts);
     }));
@@ -2028,5 +2932,38 @@ export function registerLanesCommand(parent, deps = {}) {
         .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