@indigoai-us/hq-cli 5.154.0 → 5.156.0

package/CHANGELOG.md

@@ -2,6 +2,54 @@
 
 ## [Unreleased]
 
+## [5.156.0] — 2026-09-24
+
+### Fixed
+
+- Project-thread lookup treats an omitted server `kind` as the project thread,
+  preventing duplicate project threads when a newer lane thread is present.
+- Lane admission reservations are refreshed after Work Mesh lane-thread
+  registration so slow registration cannot age the reservation before spawn.
+
+### Added
+
+- `hq mesh project register --channel` and `project set --channel` can bind an
+  existing channel to project events. `hq mesh check --project` shows lane
+  identity and status, including terminal lane threads.
+- Lane mesh threads keep a stable lane id across resume and account moves.
+  Events include the worker profile, model, account, parent lane, and senior
+  owner. Stop and dead-host recovery events close terminal threads.
+
+### Tests
+
+- Cover server-shaped project-thread results and reservation timing after
+  lane-thread registration.
+
+## [5.155.0] — 2026-09-24
+
+### Fixed
+
+- Lane respawns keep their recorded account to preserve provider sessions and
+  prompt caches. Automatic moves now record why they happened and are limited
+  to model changes, usage limits, and unavailable or logged-out accounts.
+- Account retries share the provider admission lock and the host-scoped provider,
+  account, and profile checks used by normal admission. Active reservations and
+  earlier eligible queue entries keep their place; blocked retries remain queued
+  for normal admission. Retries skip accounts already rejected for login and
+  retain message, resume, and answer context when queued.
+- Watcher retries resolve the current process hostname and Outpost identity, so
+  local-kind and Outpost-kind lanes on one Outpost share admission caps.
+- Account enable and registration now require a positive login check. Provider
+  startup messages for logged-out accounts trigger failover to another eligible
+  account or a named `account_not_logged_in` failure.
+
+### Added
+
+- Provider config can list accounts in preference order for a lane's first
+  assignment. Disabled, logged-out, usage-limited, and capped accounts are
+  skipped. If no preferred account is eligible, hq-cli chooses the least-loaded
+  eligible account. Running and resumed lanes keep their recorded account.
+
 ## [5.154.0] — 2026-09-24
 
 ### Fixed

package/dist/command-catalog.generated.d.ts

@@ -5708,6 +5708,9 @@ export declare const COMMAND_CATALOG: readonly [{
             }, {
                 readonly flags: "--repo <path[@branch]>";
                 readonly description: "Repository binding (repeatable)";
+            }, {
+                readonly flags: "--channel <channelId>";
+                readonly description: "Bind the project to an existing company or project channel";
             }, {
                 readonly flags: "--create";
                 readonly description: "Create the Board view when the GET is a 404";
@@ -5754,7 +5757,7 @@ export declare const COMMAND_CATALOG: readonly [{
                 readonly description: "Company slug or cloud uid";
             }, {
                 readonly flags: "--channel <channelId>";
-                readonly description: "Reserved: the current server chooses the project channel";
+                readonly description: "Bind the project to an existing company or project channel";
             }, {
                 readonly flags: "--json";
                 readonly description: "Print machine-readable JSON";

package/dist/command-catalog.generated.js

@@ -7367,6 +7367,10 @@ export const COMMAND_CATALOG = [
                                 "flags": "--repo <path[@branch]>",
                                 "description": "Repository binding (repeatable)"
                             },
+                            {
+                                "flags": "--channel <channelId>",
+                                "description": "Bind the project to an existing company or project channel"
+                            },
                             {
                                 "flags": "--create",
                                 "description": "Create the Board view when the GET is a 404"
@@ -7427,7 +7431,7 @@ export const COMMAND_CATALOG = [
                             },
                             {
                                 "flags": "--channel <channelId>",
-                                "description": "Reserved: the current server chooses the project channel"
+                                "description": "Bind the project to an existing company or project channel"
                             },
                             {
                                 "flags": "--json",

package/dist/commands/lanes.d.ts

@@ -6,6 +6,9 @@
  * `watch` and the monitor reminder are the line-oriented text surfaces.
  */
 import { Command } from "commander";
+import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
+export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
+export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.js";
 import { MAX_LANE_DEPTH, type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
@@ -16,17 +19,7 @@ import { spawnLaneWorker, type KillProcessFn, type ProveDetachedFn, type SpawnPr
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
-export declare const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
-export declare const OUTPOST_DIR = "/etc/outpost";
 export declare const LANES_RUNS_REL: string;
-export type OutpostIdentity = {
-    kind: "id";
-    id: string;
-} | {
-    kind: "unknown";
-} | {
-    kind: "not_outpost";
-};
 export interface SpawnLoginResult {
     status: number;
 }
@@ -79,7 +72,6 @@ export interface LanesCommandDeps {
     locateTranscript?: (home: string, sessionId: string) => string | null;
     monitorEvidence?: MonitorEvidenceReader;
 }
-export declare function readOutpostIdentity(existsSync?: (p: string) => boolean, readFileSync?: (p: string) => string): OutpostIdentity;
 export declare function parseSeniorRef(raw: string): SeniorRef;
 export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
 /**

package/dist/commands/lanes.js

@@ -12,13 +12,15 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
+import { readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
+export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 import { buildOutpostLaneCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
-import { createLaneMesh, emitLaneDecisionEvents, } from "../lib/lanes/mesh-events.js";
+import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, isLoggedOut, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -33,8 +35,6 @@ import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ON
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
-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"] },
@@ -133,27 +133,6 @@ async function defaultFetchText(url) {
     }
     return res.text();
 }
-export function readOutpostIdentity(existsSync = (p) => fs.existsSync(p), readFileSync = (p) => fs.readFileSync(p, "utf8")) {
-    const hasMarker = existsSync(OUTPOST_ID_PATH);
-    const hasDir = existsSync(OUTPOST_DIR);
-    if (hasMarker) {
-        let text;
-        try {
-            text = readFileSync(OUTPOST_ID_PATH);
-        }
-        catch (err) {
-            process.stderr.write(`hq lanes: failed to read ${OUTPOST_ID_PATH}: ${err instanceof Error ? err.message : String(err)}\n`);
-            throw err;
-        }
-        const id = text.trim();
-        if (!id)
-            return hasDir ? { kind: "unknown" } : { kind: "not_outpost" };
-        return { kind: "id", id };
-    }
-    if (hasDir)
-        return { kind: "unknown" };
-    return { kind: "not_outpost" };
-}
 function defaultSpawnLogin(opts) {
     return new Promise((resolve, reject) => {
         const child = spawn(opts.command, opts.args, {
@@ -263,11 +242,10 @@ function livenessDepsFromCtx(ctx) {
     };
 }
 function reconcileHostFromCtx(ctx) {
-    const identity = ctx.readOutpostIdentity();
-    return {
-        hostname: ctx.hostname(),
-        outpostId: identity.kind === "id" ? identity.id : null,
-    };
+    return resolveAdmissionHost({
+        hostname: ctx.hostname,
+        readOutpostIdentity: ctx.readOutpostIdentity,
+    });
 }
 export function parseSeniorRef(raw) {
     const trimmed = raw.trim();
@@ -1172,18 +1150,45 @@ function askDeliveryFailedPath(hqRoot, laneId) {
     return path.join(runDir(hqRoot, laneId), "ask_delivery_failed.json");
 }
 async function emitLaneMeshEvent(ctx, company, threadId, event, payload) {
-    if (!threadId || !company)
+    if (!company)
         return;
-    await ctx.mesh.appendThreadEvent(company, threadId, event, payload);
+    let targetThreadId = threadId;
+    let eventPayload = payload;
+    const laneId = typeof payload.lane_id === "string" ? payload.lane_id.trim() : "";
+    if (laneId && ctx.mesh.ensureLaneThread) {
+        const lane = readLane(ctx.hqRoot(), laneId);
+        const ready = await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running");
+        targetThreadId = ready.thread_id;
+        eventPayload = { ...laneMeshEventIdentity(ready), ...payload };
+    }
+    if (!targetThreadId)
+        return;
+    await ctx.mesh.appendThreadEvent(company, targetThreadId, event, eventPayload);
+}
+async function emitLaneTerminalStateSoft(ctx, lane) {
+    if (lane.state !== "failed" && lane.state !== "interrupted" &&
+        lane.state !== "cancelled" && lane.state !== "killed")
+        return;
+    try {
+        await emitLaneTerminalStateEvent(ctx.mesh, lane, lane.state, lane.terminal_reason, AbortSignal.timeout(10_000));
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: terminal mesh update failed for ${lane.lane_id}: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
 }
 async function emitLaneStartedForStories(ctx, company, lane, threadId) {
-    if (!threadId)
+    const ready = ctx.mesh.ensureLaneThread
+        ? await ensureLaneThreadRecord(ctx, lane, lane.project_id, lane.story_id, "running")
+        : lane;
+    const stableThreadId = ready.thread_id ?? threadId;
+    if (!stableThreadId)
         return;
     const failures = [];
-    for (const story of laneStories(lane)) {
+    for (const story of laneStories(ready)) {
         try {
-            await emitLaneMeshEvent(ctx, company, threadId, "lane_started", {
-                lane_id: lane.lane_id,
+            await emitLaneMeshEvent(ctx, company, stableThreadId, "lane_started", {
+                ...laneMeshEventIdentity(ready),
+                lane_id: ready.lane_id,
                 project_id: story.project_id,
                 story_id: story.story_id,
             });
@@ -1261,9 +1266,17 @@ export function applyOutpostAccountPickup(hqRoot, laneId, modelDeps = {}) {
     try {
         const resolved = resolveAccount(lane.provider, lane.account, config, {
             hqRoot,
+            accountDeps: {
+                probe: modelDeps.probe,
+                env: modelDeps.env,
+            },
+        });
+        const status = accountStatus(lane.provider, resolved.id, config, {
+            existsSync: (p) => fs.existsSync(p),
+            probe: modelDeps.probe,
+            env: modelDeps.env,
         });
-        const status = accountStatus(lane.provider, resolved.id, config);
-        if (isLoggedOut(status)) {
+        if (status.logged_in !== true) {
             return markPickupFailure(hqRoot, laneId, "account_not_logged_in", {
                 provider: lane.provider,
                 account: resolved.id,
@@ -1549,8 +1562,10 @@ async function runCreate(ctx, opts) {
             resolveAccount(provider, undefined, config, {
                 hqRoot,
                 existsSync: ctx.existsSync,
+                accountDeps: { probe: ctx.probeProvider, env: ctx.env },
                 cliModel,
                 model: modelToValidate,
+                preferredAccounts: config.providers[provider].preferred_accounts ?? [],
                 ...(profileAccounts !== undefined
                     ? { allowedAccounts: profileAccounts }
                     : {}),
@@ -1563,7 +1578,11 @@ async function runCreate(ctx, opts) {
                     .filter((id) => id !== candidate &&
                     accounts[id]?.enabled &&
                     (profileAccounts === undefined || profileAccounts.includes(id)) &&
-                    accountStatus(provider, id, config, { existsSync: ctx.existsSync }).logged_in === true)
+                    accountStatus(provider, id, config, {
+                        existsSync: ctx.existsSync,
+                        probe: ctx.probeProvider,
+                        env: ctx.env,
+                    }).logged_in === true)
                     .sort(),
             ];
         const checkedAccounts = [];
@@ -1638,9 +1657,8 @@ async function runCreate(ctx, opts) {
                     (profileAccounts === undefined || profileAccounts.includes(id)))
                     .map(([id]) => id))]
         : undefined;
-    const threadId = meshCompany
-        ? await ctx.mesh.ensureProjectThread(meshCompany, project)
-        : undefined;
+    // The lane id is created in `persist`; its Work Mesh thread is ensured
+    // immediately afterward from that stable identity.
     const persist = async () => {
         let admission;
         let validation;
@@ -1648,8 +1666,10 @@ async function runCreate(ctx, opts) {
             pinnedAccount = resolveAccount(provider, undefined, config, {
                 hqRoot,
                 existsSync: ctx.existsSync,
+                accountDeps: { probe: ctx.probeProvider, env: ctx.env },
                 cliModel,
                 model: cliModel ?? profileModel,
+                preferredAccounts: config.providers[provider].preferred_accounts ?? [],
                 ...(allowedAccounts !== undefined ? { allowedAccounts } : {}),
             }).id;
         }
@@ -1718,7 +1738,6 @@ async function runCreate(ctx, opts) {
                 added_at: createdAt,
                 updated_at: createdAt,
             })),
-            thread_id: threadId,
             depth: laneDepth,
             senior,
             senior_history: [],
@@ -1771,7 +1790,35 @@ async function runCreate(ctx, opts) {
     else {
         persisted = await withLaneAdmissionLock(hqRoot, provider, persist, ctx.sleep);
     }
-    const { lane, admission, validation } = persisted;
+    let lane = persisted.lane;
+    const { admission, validation } = persisted;
+    if (meshCompany) {
+        try {
+            lane = await ensureLaneThreadRecord(ctx, lane);
+        }
+        catch {
+            try {
+                lane = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+                    ...current,
+                    state: "failed",
+                    queued_reason: undefined,
+                    terminal_reason: "mesh_thread_registration_failed",
+                }));
+            }
+            catch {
+                throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed for ${lane.lane_id}, and its local record could not be marked terminal.`, { lane_id: lane.lane_id });
+            }
+            throw new LanesError("mesh_thread_registration_failed", `Work Mesh lane registration failed; lane ${lane.lane_id} was marked failed.`, { lane_id: lane.lane_id, state: lane.state });
+        }
+    }
+    // Thread registration runs after persistence; anchor the reservation after
+    // its network work so a slow response cannot age the slot before spawn.
+    if (meshCompany && admission.action === "start" && lane.admission_reserved_at) {
+        lane = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+            ...current,
+            admission_reserved_at: ctx.now().toISOString(),
+        }));
+    }
     const dest = runDir(hqRoot, lane.lane_id);
     ensureDir(path.join(dest, "logs"));
     ensureDir(path.join(dest, "envelopes"));
@@ -1797,6 +1844,7 @@ async function runCreate(ctx, opts) {
                 probe: ctx.probeProvider,
                 env: ctx.env,
             },
+            currentModelValidated: !outpostId && modelToValidate !== undefined,
             existsSync: ctx.existsSync,
             spawnProcess: ctx.spawnProcess,
             proveDetached: ctx.proveDetached,
@@ -1807,7 +1855,7 @@ async function runCreate(ctx, opts) {
             locateTranscript: ctx.locateTranscript,
         });
         if (meshCompany)
-            await emitLaneStartedForStories(ctx, meshCompany, started, threadId);
+            await emitLaneStartedForStories(ctx, meshCompany, started, started.thread_id);
     }
     else if (outpostId) {
         started = await dispatchCreatedOutpostLane(ctx, {
@@ -1869,13 +1917,15 @@ async function dispatchCreatedOutpostLane(ctx, input) {
         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) => ({
+            const cancelled = casUpdateLane(hqRoot, lane.lane_id, (current) => ({
                 ...current,
                 state: "cancelled",
                 queued_reason: undefined,
                 terminal_reason: "outpost_self_target",
                 outpost_command_id: dispatched.commandId,
             }));
+            await emitLaneTerminalStateSoft(ctx, cancelled);
+            return cancelled;
         }
         const stdoutTrimmed = dispatched.stdout.trim();
         if (remote === null && stdoutTrimmed !== "" && dispatched.status !== "Success") {
@@ -1887,6 +1937,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 stderr: dispatched.stderr.slice(0, 2000),
                 parse_error: "unparseable_pickup_stdout",
             });
+            await emitLaneTerminalStateSoft(ctx, failed);
             throw new LanesError(DISPATCH_TERMINAL_REASON, "Outpost pickup command failed", {
                 outpost_id: outpostId,
                 lane_id: failed.lane_id,
@@ -1904,6 +1955,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
                 status: dispatched.status,
                 stderr: dispatched.stderr.slice(0, 2000),
             });
+            await emitLaneTerminalStateSoft(ctx, failed);
             throw new LanesError(DISPATCH_TERMINAL_REASON, "Outpost pickup command failed", {
                 outpost_id: outpostId,
                 lane_id: failed.lane_id,
@@ -1928,6 +1980,7 @@ async function dispatchCreatedOutpostLane(ctx, input) {
             outpost_id: outpostId,
             message,
         });
+        await emitLaneTerminalStateSoft(ctx, failed);
         throw new LanesError(DISPATCH_TERMINAL_REASON, `Failed to dispatch lane to Outpost ${outpostId}: ${message}`, {
             outpost_id: outpostId,
             lane_id: failed.lane_id,
@@ -2131,6 +2184,7 @@ async function runPickup(ctx, opts) {
         env: ctx.env,
     });
     if (isTerminalLaneState(afterAccount.state)) {
+        await emitLaneTerminalStateSoft(ctx, afterAccount);
         printJson({
             ok: true,
             action: "pickup",
@@ -2196,6 +2250,7 @@ async function runPickup(ctx, opts) {
                     probe: ctx.probeProvider,
                     env: ctx.env,
                 },
+                currentModelValidated: afterAccount.model !== undefined,
                 existsSync: ctx.existsSync,
                 spawnProcess: ctx.spawnProcess,
                 proveDetached: ctx.proveDetached,
@@ -2512,7 +2567,11 @@ async function prepareAccountMove(ctx, lane, input) {
     if (!targetCfg.enabled) {
         throw new AccountResolutionError("account_disabled", `Account ${JSON.stringify(target)} is disabled${targetCfg.disabled_reason ? `: ${targetCfg.disabled_reason}` : ""}`, { provider: lane.provider, account: target, reason: targetCfg.disabled_reason ?? "" });
     }
-    if (isLoggedOut(accountStatus(lane.provider, target, config, { existsSync: ctx.existsSync }))) {
+    if (accountStatus(lane.provider, target, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    }).logged_in !== true) {
         throw new LanesError("account_not_logged_in", `Account ${target} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: target, lane_id: laneId });
     }
     const profile = lane.worker_profile !== undefined
@@ -3150,17 +3209,32 @@ function callerMayVerifyStory(ctx, lane) {
         return false;
     return sessionIdFromEnv(ctx.env) === lane.senior.id;
 }
-async function ensureStoryThread(ctx, lane, projectId) {
+async function ensureStoryThread(ctx, lane, projectId, storyId = lane.story_id) {
+    const company = lane.mesh_company ?? lane.company;
+    if (!company)
+        return lane;
+    return ensureLaneThreadRecord(ctx, lane, projectId, storyId);
+}
+async function ensureLaneThreadRecord(ctx, lane, projectId = lane.project_id, storyId = lane.story_id, laneStatus = lane.state) {
     const company = lane.mesh_company ?? lane.company;
     if (!company)
         return lane;
-    const threadId = await ctx.mesh.ensureProjectThread(company, projectId);
-    if (threadId === lane.thread_id)
+    const descriptorLane = { ...lane, project_id: projectId, story_id: storyId };
+    const threadId = ctx.mesh.ensureLaneThread
+        ? await ctx.mesh.ensureLaneThread(company, descriptorLane, laneStatus)
+        : await ctx.mesh.ensureProjectThread(company, projectId);
+    if (threadId === lane.thread_id && !lane.thread_id.startsWith("proj-"))
         return lane;
-    return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+    const updated = casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
         ...current,
         thread_id: threadId,
     }));
+    // The CAS changes the lane version. Refresh once so the server descriptor
+    // and the durable local record converge before the worker starts.
+    if (ctx.mesh.ensureLaneThread) {
+        await ctx.mesh.ensureLaneThread(company, { ...updated, project_id: projectId, story_id: storyId }, laneStatus);
+    }
+    return updated;
 }
 async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}) {
     const company = lane.mesh_company ?? lane.company;
@@ -3174,6 +3248,7 @@ async function emitStoryTransition(ctx, lane, projectId, storyId, event, status,
         project_id: projectId,
         story_id: storyId,
         ...payload,
+        lane_status: lane.state,
     });
     await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
 }
@@ -3514,6 +3589,7 @@ async function runStop(ctx, laneId) {
             sleepMs: ctx.stopSleepMs,
         });
     }
+    await emitLaneTerminalStateSoft(ctx, updated);
     const cancelled = cancelPendingQuestionsForLane(hqRoot, laneId, at);
     printJson({
         ok: true,
@@ -3829,7 +3905,11 @@ async function runAccountsList(ctx, opts) {
     // 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 accounts = providers.flatMap((provider) => listAccountStatuses(provider, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    }).map((status) => {
         const accountCfg = config.providers[provider].accounts[status.id];
         const model = resolveLaneModel({
             accountModel: accountCfg?.model,
@@ -3930,8 +4010,17 @@ async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         home,
         enabled: true,
     };
+    const status = accountStatus(provider, id, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    });
+    if (status.logged_in !== true) {
+        throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
+            ? `Account ${id} for ${provider} is not logged in`
+            : `Could not verify that account ${id} for ${provider} is logged in`, { provider, account: id, home });
+    }
     writeLanesConfig(hqRoot, config);
-    const status = accountStatus(provider, id, loadLanesConfig(hqRoot));
     printJson({ ok: true, action: "accounts.login", account: status });
 }
 async function runAccountsEnable(ctx, providerRaw, accountId) {
@@ -3948,13 +4037,27 @@ async function runAccountsEnable(ctx, providerRaw, accountId) {
                 .map(([id]) => id),
         });
     }
+    const status = accountStatus(provider, accountId, config, {
+        existsSync: ctx.existsSync,
+        probe: ctx.probeProvider,
+        env: ctx.env,
+    });
+    if (status.logged_in !== true) {
+        throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
+            ? `Account ${accountId} for ${provider} is not logged in`
+            : `Could not verify that account ${accountId} for ${provider} is logged in`, { provider, account: accountId });
+    }
     account.enabled = true;
     delete account.disabled_reason;
     writeLanesConfig(hqRoot, config);
     printJson({
         ok: true,
         action: "accounts.enable",
-        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot)),
+        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
+            existsSync: ctx.existsSync,
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }),
     });
 }
 async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
@@ -3978,7 +4081,11 @@ async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
     printJson({
         ok: true,
         action: "accounts.disable",
-        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot)),
+        account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
+            existsSync: ctx.existsSync,
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }),
     });
 }
 async function runSessionsList(ctx, opts) {