@indigoai-us/hq-cli 5.147.0 → 5.149.1

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 { 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)) {
@@ -1196,6 +1211,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 +1410,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 +1418,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", {});
     }
@@ -1689,6 +1735,13 @@ 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,
@@ -1771,14 +1824,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 +1857,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 +1955,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 +1966,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) {
@@ -2116,10 +2246,11 @@ async function runList(ctx, opts) {
         .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;
         }
@@ -2222,6 +2353,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 +2416,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
@@ -2317,6 +2453,8 @@ async function prepareAccountMove(ctx, lane, input) {
             const next = {
                 ...current,
                 account: target,
+                provider_session_id: sessionId,
+                provider_session_id_absent: undefined,
                 ...(input.cliModel !== undefined
                     ? { model: input.cliModel, model_source: "cli" }
                     : {}),
@@ -2344,6 +2482,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.
@@ -2413,7 +2556,6 @@ async function runMessage(ctx, laneId, opts) {
         // 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: {
@@ -2433,6 +2575,7 @@ async function runMessage(ctx, laneId, opts) {
             trigger: { kind: "message", text, message_id: messageId },
             compact: opts.compact !== false,
         });
+        archiveResumeMessage(hqRoot, laneId, dropboxMessage);
     }
     // Every accepted message moves the compaction reference forward.
     let next = casUpdateLane(hqRoot, laneId, (current) => ({
@@ -2448,6 +2591,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,
@@ -2493,6 +2648,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 +2665,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 +2701,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", {});
     }
@@ -2618,6 +2804,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,
@@ -2644,9 +2842,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 +3877,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")
@@ -3489,6 +3924,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")