@indigoai-us/hq-cli 5.148.0 → 5.150.0

package/dist/commands/lanes.js

@@ -12,22 +12,24 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { ensureCognitoToken } from "../utils/cognito-session.js";
 import { resolveLanesHqRoot } from "../lib/lanes/hq-root.js";
-import { buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { 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 { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, coveredLaneIds, 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, 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, hasRecordedSessionId, providerSupportsSessionResume, 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, 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 { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.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, quotaBlockFor } from "../lib/lanes/quota.js";
-import { SESSION_MOVE_REASON, copySessionFiles, planSessionCopy } from "../lib/lanes/move-account.js";
+import { SESSION_MOVE_REASON } from "../lib/lanes/move-account.js";
+import { ensureSessionHome } from "../lib/lanes/session-relink.js";
 import { defaultProbe, validateProfileLaneModel, validateLaneModel, } from "../lib/lanes/models.js";
-import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, stopLaneProcesses, } from "../lib/lanes/spawn.js";
+import { parseCliModel, refuseOutpostSelfTarget, resolveLaneModel, FOREGROUND_ONLY_RULE, STANDING_AUTHORIZATION, spawnLaneWorker, laneRunDir, readSpawnManifest, stopLaneProcesses, } from "../lib/lanes/spawn.js";
 export { spawnLaneWorker };
 export { questionBodyAbsPath };
 export { MAX_LANE_DEPTH };
@@ -40,8 +42,21 @@ const VENDOR_LOGIN = {
     grok: { command: "grok", args: ["login"] },
 };
 export { emitLaneDecisionEvents };
+function withoutProviderHome(value) {
+    if (Array.isArray(value))
+        return value.map(withoutProviderHome);
+    if (value === null || typeof value !== "object")
+        return value;
+    const safe = {};
+    for (const [key, nested] of Object.entries(value)) {
+        if (key === "provider_home_at_spawn")
+            continue;
+        safe[key] = withoutProviderHome(nested);
+    }
+    return safe;
+}
 function printJson(value) {
-    console.log(JSON.stringify(value, null, 2));
+    console.log(JSON.stringify(withoutProviderHome(value), null, 2));
 }
 function failJson(err) {
     if (isLanesError(err)) {
@@ -825,36 +840,25 @@ function isOverdue(hqRoot, laneId, now) {
         return false;
     return now.getTime() > at;
 }
-function compareQueueOrder(a, b) {
-    if (b.priority !== a.priority)
-        return b.priority - a.priority;
-    return a.created_at.localeCompare(b.created_at);
-}
 function admitCreate(input) {
-    const { hqRoot, provider, pinnedAccount, profileId, profileMaxConcurrent, priority, createdAt, config, } = input;
+    const { hqRoot, provider, pinnedAccount, profileId, profileMaxConcurrent, host, priority, createdAt, nowMs, config, } = input;
     const providerCfg = config.providers[provider];
     const lanes = loadAllLanes(hqRoot).filter((lane) => lane.lane_id !== input.excludeLaneId);
-    const runningProvider = lanes.filter((lane) => lane.provider === provider && lane.state === "running");
-    const queuedSame = lanes.filter((lane) => {
-        if (lane.provider !== provider || lane.state !== "queued")
-            return false;
-        if (pinnedAccount)
-            return lane.account === pinnedAccount;
-        return !lane.account;
-    });
+    const localLanes = lanes.filter((lane) => laneRunsHere(lane, host));
+    const runningProvider = lanes.filter((lane) => lane.provider === provider &&
+        (lane.state === "running" ||
+            hasActiveAdmissionReservation(lane, nowMs) ||
+            hasActivePendingResume(lane, nowMs)) &&
+        laneRunsHere(lane, host));
+    const queuedProvider = localLanes.filter((lane) => lane.provider === provider &&
+        lane.state === "queued" &&
+        !hasActiveAdmissionReservation(lane, nowMs));
     const runningCount = pinnedAccount
         ? runningProvider.filter((lane) => lane.account === pinnedAccount).length
         : runningProvider.length;
     const providerRunning = runningProvider.length;
-    const queuedCount = queuedSame.length;
+    const queuedCount = queuedProvider.length;
     const maxQueued = providerCfg.max_queued;
-    const profileRunning = profileId === undefined
-        ? 0
-        : lanes.filter((lane) => lane.worker_profile === profileId && lane.state === "running").length;
-    const atCap = providerRunning >= providerCfg.max_running ||
-        (pinnedAccount !== undefined &&
-            runningCount >= accountMaxRunning(providerCfg, pinnedAccount)) ||
-        (profileMaxConcurrent !== undefined && profileRunning >= profileMaxConcurrent);
     const synthetic = {
         schema_version: "hq-lane.v1",
         lane_id: "__incoming__",
@@ -868,19 +872,24 @@ function admitCreate(input) {
         priority,
         provider,
         account: pinnedAccount,
-        host: { kind: "local", id: "local" },
+        host: host.outpostId
+            ? { kind: "outpost", id: host.outpostId }
+            : { kind: "local", id: host.hostname },
+        ...(profileId !== undefined ? { worker_profile: profileId } : {}),
         version: 0,
         created_at: createdAt,
         updated_at: createdAt,
         attribution_history: [],
     };
-    const ranked = [...queuedSame, synthetic].sort(compareQueueOrder);
-    const first = ranked[0];
-    const isHead = first?.lane_id === "__incoming__";
-    const wouldStart = !atCap && isHead;
-    if (wouldStart)
+    const capReason = laneAdmissionCapReason(localLanes, synthetic, config, host, profileMaxConcurrent, nowMs);
+    const earlierEligible = !capReason && hasEarlierEligibleQueuedLane(localLanes, synthetic, config, host, (lane) => lane.worker_profile === undefined
+        ? undefined
+        : loadWorkerProfile(hqRoot, lane.worker_profile).meta.max_concurrent, nowMs);
+    const queuedReason = capReason ??
+        (earlierEligible ? "queue_position" : undefined);
+    if (!queuedReason)
         return { action: "start" };
-    if (queuedCount >= maxQueued) {
+    if (!input.alreadyQueued && queuedCount >= maxQueued) {
         return {
             action: "refuse",
             error: new LanesError("lane_queue_full", `Lane queue is full for ${pinnedAccount ? `account ${pinnedAccount}` : provider}`, {
@@ -891,27 +900,38 @@ function admitCreate(input) {
             }),
         };
     }
-    if (atCap) {
-        return { action: "queue", reason: isHead ? "cap" : "queue_position" };
-    }
-    return { action: "queue", reason: "queue_position" };
+    return { action: "queue", reason: queuedReason };
 }
-async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccount) {
-    if (current.action !== "start")
+async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccount, options = {}) {
+    if (current.action !== "start" &&
+        !(current.action === "queue" && current.reason === "queue_position"))
         return current;
     const { decision } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
     if (decision.admit)
         return current;
+    if (current.action === "queue")
+        return { action: "queue", reason: "throttle" };
     const providerCfg = config.providers[provider];
+    const host = options.host ?? reconcileHostFromCtx(ctx);
+    const nowMs = options.nowMs ?? ctx.now().getTime();
     const queuedCount = loadAllLanes(hqRoot).filter((lane) => {
-        if (lane.provider !== provider || lane.state !== "queued")
+        if (lane.lane_id === options.excludeLaneId ||
+            lane.provider !== provider ||
+            lane.state !== "queued" ||
+            hasActiveAdmissionReservation(lane, nowMs) ||
+            !laneRunsHere(lane, host))
             return false;
         if (pinnedAccount)
             return lane.account === pinnedAccount;
         return !lane.account;
     }).length;
-    if (queuedCount >= providerCfg.max_queued) {
-        const running = loadAllLanes(hqRoot).filter((lane) => lane.provider === provider && lane.state === "running").length;
+    if (!options.alreadyQueued && queuedCount >= providerCfg.max_queued) {
+        const running = loadAllLanes(hqRoot).filter((lane) => lane.lane_id !== options.excludeLaneId &&
+            lane.provider === provider &&
+            (lane.state === "running" ||
+                hasActiveAdmissionReservation(lane, nowMs) ||
+                hasActivePendingResume(lane, nowMs)) &&
+            laneRunsHere(lane, host)).length;
         return {
             action: "refuse",
             error: new LanesError("lane_queue_full", `Lane queue is full for ${pinnedAccount ? `account ${pinnedAccount}` : provider}`, {
@@ -924,6 +944,45 @@ async function applyThrottle(hqRoot, config, ctx, current, provider, pinnedAccou
     }
     return { action: "queue", reason: "throttle" };
 }
+async function assessLaneAdmission(ctx, lane, options) {
+    const hqRoot = ctx.hqRoot();
+    const config = loadLanesConfig(hqRoot);
+    const account = options.account ?? lane.account;
+    const profile = lane.worker_profile
+        ? loadWorkerProfile(hqRoot, lane.worker_profile)
+        : undefined;
+    const nowMs = ctx.now().getTime();
+    let admission = admitCreate({
+        hqRoot,
+        provider: lane.provider,
+        pinnedAccount: account,
+        ...(profile
+            ? { profileId: profile.id, profileMaxConcurrent: profile.meta.max_concurrent }
+            : {}),
+        host: reconcileHostFromCtx(ctx),
+        priority: lane.priority,
+        createdAt: options.queueAt,
+        nowMs,
+        config,
+        excludeLaneId: lane.lane_id,
+        alreadyQueued: options.alreadyQueued,
+    });
+    if (admission.action === "start" ||
+        (admission.action === "queue" && admission.reason === "queue_position")) {
+        admission = await applyThrottle(hqRoot, config, ctx, admission, lane.provider, account, {
+            host: reconcileHostFromCtx(ctx),
+            excludeLaneId: lane.lane_id,
+            alreadyQueued: options.alreadyQueued,
+            nowMs,
+        });
+    }
+    return admission;
+}
+function assertLaneRunsHereForAdmission(ctx, lane) {
+    if (laneRunsHere(lane, reconcileHostFromCtx(ctx)))
+        return;
+    throw new LanesError("lane_remote", `Lane ${lane.lane_id} is hosted remotely; run the admission command on its Outpost`, { lane_id: lane.lane_id, host: lane.host });
+}
 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 });
@@ -939,8 +998,6 @@ function copyHookRails(fromHome, toHome) {
 function railsPresent(home) {
     return fs.existsSync(path.join(home, "hooks"));
 }
-const ADMISSION_LOCK_STALE_MS = 30_000;
-const ADMISSION_LOCK_TIMEOUT_MS = 5_000;
 /**
  * Spec §5.1: `hq lanes ask` from inside a lane can hit a binary or dist
  * being replaced mid-call (ENOENT / ETXTBSY / a module that no longer
@@ -954,83 +1011,6 @@ function yieldEventLoop() {
         setImmediate(resolve);
     });
 }
-function admissionLockPath(hqRoot, provider, pinnedAccount) {
-    const name = pinnedAccount
-        ? `${provider}-${pinnedAccount}`
-        : `${provider}-unpinned`;
-    return path.join(hqRoot, LANES_RUNS_REL, ".admission-locks", `${name}.lock`);
-}
-async function withAdmissionLock(lockPath, fn, sleep) {
-    ensureDir(path.dirname(lockPath));
-    const started = Date.now();
-    while (true) {
-        let fd;
-        try {
-            fd = fs.openSync(lockPath, "wx");
-            try {
-                fs.writeSync(fd, Buffer.from(`${process.pid}\n${Date.now()}\n`, "utf8"));
-            }
-            catch (err) {
-                fs.closeSync(fd);
-                fd = undefined;
-                throw err;
-            }
-            try {
-                await yieldEventLoop();
-                return await fn();
-            }
-            finally {
-                try {
-                    fs.closeSync(fd);
-                }
-                catch (err) {
-                    process.stderr.write(`hq lanes: admission lock close failed for ${lockPath}: ${err instanceof Error ? err.message : String(err)}\n`);
-                }
-                try {
-                    fs.unlinkSync(lockPath);
-                }
-                catch (err) {
-                    const code = err.code;
-                    if (code !== "ENOENT") {
-                        process.stderr.write(`hq lanes: admission lock unlink failed for ${lockPath}: ${err instanceof Error ? err.message : String(err)}\n`);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== "EEXIST")
-                throw err;
-            if (Date.now() - started > ADMISSION_LOCK_TIMEOUT_MS) {
-                throw new LanesError("store_lock_timeout", `Timed out waiting for admission lock ${lockPath}`, { path: lockPath });
-            }
-            try {
-                const raw = fs.readFileSync(lockPath, "utf8");
-                const tsLine = raw.split("\n")[1];
-                const ts = tsLine ? Number(tsLine) : NaN;
-                if (Number.isFinite(ts) && Date.now() - ts > ADMISSION_LOCK_STALE_MS) {
-                    try {
-                        fs.unlinkSync(lockPath);
-                    }
-                    catch (unlinkErr) {
-                        const unlinkCode = unlinkErr.code;
-                        if (unlinkCode !== "ENOENT")
-                            throw unlinkErr;
-                    }
-                    continue;
-                }
-            }
-            catch (statErr) {
-                const statCode = statErr.code;
-                if (statCode !== "ENOENT") {
-                    process.stderr.write(`hq lanes: stale admission-lock probe failed for ${lockPath}: ${statErr instanceof Error ? statErr.message : String(statErr)}\n`);
-                }
-            }
-            await sleep(10);
-            await yieldEventLoop();
-        }
-    }
-}
 function withCasRetry(fn, attempts = 5) {
     let last;
     for (let i = 0; i < attempts; i += 1) {
@@ -1196,6 +1176,26 @@ async function emitLaneMeshEvent(ctx, company, threadId, event, payload) {
         return;
     await ctx.mesh.appendThreadEvent(company, threadId, event, payload);
 }
+async function emitLaneStartedForStories(ctx, company, lane, threadId) {
+    if (!threadId)
+        return;
+    const failures = [];
+    for (const story of laneStories(lane)) {
+        try {
+            await emitLaneMeshEvent(ctx, company, threadId, "lane_started", {
+                lane_id: lane.lane_id,
+                project_id: story.project_id,
+                story_id: story.story_id,
+            });
+            await ctx.mesh.patchStoryStatus(company, story.project_id, story.story_id, "in_progress");
+        }
+        catch (err) {
+            failures.push(err);
+        }
+    }
+    if (failures.length > 0)
+        throw failures[0];
+}
 export const PICKUP_TERMINAL_REASONS = [
     "account_not_logged_in",
     "unknown_account",
@@ -1375,6 +1375,7 @@ async function runCreate(ctx, opts) {
     const meshCompanyFlag = opts.meshCompany?.trim();
     const project = opts.project?.trim();
     const story = opts.story?.trim();
+    const additionalStories = (opts.additionalStory ?? []).map((value) => value.trim());
     const briefFile = opts.briefFile?.trim();
     if (!project) {
         throw new LanesError("missing_project", "--project is required", {});
@@ -1382,6 +1383,16 @@ async function runCreate(ctx, opts) {
     if (!story) {
         throw new LanesError("missing_story", "--story is required", {});
     }
+    if (additionalStories.some((value) => value.length === 0)) {
+        throw new LanesError("missing_story", "--additional-story values must be non-empty", {});
+    }
+    const storyIds = [story, ...additionalStories];
+    if (new Set(storyIds).size !== storyIds.length) {
+        throw new LanesError("duplicate_story", "A lane cannot carry the same project/story more than once", {
+            project_id: project,
+            stories: storyIds,
+        });
+    }
     if (!briefFile) {
         throw new LanesError("missing_brief_file", "--brief-file is required", {});
     }
@@ -1620,6 +1631,13 @@ async function runCreate(ctx, opts) {
         }
     }
     const allowedAccounts = validatedAccounts.size > 0 ? [...validatedAccounts] : profileAccounts;
+    const balancedAdmissionAccounts = !outpostId && pinnedAccount === undefined
+        ? [...new Set(allowedAccounts ??
+                Object.entries(config.providers[provider].accounts)
+                    .filter(([id, account]) => account.enabled &&
+                    (profileAccounts === undefined || profileAccounts.includes(id)))
+                    .map(([id]) => id))]
+        : undefined;
     const threadId = meshCompany
         ? await ctx.mesh.ensureProjectThread(meshCompany, project)
         : undefined;
@@ -1658,6 +1676,7 @@ async function runCreate(ctx, opts) {
             validation = "pending";
         }
         else {
+            const admissionNowMs = ctx.now().getTime();
             admission = admitCreate({
                 hqRoot,
                 provider,
@@ -1666,14 +1685,16 @@ async function runCreate(ctx, opts) {
                 ...(profile?.meta.max_concurrent !== undefined
                     ? { profileMaxConcurrent: profile.meta.max_concurrent }
                     : {}),
+                host: reconcileHostFromCtx(ctx),
                 priority,
                 createdAt,
+                nowMs: admissionNowMs,
                 config,
             });
             if (admission.action === "refuse" && admission.error) {
                 throw admission.error;
             }
-            admission = await applyThrottle(hqRoot, config, ctx, admission, provider, pinnedAccount);
+            admission = await applyThrottle(hqRoot, config, ctx, admission, provider, pinnedAccount, { nowMs: admissionNowMs });
             if (admission.action === "refuse" && admission.error) {
                 throw admission.error;
             }
@@ -1682,6 +1703,7 @@ async function runCreate(ctx, opts) {
             ? { kind: "outpost", id: outpostId }
             : { kind: "local", id: ctx.hostname() };
         const queuedReason = admission.action === "queue" ? admission.reason : undefined;
+        const admissionReservedAt = admission.action === "start" ? ctx.now().toISOString() : undefined;
         const lane = createLane(hqRoot, {
             company,
             ...(company === null && meshCompany
@@ -1689,12 +1711,22 @@ async function runCreate(ctx, opts) {
                 : {}),
             project_id: project,
             story_id: story,
+            stories: storyIds.map((storyId) => ({
+                project_id: project,
+                story_id: storyId,
+                status: "in_progress",
+                added_at: createdAt,
+                updated_at: createdAt,
+            })),
             thread_id: threadId,
             depth: laneDepth,
             senior,
             senior_history: [],
             state: "queued",
             queued_reason: queuedReason,
+            ...(admissionReservedAt !== undefined
+                ? { admission_reserved_at: admissionReservedAt }
+                : {}),
             priority,
             worker: resolvedWorker?.id ?? opts.worker,
             ...(resolvedWorker ? { worker_path: resolvedWorker.path } : {}),
@@ -1708,6 +1740,9 @@ async function runCreate(ctx, opts) {
                 : {}),
             provider,
             account: pinnedAccount,
+            ...(balancedAdmissionAccounts !== undefined
+                ? { admission_accounts: balancedAdmissionAccounts }
+                : {}),
             ...(model !== undefined ? { model } : {}),
             model_source: cliModel !== undefined
                 ? "cli"
@@ -1734,7 +1769,7 @@ async function runCreate(ctx, opts) {
         persisted = await persist();
     }
     else {
-        persisted = await withAdmissionLock(admissionLockPath(hqRoot, provider, accountWasExplicit ? pinnedAccount : undefined), persist, ctx.sleep);
+        persisted = await withLaneAdmissionLock(hqRoot, provider, persist, ctx.sleep);
     }
     const { lane, admission, validation } = persisted;
     const dest = runDir(hqRoot, lane.lane_id);
@@ -1771,14 +1806,8 @@ async function runCreate(ctx, opts) {
             runCompaction: ctx.runCompaction,
             locateTranscript: ctx.locateTranscript,
         });
-        if (meshCompany) {
-            await emitLaneMeshEvent(ctx, meshCompany, threadId, "lane_started", {
-                lane_id: started.lane_id,
-                project_id: project,
-                story_id: story,
-            });
-            await ctx.mesh.patchStoryStatus(meshCompany, project, story, "in_progress");
-        }
+        if (meshCompany)
+            await emitLaneStartedForStories(ctx, meshCompany, started, threadId);
     }
     else if (outpostId) {
         started = await dispatchCreatedOutpostLane(ctx, {
@@ -1810,6 +1839,8 @@ async function runCreate(ctx, opts) {
         company: started.company,
         project_id: started.project_id,
         story_id: started.story_id,
+        stories: laneStories(started),
+        story_warning: storyWarning(started) ?? null,
         thread_id: started.thread_id ?? null,
         senior: started.senior,
         depth: started.depth,
@@ -1906,6 +1937,9 @@ async function dispatchCreatedOutpostLane(ctx, input) {
     }
 }
 function parseRemotePickupJson(stdout) {
+    return parseRemoteJson(stdout, "Outpost pickup");
+}
+function parseRemoteJson(stdout, surface) {
     const trimmed = stdout.trim();
     if (!trimmed)
         return null;
@@ -1914,14 +1948,92 @@ function parseRemotePickupJson(stdout) {
         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");
+        process.stderr.write(`hq lanes: ${surface} 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`);
+        process.stderr.write(`hq lanes: failed to parse ${surface} JSON: ${err instanceof Error ? err.message : String(err)}\n`);
         return null;
     }
     return null;
 }
+function laneIsHostedHere(ctx, lane) {
+    if (lane.host.kind !== "outpost")
+        return true;
+    const identity = ctx.readOutpostIdentity();
+    if (identity.kind === "unknown") {
+        throw new LanesError("outpost_identity_unknown", `Cannot determine whether this process is Outpost ${lane.host.id}; refusing local lane delivery`, { lane_id: lane.lane_id, outpost_id: lane.host.id });
+    }
+    return identity.kind === "id" && identity.id === lane.host.id;
+}
+async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
+    if (lane.host.kind !== "outpost") {
+        throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to dispatch to`, { lane_id: lane.lane_id });
+    }
+    const outpostId = lane.host.id;
+    let dispatched;
+    try {
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostLaneCommand({
+                action,
+                laneId: lane.lane_id,
+                text: options.text,
+                project: options.project,
+                story: options.story,
+                account: options.account,
+                model: options.model,
+                compact: options.compact,
+            }),
+        });
+    }
+    catch (err) {
+        throw new LanesError("outpost_dispatch_failed", `Could not dispatch ${action} for lane ${lane.lane_id} to Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, outpost_id: outpostId });
+    }
+    if (dispatched.done !== true ||
+        dispatched.status !== "Success" ||
+        dispatched.exitCode !== 0) {
+        throw new LanesError("outpost_dispatch_failed", `Outpost ${outpostId} did not confirm the ${action} command`, {
+            lane_id: lane.lane_id,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+            status: dispatched.status,
+            done: dispatched.done ?? false,
+            exit_code: dispatched.exitCode,
+        });
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost lane command");
+    if (remote?.error !== undefined) {
+        throw new LanesError("outpost_remote_command_failed", typeof remote.message === "string"
+            ? remote.message
+            : `Outpost ${outpostId} rejected the ${action} command`, {
+            lane_id: lane.lane_id,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+            remote_error: remote.error,
+        });
+    }
+    const resultConfirmed = remote !== null &&
+        remote.ok === true &&
+        remote.action === action &&
+        remote.lane_id === lane.lane_id &&
+        (action === "message"
+            ? remote.accepted === true
+            : remote.delivery_status === "worker_spawned" ||
+                remote.delivery_status === "queued_on_target_account");
+    if (!resultConfirmed) {
+        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without a confirmed ${action} result for lane ${lane.lane_id}`, {
+            lane_id: lane.lane_id,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+        });
+    }
+    printJson({
+        ...remote,
+        outpost_id: outpostId,
+        outpost_command_id: dispatched.commandId,
+        outpost_transport: "outposts_exec",
+    });
+}
 function ingestPickupPayload(hqRoot, payload, now) {
     const laneId = payload.lane.lane_id;
     if (!laneId) {
@@ -2030,38 +2142,54 @@ async function runPickup(ctx, opts) {
         });
         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,
-            };
+    let selfTargetCancelled = false;
+    const started = await withLaneAdmissionLock(hqRoot, afterAccount.provider, async () => {
+        const current = readLane(hqRoot, afterAccount.lane_id);
+        const config = loadLanesConfig(hqRoot);
+        const nowMs = ctx.now().getTime();
+        let admission = admitCreate({
+            hqRoot,
+            provider: current.provider,
+            pinnedAccount: current.account,
+            ...(current.worker_profile !== undefined
+                ? {
+                    profileId: current.worker_profile,
+                    profileMaxConcurrent: loadWorkerProfile(hqRoot, current.worker_profile).meta.max_concurrent,
+                }
+                : {}),
+            host: reconcileHostFromCtx(ctx),
+            priority: current.priority,
+            createdAt: current.queued_at ?? current.created_at,
+            nowMs,
+            config,
+            excludeLaneId: current.lane_id,
+            alreadyQueued: true,
         });
-    }
-    else {
+        if (admission.action === "refuse" && admission.error)
+            throw admission.error;
+        admission = await applyThrottle(hqRoot, config, ctx, admission, current.provider, current.account, { host: reconcileHostFromCtx(ctx), excludeLaneId: current.lane_id, alreadyQueued: true, nowMs });
+        if (admission.action === "refuse" && admission.error)
+            throw admission.error;
+        if (admission.action === "queue") {
+            return casUpdateLane(hqRoot, current.lane_id, (live) => {
+                if (live.version !== current.version || isTerminalLaneState(live.state)) {
+                    throw new LanesError("lane_admission_conflict", `Lane ${current.lane_id} changed while pickup admission was checked`, {
+                        lane_id: current.lane_id,
+                        prepared_version: current.version,
+                        version: live.version,
+                        state: live.state,
+                    });
+                }
+                return {
+                    ...live,
+                    state: "queued",
+                    queued_reason: admission.reason ?? "throttle",
+                    queued_at: live.queued_at ?? ctx.now().toISOString(),
+                };
+            });
+        }
         try {
-            started = spawnLaneWorker(hqRoot, afterAccount, {
+            return spawnLaneWorker(hqRoot, current, {
                 env: ctx.env,
                 modelDeps: {
                     readFileSync: ctx.readFileSync,
@@ -2080,19 +2208,22 @@ async function runPickup(ctx, opts) {
         }
         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;
+                selfTargetCancelled = true;
+                return readLane(hqRoot, afterAccount.lane_id);
             }
             throw err;
         }
+    }, ctx.sleep);
+    if (selfTargetCancelled) {
+        printJson({
+            ok: true,
+            action: "pickup",
+            lane_id: started.lane_id,
+            state: started.state,
+            error: "outpost_self_target",
+            lane: started,
+        });
+        return;
     }
     printJson({
         ok: true,
@@ -2112,14 +2243,16 @@ async function runList(ctx, opts) {
         company = await ctx.resolveCompany(opts.company);
     }
     const now = ctx.now();
+    const host = reconcileHostFromCtx(ctx);
     const lanes = loadAllLanes(hqRoot)
         .filter((lane) => {
         if (state && lane.state !== state)
             return false;
-        if (opts.project && lane.project_id !== opts.project)
-            return false;
-        if (opts.story && lane.story_id !== opts.story)
+        if ((opts.project || opts.story) &&
+            !laneStories(lane).some((story) => (!opts.project || story.project_id === opts.project) &&
+                (!opts.story || story.story_id === opts.story))) {
             return false;
+        }
         if (company && !recordMatchesCompany(lane, company)) {
             return false;
         }
@@ -2127,28 +2260,42 @@ async function runList(ctx, opts) {
             return false;
         return true;
     })
-        .sort(compareQueueOrder)
-        .map((lane) => ({
-        ...lane,
-        overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
-        stalled: Boolean(lane.stalled),
-        // Listing is observational. Reconcile owns durable liveness transitions.
-        senior_lost: lane.state === "running" && lane.senior.kind === "session" && lane.senior.id
-            ? (() => {
-                const state = sessionLiveness(hqRoot, lane.senior.id, {
-                    nowMs: now.getTime(),
-                    deps: livenessDepsFromCtx(ctx),
-                    presenceConnected: ctx.presenceConnected,
-                });
-                return state === null || state === "ended" || state === "lost";
-            })()
-            : false,
-    }));
+        .sort(compareLaneQueueOrder)
+        .map((lane) => {
+        const remoteQueued = lane.state === "queued" &&
+            lane.host.kind === "outpost" &&
+            !laneRunsHere(lane, host);
+        return {
+            ...lane,
+            ...(remoteQueued
+                ? { state: "remote", remote_state: lane.state, queued_reason: undefined }
+                : {}),
+            overdue: Boolean(lane.overdue) || isOverdue(hqRoot, lane.lane_id, now),
+            stalled: Boolean(lane.stalled),
+            // Listing is observational. Reconcile owns durable liveness transitions.
+            senior_lost: lane.state === "running" && lane.senior.kind === "session" && lane.senior.id
+                ? (() => {
+                    const state = sessionLiveness(hqRoot, lane.senior.id, {
+                        nowMs: now.getTime(),
+                        deps: livenessDepsFromCtx(ctx),
+                        presenceConnected: ctx.presenceConnected,
+                    });
+                    return state === null || state === "ended" || state === "lost";
+                })()
+                : false,
+        };
+    });
     printJson({ ok: true, action: "list", lanes });
 }
 async function runShow(ctx, laneId) {
     const hqRoot = ctx.hqRoot();
-    const lane = readLane(hqRoot, laneId);
+    const storedLane = readLane(hqRoot, laneId);
+    const remoteQueued = storedLane.state === "queued" &&
+        storedLane.host.kind === "outpost" &&
+        !laneRunsHere(storedLane, reconcileHostFromCtx(ctx));
+    const lane = remoteQueued
+        ? { ...storedLane, state: "remote", remote_state: storedLane.state, queued_reason: undefined }
+        : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
     printJson({
         ok: true,
@@ -2159,7 +2306,7 @@ async function runShow(ctx, laneId) {
         stalled_at: lane.stalled_at ?? null,
         stalled_reason: lane.stalled_reason ?? null,
         ask_delivery_failed: askDeliveryFailed,
-        delivery: laneDeliveryMechanism(lane),
+        delivery: laneDeliveryMechanism(storedLane),
         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,
@@ -2175,10 +2322,136 @@ async function runShow(ctx, laneId) {
         terminal_details: lane.terminal_details ?? null,
         last_message_at: lane.last_message_at ?? null,
         last_compaction: lane.last_compaction
-            ? { ...lane.last_compaction, after: compactionAfterUsage(lane) }
+            ? { ...lane.last_compaction, after: compactionAfterUsage(storedLane) }
             : null,
     });
 }
+function forceAdmissionAuthorized(ctx, lane) {
+    const sessionId = sessionIdFromEnv(ctx.env);
+    const callerLaneId = ctx.env.HQ_LANE_ID?.trim() || undefined;
+    if (lane.senior.kind === "lane") {
+        return callerLaneId !== undefined && callerLaneId === lane.senior.id;
+    }
+    if (!sessionId || callerLaneId !== undefined)
+        return false;
+    if (lane.senior.kind === "session")
+        return sessionId === lane.senior.id;
+    if (lane.senior.kind !== "user")
+        return false;
+    const loaded = loadSessionMeta(ctx.hqRoot(), sessionId, ctx);
+    if (loaded.status !== "ok")
+        return false;
+    const senior = loaded.doc.senior;
+    return senior === "user" ||
+        (senior !== null && typeof senior === "object" && !Array.isArray(senior) &&
+            senior.kind === "user");
+}
+async function runAdmit(ctx, laneId, opts) {
+    const hqRoot = ctx.hqRoot();
+    let lane = readLane(hqRoot, laneId);
+    if (lane.state !== "queued") {
+        throw new LanesError("lane_not_queued", `Lane ${laneId} is ${lane.state}; only a queued lane can be admitted`, {
+            lane_id: laneId,
+            state: lane.state,
+        });
+    }
+    const host = reconcileHostFromCtx(ctx);
+    if (!laneRunsHere(lane, host)) {
+        printJson({ ok: true, action: "admit", lane_id: laneId, admitted: false, blocked_by: "remote", lane });
+        return;
+    }
+    if (lane.pickup_validation_pending === true) {
+        printJson({ ok: true, action: "admit", lane_id: laneId, admitted: false, blocked_by: "pickup_validation", lane });
+        return;
+    }
+    await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+        lane = readLane(hqRoot, laneId);
+        if (lane.state !== "queued") {
+            throw new LanesError("lane_not_queued", `Lane ${laneId} changed to ${lane.state} before admission`, {
+                lane_id: laneId,
+                state: lane.state,
+            });
+        }
+        let blockedBy;
+        if (opts.force) {
+            if (!forceAdmissionAuthorized(ctx, lane)) {
+                throw new LanesError("force_not_authorized", `Only lane ${lane.senior.kind === "lane" ? lane.senior.id : lane.senior.kind === "session" ? lane.senior.id : "senior/operator"} may force admission of ${laneId}`, { lane_id: laneId, senior: lane.senior });
+            }
+            const config = loadLanesConfig(hqRoot);
+            const lanes = loadAllLanes(hqRoot).filter((row) => row.lane_id !== laneId && laneRunsHere(row, host));
+            const { decision } = await decideAdmission(hqRoot, config.throttle, ctx.throttleDeps);
+            if (!decision.admit) {
+                blockedBy = "throttle";
+            }
+            else if (hasEarlierEligibleQueuedLane(lanes, lane, config, host, (row) => row.worker_profile === undefined
+                ? undefined
+                : loadWorkerProfile(hqRoot, row.worker_profile).meta.max_concurrent)) {
+                blockedBy = "queue_position";
+            }
+        }
+        else {
+            const admission = await assessLaneAdmission(ctx, lane, {
+                queueAt: lane.queued_at ?? lane.created_at,
+                alreadyQueued: true,
+            });
+            if (admission.action === "refuse" && admission.error) {
+                throw admission.error;
+            }
+            if (admission.action === "queue")
+                blockedBy = admission.reason ?? "throttle";
+        }
+        if (blockedBy !== undefined) {
+            const updated = casUpdateLane(hqRoot, laneId, (current) => {
+                if (current.version !== lane.version || current.state !== "queued") {
+                    throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while admission was checked`, {
+                        lane_id: laneId,
+                        prepared_version: lane.version,
+                        version: current.version,
+                        state: current.state,
+                    });
+                }
+                return { ...current, queued_reason: blockedBy };
+            });
+            printJson({
+                ok: true,
+                action: "admit",
+                lane_id: laneId,
+                admitted: false,
+                blocked_by: blockedBy,
+                lane: updated,
+            });
+            return;
+        }
+        const started = spawnLaneWorker(hqRoot, lane, {
+            env: ctx.env,
+            modelDeps: {
+                readFileSync: ctx.readFileSync,
+                probe: ctx.probeProvider,
+                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,
+        });
+        const admitted = opts.force && started.state === "running"
+            ? casUpdateLane(hqRoot, laneId, (current) => ({ ...current, admitted_reason: "operator_force" }))
+            : started;
+        printJson({
+            ok: true,
+            action: "admit",
+            lane_id: laneId,
+            admitted: admitted.state === "running",
+            forced: Boolean(opts.force),
+            blocked_by: admitted.state === "running" ? null : admitted.queued_reason ?? null,
+            lane: admitted,
+        });
+    }, ctx.sleep);
+}
 /**
  * US-023: move the lane's provider session to `--account` (same provider)
  * before a resume or a message resume. Every check runs before anything is
@@ -2191,6 +2464,7 @@ async function prepareAccountMove(ctx, lane, input) {
     const hqRoot = ctx.hqRoot();
     const now = ctx.now();
     const laneId = lane.lane_id;
+    assertLaneRunsHereForAdmission(ctx, lane);
     if (lane.state === "running") {
         throw new LanesError("lane_running", `Lane ${laneId} is running; stop it or wait for it to exit before moving its session`, {
             lane_id: laneId,
@@ -2222,6 +2496,9 @@ async function prepareAccountMove(ctx, lane, input) {
     if (!providerSupportsSessionResume(lane.provider)) {
         throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
     }
+    if (lane.provider === "grok") {
+        throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
+    }
     if (!hasRecordedSessionId(lane)) {
         throw new LanesError("no_provider_session", `Lane ${laneId} has no recorded provider session id, so there is no session to move`, { lane_id: laneId, provider: lane.provider });
     }
@@ -2282,12 +2559,14 @@ async function prepareAccountMove(ctx, lane, input) {
         throw new AccountResolutionError("unknown_account", `Lane ${laneId} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`, { provider: lane.provider, account: lane.account ?? "", enabled: [] });
     }
     // Checks done. Copy the session files, then write the record.
-    const copy = copySessionFiles(planSessionCopy(lane.provider, {
-        sourceHome: sourceCfg.home,
-        targetHome: targetCfg.home,
-        cwd: hqRoot,
+    const copy = ensureSessionHome({
+        provider: lane.provider,
         sessionId,
-    }));
+        cwd: hqRoot,
+        targetHome: targetCfg.home,
+        registeredHomes: Object.values(providerCfg.accounts).map((account) => account.home),
+        providerHomeAtSpawn: lane.provider_home_at_spawn ?? sourceCfg.home,
+    });
     const at = now.toISOString();
     const from = lane.account ?? null;
     // The capacity decision and the record write run under the target
@@ -2296,16 +2575,14 @@ async function prepareAccountMove(ctx, lane, input) {
     // pointed at the account whose spawn has not claimed it yet
     // (`pending_resume` set by this write, cleared by the claim), so two moves
     // into one free slot cannot both start.
-    return withAdmissionLock(admissionLockPath(hqRoot, lane.provider, target), async () => {
-        const lanes = loadAllLanes(hqRoot);
-        // A queued lane with a pending resume waits for admission and holds
-        // no slot; one in any other state with a pending resume is a move
-        // whose spawn is about to claim, and holds the slot it was granted.
-        const occupies = (row) => row.lane_id !== laneId &&
-            (row.state === "running" || (row.pending_resume !== undefined && row.state !== "queued"));
-        const onProvider = lanes.filter((row) => row.provider === lane.provider && occupies(row));
-        const atCap = onProvider.length >= providerCfg.max_running ||
-            onProvider.filter((row) => row.account === target).length >= accountMaxRunning(providerCfg, target);
+    return withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+        const admission = await assessLaneAdmission(ctx, lane, {
+            account: target,
+            queueAt: at,
+        });
+        if (admission.action === "refuse" && admission.error)
+            throw admission.error;
+        const queued = admission.action === "queue";
         const moved = casUpdateLane(hqRoot, laneId, (current) => {
             // The copy and every check above were made from `lane`; a record
             // that moved on since (another move, a spawn, a cancel) invalidates
@@ -2317,6 +2594,9 @@ async function prepareAccountMove(ctx, lane, input) {
             const next = {
                 ...current,
                 account: target,
+                admission_accounts: undefined,
+                provider_session_id: sessionId,
+                provider_session_id_absent: undefined,
                 ...(input.cliModel !== undefined
                     ? { model: input.cliModel, model_source: "cli" }
                     : {}),
@@ -2328,13 +2608,17 @@ async function prepareAccountMove(ctx, lane, input) {
                 }),
                 pending_resume: { session_id: sessionId, at, ...input.pending },
             };
-            if (atCap) {
+            if (queued) {
                 next.state = "queued";
-                next.queued_reason = "cap";
+                next.queued_reason = admission.reason ?? "throttle";
+                next.queued_at = at;
+            }
+            else {
+                next.queued_at = undefined;
             }
             return next;
         });
-        return { lane: moved, from, to: target, copy, queued: atCap };
+        return { lane: moved, from, to: target, copy, queued };
     }, ctx.sleep);
 }
 async function runMessage(ctx, laneId, opts) {
@@ -2344,6 +2628,11 @@ async function runMessage(ctx, laneId, opts) {
         throw new LanesError("missing_text", "--text is required", {});
     }
     let lane = readLane(hqRoot, laneId);
+    if (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane)) {
+        await dispatchOutpostLaneCommand(ctx, lane, "message", opts);
+        return;
+    }
+    lane = laneWithRecoveredProviderSession(hqRoot, lane);
     // An account move is refused on its own terms first: a running lane and a
     // provider without session resume get the move's named errors, not the
     // generic delivery refusal below.
@@ -2384,6 +2673,7 @@ async function runMessage(ctx, laneId, opts) {
     };
     let resumed = null;
     let move = null;
+    let queuedOnAdmission = false;
     if (opts.account !== undefined) {
         // A moved message is always a resume on the target account: a running
         // lane (the dropbox mechanism) is refused inside prepareAccountMove.
@@ -2408,31 +2698,70 @@ async function runMessage(ctx, laneId, opts) {
         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,
-            modelDeps: {
-                readFileSync: ctx.readFileSync,
-                probe: ctx.probeProvider,
+        // Exited worker with a recorded session: queue the message when capacity
+        // is occupied, otherwise start its next turn under the shared admission lock.
+        assertLaneRunsHereForAdmission(ctx, lane);
+        resumed = await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+            const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
+            if (admission.action === "refuse" && admission.error)
+                throw admission.error;
+            if (admission.action === "queue") {
+                const sessionId = lane.provider_session_id;
+                if (!sessionId) {
+                    throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this message resume`, {
+                        lane_id: laneId,
+                        provider: lane.provider,
+                    });
+                }
+                archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                queuedOnAdmission = true;
+                return casUpdateLane(hqRoot, laneId, (current) => {
+                    if (current.version !== lane.version || current.state !== lane.state) {
+                        throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
+                            lane_id: laneId,
+                            prepared_version: lane.version,
+                            version: current.version,
+                            state: current.state,
+                        });
+                    }
+                    return {
+                        ...current,
+                        state: "queued",
+                        queued_reason: admission.reason ?? "throttle",
+                        queued_at: at,
+                        pending_resume: {
+                            session_id: sessionId,
+                            trigger: "message",
+                            text,
+                            message_id: messageId,
+                            compact: opts.compact !== false,
+                            at,
+                        },
+                    };
+                });
+            }
+            const 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,
-        }, {
-            trigger: { kind: "message", text, message_id: messageId },
-            compact: opts.compact !== false,
-        });
+                modelDeps: {
+                    readFileSync: ctx.readFileSync,
+                    probe: ctx.probeProvider,
+                    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,
+            });
+            archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+            return started;
+        }, ctx.sleep);
     }
     // Every accepted message moves the compaction reference forward.
     let next = casUpdateLane(hqRoot, laneId, (current) => ({
@@ -2448,6 +2777,18 @@ async function runMessage(ctx, laneId, opts) {
                 ...current,
                 project_id: projectId,
                 story_id: storyId,
+                stories: laneStory(current, projectId, storyId)
+                    ? laneStories(current)
+                    : [
+                        ...laneStories(current),
+                        {
+                            project_id: projectId,
+                            story_id: storyId,
+                            status: "in_progress",
+                            added_at: at,
+                            updated_at: at,
+                        },
+                    ],
                 attribution_history: appendCappedHistory(current.attribution_history, {
                     project_id: projectId,
                     story_id: storyId,
@@ -2466,9 +2807,11 @@ async function runMessage(ctx, laneId, opts) {
     const drainHook = drainHookStatusFor(ctx, next);
     const deliveryStatus = move?.queued
         ? "queued_on_target_account"
-        : mechanism === "dropbox"
-            ? "awaiting_next_tool_call"
-            : "worker_spawned";
+        : queuedOnAdmission
+            ? "queued_on_admission"
+            : 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
@@ -2493,6 +2836,8 @@ async function runMessage(ctx, laneId, opts) {
         account_move: move ? accountMoveSummary(move) : null,
         project_id: next.project_id,
         story_id: next.story_id,
+        stories: laneStories(next),
+        story_warning: storyWarning(next) ?? null,
         lane: next,
     });
 }
@@ -2508,6 +2853,30 @@ function accountMoveSummary(move) {
         target_dir: move.copy.target_dir,
     };
 }
+function laneWithRecoveredProviderSession(hqRoot, lane) {
+    if (lane.provider === "grok")
+        return lane;
+    const manifest = readSpawnManifest(laneRunDir(hqRoot, lane.lane_id));
+    const sessionId = (typeof lane.provider_session_id === "string" && lane.provider_session_id.trim()
+        ? lane.provider_session_id
+        : undefined) ??
+        (typeof lane.last_resume?.session_id === "string" && lane.last_resume.session_id.trim()
+            ? lane.last_resume.session_id
+            : undefined) ??
+        (typeof manifest.resume?.session_id === "string" && manifest.resume.session_id.trim()
+            ? manifest.resume.session_id
+            : undefined);
+    const providerHome = lane.provider_home_at_spawn ?? manifest.provider_home_at_spawn;
+    return {
+        ...lane,
+        ...(lane.provider_session_id === undefined && sessionId !== undefined
+            ? { provider_session_id: sessionId, provider_session_id_absent: undefined }
+            : {}),
+        ...(lane.provider_home_at_spawn === undefined && providerHome !== undefined
+            ? { provider_home_at_spawn: providerHome }
+            : {}),
+    };
+}
 /**
  * `hq lanes resume <lane-id> [--text <msg>]`: the explicit opt-in that
  * continues a lane in `interrupted`, `done` or `blocked` on its recorded
@@ -2520,6 +2889,11 @@ function accountMoveSummary(move) {
 async function runResume(ctx, laneId, opts) {
     const hqRoot = ctx.hqRoot();
     let lane = readLane(hqRoot, laneId);
+    if (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane)) {
+        await dispatchOutpostLaneCommand(ctx, lane, "resume", opts);
+        return;
+    }
+    lane = laneWithRecoveredProviderSession(hqRoot, lane);
     if (opts.model !== undefined && opts.account === undefined) {
         throw new LanesError("model_requires_account", "--model on hq lanes resume is only accepted together with --account", {});
     }
@@ -2532,6 +2906,9 @@ async function runResume(ctx, laneId, opts) {
     if (opts.account !== undefined && !providerSupportsSessionResume(lane.provider)) {
         throw new LanesError("provider_session_not_portable", `Provider ${lane.provider} has no session resume, so a lane cannot move between its accounts`, { lane_id: laneId, provider: lane.provider });
     }
+    if (lane.state === "queued") {
+        throw new LanesError("lane_not_resumable", `Lane ${laneId} is queued; use hq lanes admit ${laneId} to request admission`, { lane_id: laneId, state: lane.state, admission_command: `hq lanes admit ${laneId}` });
+    }
     const refusal = resumeCommandRefusal(lane);
     if (refusal !== null) {
         throw new LanesError(refusal.error, refusal.message, {
@@ -2541,6 +2918,7 @@ async function runResume(ctx, laneId, opts) {
             message: refusal.message,
         });
     }
+    assertLaneRunsHereForAdmission(ctx, lane);
     const resumedFrom = lane.state;
     const text = opts.text?.trim() ? opts.text : undefined;
     const at = ctx.now().toISOString();
@@ -2563,32 +2941,77 @@ async function runResume(ctx, laneId, opts) {
         });
         lane = move.lane;
     }
-    const resumed = move?.queued
-        ? lane
-        : spawnLaneWorker(hqRoot, lane, {
-            env: ctx.env,
-            modelDeps: {
-                readFileSync: ctx.readFileSync,
-                probe: ctx.probeProvider,
+    let queuedOnAdmission = false;
+    let resumed;
+    if (move?.queued) {
+        resumed = lane;
+    }
+    else {
+        resumed = await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+            const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
+            if (admission.action === "refuse" && admission.error)
+                throw admission.error;
+            if (admission.action === "queue") {
+                const sessionId = lane.provider_session_id;
+                if (!sessionId) {
+                    throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this resume`, {
+                        lane_id: laneId,
+                        provider: lane.provider,
+                    });
+                }
+                queuedOnAdmission = true;
+                return casUpdateLane(hqRoot, laneId, (current) => {
+                    if (current.version !== lane.version || current.state !== lane.state) {
+                        throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while resume admission was checked`, {
+                            lane_id: laneId,
+                            prepared_version: lane.version,
+                            version: current.version,
+                            state: current.state,
+                        });
+                    }
+                    return {
+                        ...current,
+                        state: "queued",
+                        queued_reason: admission.reason ?? "throttle",
+                        queued_at: at,
+                        pending_resume: {
+                            session_id: sessionId,
+                            trigger: "resume",
+                            resumed_from: resumedFrom,
+                            ...(text !== undefined ? { text } : {}),
+                            ...(messageId !== undefined ? { message_id: messageId } : {}),
+                            compact: opts.compact !== false,
+                            at,
+                        },
+                    };
+                });
+            }
+            return 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,
-        });
+                modelDeps: {
+                    readFileSync: ctx.readFileSync,
+                    probe: ctx.probeProvider,
+                    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,
+            });
+        }, ctx.sleep);
+    }
     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.
@@ -2618,6 +3041,18 @@ async function runResume(ctx, laneId, opts) {
                 ...current,
                 project_id: projectId,
                 story_id: storyId,
+                stories: laneStory(current, projectId, storyId)
+                    ? laneStories(current)
+                    : [
+                        ...laneStories(current),
+                        {
+                            project_id: projectId,
+                            story_id: storyId,
+                            status: "in_progress",
+                            added_at: at,
+                            updated_at: at,
+                        },
+                    ],
                 attribution_history: appendCappedHistory(current.attribution_history, {
                     project_id: projectId,
                     story_id: storyId,
@@ -2635,7 +3070,11 @@ async function runResume(ctx, laneId, opts) {
         message_id: messageId ?? null,
         text: text ?? null,
         delivery: "resume",
-        delivery_status: move?.queued ? "queued_on_target_account" : "worker_spawned",
+        delivery_status: move?.queued
+            ? "queued_on_target_account"
+            : queuedOnAdmission
+                ? "queued_on_admission"
+                : "worker_spawned",
         account_move: move ? accountMoveSummary(move) : null,
         resumed_session_id: resumed.last_resume?.session_id ?? null,
         last_resume: next.last_resume ?? null,
@@ -2644,9 +3083,245 @@ async function runResume(ctx, laneId, opts) {
             : null,
         project_id: next.project_id,
         story_id: next.story_id,
+        stories: laneStories(next),
+        story_warning: storyWarning(next) ?? null,
         lane: next,
     });
 }
+function storyCommandTarget(lane, storyId, project) {
+    const projectId = project?.trim() || lane.project_id;
+    const normalizedStoryId = storyId.trim();
+    if (!projectId) {
+        throw new LanesError("missing_project", "--project is required", {});
+    }
+    if (!normalizedStoryId) {
+        throw new LanesError("missing_story", "<story-id> is required", {});
+    }
+    const story = laneStory(lane, projectId, normalizedStoryId);
+    if (!story) {
+        throw new LanesError("story_not_on_lane", `Story ${projectId}/${normalizedStoryId} is not carried by lane ${lane.lane_id}`, { lane_id: lane.lane_id, project_id: projectId, story_id: normalizedStoryId });
+    }
+    return { projectId, storyId: normalizedStoryId, story };
+}
+function updateCarriedStory(lane, projectId, storyId, status, at, extras = {}) {
+    const stories = laneStories(lane).map((story) => story.project_id === projectId && story.story_id === storyId
+        ? {
+            ...story,
+            status,
+            updated_at: at,
+            blocked_reason: extras.blocked_reason,
+            verified_at: extras.verified_at,
+            verified_by: extras.verified_by,
+        }
+        : story);
+    return {
+        ...lane,
+        project_id: projectId,
+        story_id: storyId,
+        stories,
+    };
+}
+function addCarriedStory(lane, projectId, storyId, at) {
+    if (laneStory(lane, projectId, storyId)) {
+        throw new LanesError("story_already_on_lane", `Story ${projectId}/${storyId} is already carried by lane ${lane.lane_id}`, {
+            lane_id: lane.lane_id,
+            project_id: projectId,
+            story_id: storyId,
+        });
+    }
+    return {
+        ...lane,
+        project_id: projectId,
+        story_id: storyId,
+        stories: [
+            ...laneStories(lane),
+            { project_id: projectId, story_id: storyId, status: "in_progress", added_at: at, updated_at: at },
+        ],
+    };
+}
+function callerMayVerifyStory(ctx, lane) {
+    const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
+    if (callerLaneId) {
+        return lane.senior.kind === "lane" && lane.senior.id === callerLaneId;
+    }
+    if (lane.senior.kind === "user")
+        return true;
+    if (lane.senior.kind === "lane")
+        return false;
+    return sessionIdFromEnv(ctx.env) === lane.senior.id;
+}
+async function ensureStoryThread(ctx, lane, projectId) {
+    const company = lane.mesh_company ?? lane.company;
+    if (!company)
+        return lane;
+    const threadId = await ctx.mesh.ensureProjectThread(company, projectId);
+    if (threadId === lane.thread_id)
+        return lane;
+    return casUpdateLane(ctx.hqRoot(), lane.lane_id, (current) => ({
+        ...current,
+        thread_id: threadId,
+    }));
+}
+async function emitStoryTransition(ctx, lane, projectId, storyId, event, status, payload = {}) {
+    const company = lane.mesh_company ?? lane.company;
+    if (!company)
+        return;
+    const ready = await ensureStoryThread(ctx, lane, projectId);
+    if (!ready.thread_id)
+        return;
+    await emitLaneMeshEvent(ctx, company, ready.thread_id, event, {
+        lane_id: ready.lane_id,
+        project_id: projectId,
+        story_id: storyId,
+        ...payload,
+    });
+    await ctx.mesh.patchStoryStatus(company, projectId, storyId, status === "blocked" ? "in_progress" : status);
+}
+function sameCommittedStory(current, expected, projectId, storyId) {
+    const currentStory = laneStory(current, projectId, storyId);
+    const expectedStory = laneStory(expected, projectId, storyId);
+    return (current.project_id === expected.project_id &&
+        current.story_id === expected.story_id &&
+        JSON.stringify(currentStory) === JSON.stringify(expectedStory));
+}
+async function commitStoryTransition(ctx, before, next, projectId, storyId, event, status, payload = {}) {
+    try {
+        await emitStoryTransition(ctx, next, projectId, storyId, event, status, payload);
+    }
+    catch (err) {
+        try {
+            const current = readLane(ctx.hqRoot(), next.lane_id);
+            if (!sameCommittedStory(current, next, projectId, storyId)) {
+                throw new LanesError("story_transition_rollback_conflict", `Story ${projectId}/${storyId} changed while mesh publication failed`, { lane_id: next.lane_id, project_id: projectId, story_id: storyId });
+            }
+            updateLane(ctx.hqRoot(), next.lane_id, current.version, "command", (latest) => {
+                if (!sameCommittedStory(latest, next, projectId, storyId)) {
+                    throw new LanesError("story_transition_rollback_conflict", `Story ${projectId}/${storyId} changed before rollback`, { lane_id: next.lane_id, project_id: projectId, story_id: storyId });
+                }
+                return {
+                    ...latest,
+                    project_id: before.project_id,
+                    story_id: before.story_id,
+                    stories: before.stories,
+                };
+            });
+        }
+        catch (rollbackErr) {
+            process.stderr.write(`hq lanes: story transition rollback failed for ${next.lane_id}/${projectId}/${storyId}: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}\n`);
+        }
+        throw err;
+    }
+}
+async function runStoryList(ctx, laneId) {
+    const lane = readLane(ctx.hqRoot(), laneId);
+    printJson({
+        ok: true,
+        action: "story.list",
+        lane_id: laneId,
+        stories: laneStories(lane),
+        active_stories: activeLaneStories(lane),
+        story_warning: storyWarning(lane) ?? null,
+    });
+}
+async function runStoryAdd(ctx, laneId, storyId, opts) {
+    const hqRoot = ctx.hqRoot();
+    let lane = readLane(hqRoot, laneId);
+    const projectId = opts.project?.trim() || lane.project_id;
+    if (!projectId)
+        throw new LanesError("missing_project", "--project is required", {});
+    const normalizedStoryId = storyId.trim();
+    if (!normalizedStoryId)
+        throw new LanesError("missing_story", "<story-id> is required", {});
+    const at = ctx.now().toISOString();
+    lane = await ensureStoryThread(ctx, lane, projectId);
+    const before = lane;
+    const next = casUpdateLane(hqRoot, laneId, (current) => addCarriedStory(current, projectId, normalizedStoryId, at));
+    await commitStoryTransition(ctx, before, next, projectId, normalizedStoryId, "lane_started", "in_progress");
+    const finalLane = readLane(hqRoot, laneId);
+    printJson({
+        ok: true,
+        action: "story.add",
+        lane_id: laneId,
+        project_id: projectId,
+        story_id: normalizedStoryId,
+        status: "in_progress",
+        story_warning: storyWarning(finalLane) ?? null,
+        lane: finalLane,
+    });
+}
+async function runStoryStart(ctx, laneId, storyId, opts) {
+    const hqRoot = ctx.hqRoot();
+    let lane = readLane(hqRoot, laneId);
+    const target = storyCommandTarget(lane, storyId, opts.project);
+    if (target.story.status === "done") {
+        throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be started again`, {
+            lane_id: laneId,
+            project_id: target.projectId,
+            story_id: target.storyId,
+        });
+    }
+    const at = ctx.now().toISOString();
+    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const before = lane;
+    const next = casUpdateLane(hqRoot, laneId, (current) => updateCarriedStory(current, target.projectId, target.storyId, "in_progress", at));
+    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_started", "in_progress");
+    const finalLane = readLane(hqRoot, laneId);
+    printJson({ ok: true, action: "story.start", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "in_progress", story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+}
+async function runStoryBlock(ctx, laneId, storyId, opts) {
+    const hqRoot = ctx.hqRoot();
+    let lane = readLane(hqRoot, laneId);
+    const target = storyCommandTarget(lane, storyId, opts.project);
+    if (target.story.status === "done") {
+        throw new LanesError("story_already_done", `Story ${target.projectId}/${target.storyId} is done and cannot be blocked again`, {
+            lane_id: laneId,
+            project_id: target.projectId,
+            story_id: target.storyId,
+        });
+    }
+    const reason = opts.reason?.trim();
+    if (!reason)
+        throw new LanesError("missing_block_reason", "--reason is required", {});
+    const at = ctx.now().toISOString();
+    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const before = lane;
+    const next = casUpdateLane(hqRoot, laneId, (current) => updateCarriedStory(current, target.projectId, target.storyId, "blocked", at, { blocked_reason: reason }));
+    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_blocked", "blocked", { blocked_reason: reason });
+    const finalLane = readLane(hqRoot, laneId);
+    printJson({ ok: true, action: "story.block", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "blocked", blocked_reason: reason, story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+}
+async function runStoryDone(ctx, laneId, storyId, opts) {
+    const hqRoot = ctx.hqRoot();
+    let lane = readLane(hqRoot, laneId);
+    if (!opts.verified) {
+        throw new LanesError("senior_verification_required", "Only a senior may mark a story done; pass --verified after reviewing or merging it", { lane_id: laneId });
+    }
+    if (!callerMayVerifyStory(ctx, lane)) {
+        throw new LanesError("senior_verification_required", `Caller is not the senior for lane ${laneId}`, {
+            lane_id: laneId,
+            senior: lane.senior,
+        });
+    }
+    const target = storyCommandTarget(lane, storyId, opts.project);
+    if (target.story.status !== "review") {
+        throw new LanesError("story_not_ready_for_verification", `Story ${target.projectId}/${target.storyId} must be in review before senior verification`, {
+            lane_id: laneId,
+            project_id: target.projectId,
+            story_id: target.storyId,
+            status: target.story.status,
+        });
+    }
+    const at = ctx.now().toISOString();
+    lane = await ensureStoryThread(ctx, lane, target.projectId);
+    const before = lane;
+    const next = casUpdateLane(hqRoot, laneId, (current) => updateCarriedStory(current, target.projectId, target.storyId, "done", at, {
+        verified_at: at,
+        verified_by: current.senior,
+    }));
+    await commitStoryTransition(ctx, before, next, target.projectId, target.storyId, "lane_done", "done", { summary: "Senior verification complete" });
+    const finalLane = readLane(hqRoot, laneId);
+    printJson({ ok: true, action: "story.done", lane_id: laneId, project_id: target.projectId, story_id: target.storyId, status: "done", verified: true, story_warning: storyWarning(finalLane) ?? null, lane: finalLane });
+}
 /**
  * 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
@@ -3443,6 +4118,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--mesh-company <slug|uid>", "Explicit Work Mesh company for a personal lane; membership is verified")
         .requiredOption("--project <slug>", "HQ project slug")
         .requiredOption("--story <id>", "Story id from the project's prd.json")
+        .option("--additional-story <id>", "Additional story carried by this lane; repeatable and discouraged when active", collectRepeatable)
         .requiredOption("--brief-file <path>", "Path to the lane brief")
         .option("--worker <name>", "HQ worker id from the registry")
         .option("--provider <name>", "claude | codex | grok")
@@ -3468,6 +4144,14 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (opts) => {
         await runList(ctx, opts);
     }));
+    lanes
+        .command("admit")
+        .description("Try to admit the oldest eligible queued lane")
+        .argument("<lane-id>", "Lane id")
+        .option("--force", "Senior/operator override for provider, account, and profile caps")
+        .action(wrap(async (laneId, opts) => {
+        await runAdmit(ctx, laneId, opts);
+    }));
     lanes
         .command("watch")
         .description("Watch lane state and question changes until all lanes are terminal")
@@ -3489,6 +4173,54 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (laneId) => {
         await runShow(ctx, laneId);
     }));
+    const stories = lanes
+        .command("story")
+        .description("Track several project stories on one lane");
+    stories
+        .command("list")
+        .description("List the stories carried by a lane")
+        .argument("<lane-id>", "Lane id")
+        .action(wrap(async (laneId) => {
+        await runStoryList(ctx, laneId);
+    }));
+    stories
+        .command("add")
+        .description("Add and start another story on a lane")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await runStoryAdd(ctx, laneId, storyId, opts);
+    }));
+    stories
+        .command("start")
+        .description("Start or resume a carried story")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await runStoryStart(ctx, laneId, storyId, opts);
+    }));
+    stories
+        .command("block")
+        .description("Mark one carried story blocked")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .requiredOption("--reason <text>", "Why the story is blocked")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await runStoryBlock(ctx, laneId, storyId, opts);
+    }));
+    stories
+        .command("done")
+        .description("Mark a reviewed story done after senior verification")
+        .argument("<lane-id>", "Lane id")
+        .argument("<story-id>", "Story id")
+        .requiredOption("--verified", "Confirm senior review or merge")
+        .option("--project <slug>", "Project id; defaults to the lane's current project")
+        .action(wrap(async (laneId, storyId, opts) => {
+        await runStoryDone(ctx, laneId, storyId, opts);
+    }));
     lanes
         .command("message")
         .description("Send a follow-up message to a lane")