@indigoai-us/hq-cli 5.299.0 → 5.300.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [5.300.0] — 2026-09-30
+- With the default-off hq-flags gate `files.share-empty-prefix-warning`, `hq files share` warns when a granted prefix has no files. A failed or timed-out list check does not block the grant.
+
+- Lane messages and resumes that switch project or story attribution now tell the provider which story is active. Reused completion artifacts no longer close the new story.
+- Make signed-out `hq sync` commands fail fast with `hq login` guidance when stdin or stdout is not a terminal, while keeping browser login in a terminal.
+
 ## [5.299.0] — 2026-09-30
 - Add `hq lanes accounts clear-quota` and clear future quota marks after successful lane turns.
 - On macOS, `hq daemon` retires a loaded legacy mesh LaunchAgent even when its plist is missing, and daemon uninstall boots the job out before deleting its plist. Mesh-owner wait logs now repeat at most every ten minutes.

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

@@ -8509,10 +8509,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Message text";
         }, {
             readonly flags: "--project <slug>";
-            readonly description: "Re-point project attribution from this message";
+            readonly description: "Re-point project attribution; a changed story is named in the resumed prompt";
         }, {
             readonly flags: "--story <id>";
-            readonly description: "Re-point story attribution from this message";
+            readonly description: "Re-point story attribution; a changed story is named in the resumed prompt";
         }, {
             readonly flags: "--account <id>";
             readonly description: "Move the lane's session to this account of its provider before the message resumes it";
@@ -8602,10 +8602,10 @@ export declare const COMMAND_CATALOG: readonly [{
             readonly description: "Required explanation for resuming from failed";
         }, {
             readonly flags: "--project <slug>";
-            readonly description: "Re-point project attribution from this resume";
+            readonly description: "Re-point project attribution; a changed story is named in the resumed prompt";
         }, {
             readonly flags: "--story <id>";
-            readonly description: "Re-point story attribution from this resume";
+            readonly description: "Re-point story attribution; a changed story is named in the resumed prompt";
         }, {
             readonly flags: "--account <id>";
             readonly description: "Move the lane's session to this account of its provider before resuming";

package/dist/command-catalog.generated.js

@@ -10972,11 +10972,11 @@ export const COMMAND_CATALOG = [
                     },
                     {
                         "flags": "--project <slug>",
-                        "description": "Re-point project attribution from this message"
+                        "description": "Re-point project attribution; a changed story is named in the resumed prompt"
                     },
                     {
                         "flags": "--story <id>",
-                        "description": "Re-point story attribution from this message"
+                        "description": "Re-point story attribution; a changed story is named in the resumed prompt"
                     },
                     {
                         "flags": "--account <id>",
@@ -11094,11 +11094,11 @@ export const COMMAND_CATALOG = [
                     },
                     {
                         "flags": "--project <slug>",
-                        "description": "Re-point project attribution from this resume"
+                        "description": "Re-point project attribution; a changed story is named in the resumed prompt"
                     },
                     {
                         "flags": "--story <id>",
-                        "description": "Re-point story attribution from this resume"
+                        "description": "Re-point story attribution; a changed story is named in the resumed prompt"
                     },
                     {
                         "flags": "--account <id>",

package/dist/commands/cloud.js

@@ -53,6 +53,11 @@ export class SyncExitError extends Error {
         this.health = opts.health ?? "failed";
     }
 }
+async function ensureSyncCognitoToken() {
+    return ensureCognitoToken({
+        interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+    });
+}
 /**
  * Preserve the vault's typed write-scope refusal at the CLI boundary. This is
  * deliberately duck-typed so hq-cli remains compatible while hq-cloud and the
@@ -845,11 +850,11 @@ export function registerCloudCommands(program) {
                 }
                 // Upload creds are pre-vended in entityContext, but prefix filtering
                 // still needs vault-service membership/grant resolution.
-                const accessToken = await ensureCognitoToken();
+                const accessToken = await ensureSyncCognitoToken();
                 scopeVaultConfig = buildVaultConfig(accessToken);
             }
             else {
-                const accessToken = await ensureCognitoToken();
+                const accessToken = await ensureSyncCognitoToken();
                 vaultConfig = buildVaultConfig(accessToken);
                 scopeVaultConfig = vaultConfig;
             }
@@ -1064,7 +1069,7 @@ export function registerCloudCommands(program) {
             console.log(chalk.bold("\nHQ Sync — Pull"));
             console.log(`  HQ root:  ${options.hqRoot}`);
             console.log(`  Company:  ${options.company ?? "(from .hq/config.json)"}\n`);
-            const accessToken = await ensureCognitoToken();
+            const accessToken = await ensureSyncCognitoToken();
             const vaultConfig = buildVaultConfig(accessToken);
             // US-011 (2026-05-21 fix): resolve the caller's sync-config for
             // the targeted membership BEFORE the pull, so we can (a) emit the
@@ -1368,7 +1373,7 @@ async function runPullAll(hqRoot, onConflict, modeAllOverride, skipPersonal, for
     console.log("");
     let result;
     try {
-        const accessToken = await ensureCognitoToken();
+        const accessToken = await ensureSyncCognitoToken();
         const vaultConfig = buildVaultConfig(accessToken);
         const realClient = new VaultClient(vaultConfig);
         const adapter = {
@@ -1461,7 +1466,7 @@ export async function runPullPersonal(hqRoot, onConflict) {
     console.log(`  HQ root:  ${hqRoot}`);
     console.log(`  Strategy: ${onConflict ?? "(interactive)"}\n`);
     try {
-        const accessToken = await ensureCognitoToken();
+        const accessToken = await ensureSyncCognitoToken();
         const vaultConfig = buildVaultConfig(accessToken);
         const client = new VaultClient(vaultConfig);
         const personalUid = await resolveCanonicalPersonUid({
@@ -1509,7 +1514,7 @@ async function runPushAll(hqRoot, message, onConflict, skipPersonal) {
     console.log("");
     let result;
     try {
-        const accessToken = await ensureCognitoToken();
+        const accessToken = await ensureSyncCognitoToken();
         const vaultConfig = buildVaultConfig(accessToken);
         const realClient = new VaultClient(vaultConfig);
         const author = resolveUploadAuthor();
@@ -1637,7 +1642,7 @@ async function runNowSingle(hqRoot, company, personal, message, onConflict, mode
     console.log(`  Target:   ${personal ? "(personal)" : (company ?? "(active company)")}`);
     console.log(`  Strategy: ${onConflict ?? "(interactive)"}\n`);
     try {
-        const accessToken = await ensureCognitoToken();
+        const accessToken = await ensureSyncCognitoToken();
         const vaultConfig = buildVaultConfig(accessToken);
         const author = resolveUploadAuthor();
         // Resolve the target. For --personal, look up the canonical person and

package/dist/commands/files.d.ts

@@ -1,4 +1,5 @@
 import { Command } from "commander";
+export declare const FILES_SHARE_EMPTY_PREFIX_WARNING_FLAG = "files.share-empty-prefix-warning";
 /**
  * Parse a human-friendly duration string ("15m", "1h", "24h", "2d") into
  * milliseconds. Returns null on parse failure. Mirrors the parser used in

package/dist/commands/files.js

@@ -12,7 +12,10 @@ import { fetchChannels, matchChannelsByName } from "./dm.js";
 import { resolveCompanySlug, resolvePersonWithRosterFallback, } from "./people.js";
 import { findHqRoot } from "../utils/manifest.js";
 import { maxLength } from "../utils/table-width.js";
+import { resolveCompanyFlagGate } from "../lib/flag-registry.js";
 const PERSON_UID_PATTERN = /^(prs|agt)_[A-Za-z0-9_-]+$/;
+export const FILES_SHARE_EMPTY_PREFIX_WARNING_FLAG = "files.share-empty-prefix-warning";
+const FILES_SHARE_EMPTY_PREFIX_CHECK_TIMEOUT_MS = 5_000;
 function collectMentions(value, previous) {
     return [...previous, value];
 }
@@ -589,6 +592,56 @@ export function registerFilesCommand(program) {
     // files-browse.ts) onto the same group without re-creating it.
     return files;
 }
+/** Best-effort, default-off warning after the ACL grant has succeeded. */
+async function warnIfEmptySharePrefix(params) {
+    if (isPrivateFolderPattern(params.prefix))
+        return;
+    let enabled;
+    try {
+        enabled = await resolveCompanyFlagGate(params.companyUid, params.token, FILES_SHARE_EMPTY_PREFIX_WARNING_FLAG, { fallback: false }, () => false);
+    }
+    catch (error) {
+        const errorClass = error instanceof Error ? error.name : "unknown error";
+        console.error(`hq: Could not resolve ${FILES_SHARE_EMPTY_PREFIX_WARNING_FLAG} (${errorClass}); using its fallback.`);
+        return;
+    }
+    if (!enabled)
+        return;
+    const listPrefix = params.fullVault
+        ? ""
+        : params.prefix.endsWith("*")
+            ? params.prefix.slice(0, -1)
+            : params.prefix;
+    try {
+        const query = {
+            company: params.companyUid,
+        };
+        if (listPrefix)
+            query.prefix = listPrefix;
+        const listed = await vaultApiFetch({
+            token: params.token,
+            path: "/v1/files/list",
+            query,
+            signal: AbortSignal.timeout(FILES_SHARE_EMPTY_PREFIX_CHECK_TIMEOUT_MS),
+        });
+        if (!listed.ok)
+            throw new Error(`files list failed (${listed.status})`);
+        const body = (await listed.json());
+        const objects = Array.isArray(body.objects) ? body.objects : [];
+        const hasMatchingObject = params.fullVault || params.prefix.endsWith("*")
+            ? objects.length > 0
+            : objects.some((object) => object.key === listPrefix);
+        if (!hasMatchingObject) {
+            console.warn(chalk.yellow(`Warning: no files exist under '${displayAclPattern(params.prefix)}'. ` +
+                `The recipient will see nothing until files sync there.`));
+        }
+    }
+    catch (error) {
+        const errorClass = error instanceof Error ? error.name : "unknown error";
+        console.warn(chalk.yellow(`Could not check whether '${displayAclPattern(params.prefix)}' has files; ` +
+            `the share succeeded (${errorClass}).`));
+    }
+}
 async function resolveShareChannelTarget(params) {
     const token = (await resolveVaultCredential()).token;
     const channels = await fetchChannels(token);
@@ -757,6 +810,12 @@ async function runDirectGrant(params) {
     }
     const data = (await res.json());
     const printedPrefix = data.acl?.path ?? data.acl?.prefix ?? canonicalPrefix;
+    await warnIfEmptySharePrefix({
+        token,
+        companyUid,
+        prefix: canonicalPrefix,
+        fullVault: params.fullVault === true,
+    });
     const verb = autoCreated ? "Created ACL and granted" : "Granted";
     if (params.fullVault) {
         console.log(chalk.green(`${verb} ${params.permission} on the ENTIRE vault to ${principalLabel}`));

package/dist/commands/lanes-message.js

@@ -8,6 +8,7 @@ import { dispatchLaneDelivery } from "../lib/lanes/delivery-core.js";
 import { dropboxInboxHasMessages, drainDropbox, formatDropboxMessages, formatMonitorEvent, requeueDropboxMessages } from "../lib/lanes/dropbox.js";
 import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, writeWatcherDecision } from "../lib/lanes/watcher.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
+import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice } from "../lib/lanes/story-switch.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
@@ -212,8 +213,11 @@ export function createLaneMessageHandlers(deps) {
             })();
         let accepted = false;
         let claimedMessages = [];
+        let storySwitchRollback;
+        let storySwitchDeliveryStarted = false;
         const markAccepted = () => {
             accepted = true;
+            storySwitchDeliveryStarted = true;
             opts.onAccepted?.();
         };
         let text = opts.text;
@@ -392,19 +396,21 @@ export function createLaneMessageHandlers(deps) {
             if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
                 validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
             }
+            const notice = storySwitchNotice(lane.project_id, lane.story_id, projectId, storyId);
+            const promptedText = notice === undefined ? text : `${notice}\n\n${text}`;
             const framedMonitorEvent = opts.monitorEvent === undefined
                 ? undefined
                 : formatMonitorEvent({
                     monitorId: opts.monitorEvent.monitor_id,
                     description: opts.monitorEvent.description,
                     sequence: opts.monitorEvent.sequence,
-                    text,
+                    text: promptedText,
                 });
-            const deliveryText = framedMonitorEvent ?? text;
+            const deliveryText = framedMonitorEvent ?? promptedText;
             const dropboxMessage = {
                 at,
                 message_id: messageId,
-                text,
+                text: promptedText,
                 project_id: projectId,
                 story_id: storyId,
                 ...(opts.monitorEvent === undefined ? {} : {
@@ -414,6 +420,52 @@ export function createLaneMessageHandlers(deps) {
                     sequence: opts.monitorEvent.sequence,
                 }),
             };
+            if (projectId !== lane.project_id || storyId !== lane.story_id) {
+                lane = casUpdateLane(hqRoot, laneId, (current) => {
+                    const already = current.attribution_history.some((entry) => entry.message_id === messageId);
+                    if (already)
+                        return current;
+                    const existingStory = laneStory(current, projectId, storyId);
+                    storySwitchRollback = {
+                        message_id: messageId,
+                        project_id: current.project_id,
+                        story_id: current.story_id,
+                        no_story_reason: current.no_story_reason,
+                        ...(!existingStory ? {
+                            added_story: { project_id: projectId, story_id: storyId, status: "in_progress", added_at: at, updated_at: at },
+                        } : {}),
+                        story_switch_unacknowledged: current.story_switch_unacknowledged,
+                    };
+                    return {
+                        ...current,
+                        project_id: projectId,
+                        story_id: storyId,
+                        no_story_reason: storyId ? undefined : current.no_story_reason,
+                        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,
+                            message_id: messageId,
+                            at,
+                        }),
+                        story_switch_pending: {
+                            previous_project_id: current.project_id,
+                            previous_story_id: current.story_id,
+                            project_id: projectId,
+                            story_id: storyId,
+                            message_id: messageId,
+                            at,
+                            previous_artifact_keys: artifactIdentityKeys(current.last_envelope?.artifacts),
+                        },
+                        story_switch_unacknowledged: undefined,
+                    };
+                });
+            }
             let resumed = null;
             let move = null;
             let queuedOnAdmission = false;
@@ -491,6 +543,7 @@ export function createLaneMessageHandlers(deps) {
                             throw new LanesError("lane_not_accepting_messages", operatorMessageRefusalReason(lane.state), { lane_id: laneId, state: lane.state });
                         }
                         appendDropboxMessage(hqRoot, laneId, dropboxMessage);
+                        storySwitchDeliveryStarted = true;
                         return null;
                     },
                     resume: async () => {
@@ -565,6 +618,8 @@ export function createLaneMessageHandlers(deps) {
                                     compact: opts.compact !== false,
                                     effort: resumeEffort ?? recordedResumeEffort(lane),
                                 });
+                                storySwitchDeliveryStarted = true;
+                                deps.onLaneWorkerStarted?.(laneId, "message");
                                 archiveResumeMessage(hqRoot, laneId, dropboxMessage);
                                 return started;
                             }, hireGrantContext);
@@ -576,41 +631,10 @@ export function createLaneMessageHandlers(deps) {
                 markAccepted();
             }
             // Every accepted message moves the compaction reference forward.
-            let next = casUpdateLane(hqRoot, laneId, (current) => ({
+            const next = casUpdateLane(hqRoot, laneId, (current) => ({
                 ...resetKeepAliveProgress(current),
                 last_message_at: at,
             }));
-            if (projectId !== lane.project_id || storyId !== lane.story_id) {
-                next = casUpdateLane(hqRoot, laneId, (current) => {
-                    const already = current.attribution_history.some((entry) => entry.message_id === messageId);
-                    if (already)
-                        return current;
-                    return {
-                        ...current,
-                        project_id: projectId,
-                        story_id: storyId,
-                        no_story_reason: storyId ? undefined : current.no_story_reason,
-                        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,
-                            message_id: messageId,
-                            at,
-                        }),
-                    };
-                });
-            }
             // What this command can claim when it returns: the message is durably
             // written (accepted). Delivery to the model is asynchronous in both
             // mechanisms. `dropbox` delivers on the worker's next tool call, and only
@@ -660,6 +684,15 @@ export function createLaneMessageHandlers(deps) {
                 });
         }
         catch (err) {
+            if (storySwitchRollback !== undefined && !storySwitchDeliveryStarted) {
+                try {
+                    casUpdateLane(hqRoot, laneId, (current) => rollbackStorySwitchAttribution(current, storySwitchRollback));
+                }
+                catch (rollbackErr) {
+                    const rollbackMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+                    process.stderr.write(`Could not roll back story attribution after message failure: ${rollbackMessage}\n`);
+                }
+            }
             if (claimedMessages.length > 0 && !accepted) {
                 const error = err instanceof Error ? err.message : String(err);
                 writeWatcherDecision(watcherOutLogPath(hqRoot, laneId), {

package/dist/commands/lanes-resume.js

@@ -5,6 +5,7 @@ import { parseCliEffort } from "../lib/lanes/effort.js";
 import { parseOutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
+import { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice } from "../lib/lanes/story-switch.js";
 import { spawnLaneWorker } from "../lib/lanes/spawn.js";
 import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, hasKeepAliveProgress, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneResumeHandlers(deps) {
@@ -195,6 +196,8 @@ export function createLaneResumeHandlers(deps) {
         }
         const attributionChanged = projectId !== lane.project_id || storyId !== lane.story_id;
         const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
+        const notice = storySwitchNotice(lane.project_id, lane.story_id, projectId, storyId);
+        const deliveryText = notice === undefined ? text : `${notice}${text === undefined ? "" : `\n\n${text}`}`;
         let requestedMeshCompany;
         let meshThreadId;
         if (opts.meshCompany !== undefined) {
@@ -253,41 +256,60 @@ export function createLaneResumeHandlers(deps) {
             account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
             model: opts.model,
         });
-        let move = null;
-        if (opts.account !== undefined && !keepCurrentAccount) {
-            move = await prepareAccountMove(ctx, lane, {
-                account: opts.account,
-                cliModel: opts.model?.trim() || undefined,
-                ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
-                ...(profileRepin !== undefined ? { profileRepin } : {}),
-                ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-                ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                pending: {
-                    trigger: "resume",
-                    resumed_from: resumedFrom,
-                    ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                    ...(failedResumeExpectedSenior !== undefined
-                        ? { expected_senior: failedResumeExpectedSenior }
-                        : {}),
-                    ...(text !== undefined ? { text } : {}),
-                    ...(messageId !== undefined ? { message_id: messageId } : {}),
-                    compact: opts.compact !== false,
-                },
+        let storySwitchRollback;
+        let storySwitchWorkerStarted = false;
+        if (messageId !== undefined && attributionChanged) {
+            lane = casUpdateLane(hqRoot, laneId, (current) => {
+                const already = current.attribution_history.some((entry) => entry.message_id === messageId);
+                if (already)
+                    return current;
+                const existingStory = laneStory(current, projectId, storyId);
+                storySwitchRollback = {
+                    message_id: messageId,
+                    project_id: current.project_id,
+                    story_id: current.story_id,
+                    no_story_reason: current.no_story_reason,
+                    ...(!existingStory ? {
+                        added_story: { project_id: projectId, story_id: storyId, status: "in_progress", added_at: at, updated_at: at },
+                    } : {}),
+                    story_switch_unacknowledged: current.story_switch_unacknowledged,
+                };
+                return {
+                    ...current,
+                    project_id: projectId,
+                    story_id: storyId,
+                    no_story_reason: storyId ? undefined : current.no_story_reason,
+                    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,
+                        message_id: messageId,
+                        at,
+                    }),
+                    story_switch_pending: {
+                        previous_project_id: current.project_id,
+                        previous_story_id: current.story_id,
+                        project_id: projectId,
+                        story_id: storyId,
+                        message_id: messageId,
+                        at,
+                        previous_artifact_keys: artifactIdentityKeys(current.last_envelope?.artifacts),
+                    },
+                    story_switch_unacknowledged: undefined,
+                };
             });
-            lane = move.lane;
         }
-        else if (automaticAccountSelection !== undefined) {
-            const selection = automaticAccountSelection.selection;
-            if (selection.account !== lane.account) {
+        try {
+            let move = null;
+            if (opts.account !== undefined && !keepCurrentAccount) {
                 move = await prepareAccountMove(ctx, lane, {
-                    account: selection.account,
-                    cliModel: undefined,
-                    ...(automaticAccountSelection.historyReason !== undefined
-                        ? { accountHistoryReason: automaticAccountSelection.historyReason }
-                        : {}),
-                    ...(automaticAccountSelection.preservedModel !== undefined
-                        ? { preservedModel: automaticAccountSelection.preservedModel }
-                        : {}),
+                    account: opts.account,
+                    cliModel: opts.model?.trim() || undefined,
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
@@ -299,204 +321,219 @@ export function createLaneResumeHandlers(deps) {
                         ...(failedResumeExpectedSenior !== undefined
                             ? { expected_senior: failedResumeExpectedSenior }
                             : {}),
-                        ...(text !== undefined ? { text } : {}),
+                        ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                         ...(messageId !== undefined ? { message_id: messageId } : {}),
                         compact: opts.compact !== false,
                     },
-                    accountSelection: selection,
                 });
                 lane = move.lane;
             }
-            else {
-                lane = persistClaudeAccountSelection(hqRoot, lane, selection);
-            }
-        }
-        lane = recordResumeSetup(ctx, lane, {
-            ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
-            ...(move === null && profileRepin !== undefined ? { profileRepin } : {}),
-            ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
-            ...(keepAlive !== undefined ? { keepAlive } : {}),
-            ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
-            ...(requestedMeshCompany !== undefined
-                ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
-                : {}),
-        });
-        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;
-                return withResumeHireAdmission(ctx, lane, () => {
-                    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_details: undefined,
-                                queued_at: at,
-                                pending_resume: {
-                                    session_id: sessionId,
-                                    trigger: "resume",
-                                    caller: ctx.env.HQ_LANE_ID?.trim() || "user",
-                                    resumed_from: resumedFrom,
-                                    ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                                    ...(failedResumeExpectedSenior !== undefined
-                                        ? { expected_senior: failedResumeExpectedSenior }
-                                        : {}),
-                                    ...(text !== undefined ? { text } : {}),
-                                    ...(messageId !== undefined ? { message_id: messageId } : {}),
-                                    compact: opts.compact !== false,
-                                    at,
-                                },
-                            };
-                        });
-                    }
-                    return 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,
-                    }, {
-                        trigger: {
-                            kind: "resume",
-                            from: resumedFrom,
-                            ...(opts.fromFailed === true ? { fromFailed: true } : {}),
+            else if (automaticAccountSelection !== undefined) {
+                const selection = automaticAccountSelection.selection;
+                if (selection.account !== lane.account) {
+                    move = await prepareAccountMove(ctx, lane, {
+                        account: selection.account,
+                        cliModel: undefined,
+                        ...(automaticAccountSelection.historyReason !== undefined
+                            ? { accountHistoryReason: automaticAccountSelection.historyReason }
+                            : {}),
+                        ...(automaticAccountSelection.preservedModel !== undefined
+                            ? { preservedModel: automaticAccountSelection.preservedModel }
+                            : {}),
+                        ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                        ...(profileRepin !== undefined ? { profileRepin } : {}),
+                        ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                        ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
+                        pending: {
+                            trigger: "resume",
+                            resumed_from: resumedFrom,
+                            ...(opts.fromFailed === true ? { from_failed: true } : {}),
                             ...(failedResumeExpectedSenior !== undefined
-                                ? { expectedSenior: failedResumeExpectedSenior }
+                                ? { expected_senior: failedResumeExpectedSenior }
                                 : {}),
-                            ...(text !== undefined ? { text } : {}),
+                            ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                             ...(messageId !== undefined ? { message_id: messageId } : {}),
+                            compact: opts.compact !== false,
                         },
-                        compact: opts.compact !== false,
-                        effort: resumeEffort ?? recordedResumeEffort(lane),
+                        accountSelection: selection,
                     });
-                }, hireGrantContext);
-            }, 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.
-            archiveResumeMessage(hqRoot, laneId, {
-                at,
-                message_id: messageId,
-                text,
-                project_id: projectId,
-                story_id: storyId,
-                resumed_from: resumedFrom,
+                    lane = move.lane;
+                }
+                else {
+                    lane = persistClaudeAccountSelection(hqRoot, lane, selection);
+                }
+            }
+            lane = recordResumeSetup(ctx, lane, {
+                ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+                ...(move === null && profileRepin !== undefined ? { profileRepin } : {}),
+                ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                ...(keepAlive !== undefined ? { keepAlive } : {}),
+                ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
+                ...(requestedMeshCompany !== undefined
+                    ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
+                    : {}),
             });
-        }
-        let next = resumed;
-        if (failedResumeActor !== undefined &&
-            failedResumeReason !== undefined &&
-            recoveredFailure !== undefined) {
-            next = casUpdateLane(hqRoot, laneId, (current) => ({
-                ...current,
-                failed_resume_history: appendCappedHistory(current.failed_resume_history ?? [], {
+            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;
+                    return withResumeHireAdmission(ctx, lane, () => {
+                        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_details: undefined,
+                                    queued_at: at,
+                                    pending_resume: {
+                                        session_id: sessionId,
+                                        trigger: "resume",
+                                        caller: ctx.env.HQ_LANE_ID?.trim() || "user",
+                                        resumed_from: resumedFrom,
+                                        ...(opts.fromFailed === true ? { from_failed: true } : {}),
+                                        ...(failedResumeExpectedSenior !== undefined
+                                            ? { expected_senior: failedResumeExpectedSenior }
+                                            : {}),
+                                        ...(deliveryText !== undefined ? { text: deliveryText } : {}),
+                                        ...(messageId !== undefined ? { message_id: messageId } : {}),
+                                        compact: opts.compact !== false,
+                                        at,
+                                    },
+                                };
+                            });
+                        }
+                        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,
+                        }, {
+                            trigger: {
+                                kind: "resume",
+                                from: resumedFrom,
+                                ...(opts.fromFailed === true ? { fromFailed: true } : {}),
+                                ...(failedResumeExpectedSenior !== undefined
+                                    ? { expectedSenior: failedResumeExpectedSenior }
+                                    : {}),
+                                ...(deliveryText !== undefined ? { text: deliveryText } : {}),
+                                ...(messageId !== undefined ? { message_id: messageId } : {}),
+                            },
+                            compact: opts.compact !== false,
+                            effort: resumeEffort ?? recordedResumeEffort(lane),
+                        });
+                        storySwitchWorkerStarted = true;
+                        deps.onLaneWorkerStarted?.(laneId, "resume");
+                        return started;
+                    }, hireGrantContext);
+                }, ctx.sleep);
+            }
+            if (deliveryText !== undefined && messageId !== undefined) {
+                // Same audit copy a message resume leaves; nothing drains it. Archive only
+                // after a successful spawn so a concurrent resume cannot leave a phantom.
+                archiveResumeMessage(hqRoot, laneId, {
                     at,
-                    actor: failedResumeActor,
-                    reason: failedResumeReason,
-                    failure: recoveredFailure,
-                }),
-            }));
-        }
-        if (text !== undefined) {
-            // An operator text moves the compaction reference forward, as a message does.
-            next = casUpdateLane(hqRoot, laneId, (current) => ({
-                ...resetKeepAliveProgress(current),
-                last_message_at: at,
-            }));
-        }
-        if (messageId !== undefined && attributionChanged) {
-            next = casUpdateLane(hqRoot, laneId, (current) => {
-                const already = current.attribution_history.some((entry) => entry.message_id === messageId);
-                if (already)
-                    return current;
-                return {
-                    ...current,
+                    message_id: messageId,
+                    text: deliveryText,
                     project_id: projectId,
                     story_id: storyId,
-                    no_story_reason: storyId ? undefined : current.no_story_reason,
-                    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,
-                        message_id: messageId,
+                    resumed_from: resumedFrom,
+                });
+            }
+            let next = resumed;
+            if (failedResumeActor !== undefined &&
+                failedResumeReason !== undefined &&
+                recoveredFailure !== undefined) {
+                next = casUpdateLane(hqRoot, laneId, (current) => ({
+                    ...current,
+                    failed_resume_history: appendCappedHistory(current.failed_resume_history ?? [], {
                         at,
+                        actor: failedResumeActor,
+                        reason: failedResumeReason,
+                        failure: recoveredFailure,
                     }),
-                };
+                }));
+            }
+            if (deliveryText !== undefined) {
+                // An operator text moves the compaction reference forward, as a message does.
+                next = casUpdateLane(hqRoot, laneId, (current) => ({
+                    ...resetKeepAliveProgress(current),
+                    last_message_at: at,
+                }));
+            }
+            if (text === undefined && hasKeepAliveProgress(next)) {
+                next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
+            }
+            printJson({
+                ok: true,
+                action: "resume",
+                lane_id: laneId,
+                resumed_from: resumedFrom,
+                message_id: messageId ?? null,
+                text: text ?? null,
+                delivery: "resume",
+                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,
+                compaction: resumed.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
+                    ? resumed.last_compaction
+                    : null,
+                project_id: next.project_id,
+                story_id: next.story_id,
+                stories: laneStories(next),
+                story_warning: storyWarning(next) ?? null,
+                lane: next,
             });
         }
-        if (text === undefined && hasKeepAliveProgress(next)) {
-            next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
+        catch (err) {
+            if (storySwitchRollback !== undefined && !storySwitchWorkerStarted) {
+                try {
+                    casUpdateLane(hqRoot, laneId, (current) => rollbackStorySwitchAttribution(current, storySwitchRollback));
+                }
+                catch (rollbackErr) {
+                    const rollbackMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
+                    process.stderr.write(`Could not roll back story attribution after resume failure: ${rollbackMessage}\n`);
+                }
+            }
+            throw err;
         }
-        printJson({
-            ok: true,
-            action: "resume",
-            lane_id: laneId,
-            resumed_from: resumedFrom,
-            message_id: messageId ?? null,
-            text: text ?? null,
-            delivery: "resume",
-            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,
-            compaction: resumed.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
-                ? resumed.last_compaction
-                : null,
-            project_id: next.project_id,
-            story_id: next.story_id,
-            stories: laneStories(next),
-            story_warning: storyWarning(next) ?? null,
-            lane: next,
-        });
     }
     return { runClaudeBalanceMoveTarget, runResume };
 }

package/dist/commands/lanes-shared.d.ts

@@ -144,6 +144,8 @@ export interface OutpostLaneDispatchBehavior {
     expectedOwnerHost?: LaneRecord["host"];
 }
 export interface LaneMessageHandlerDeps {
+    /** Test seam invoked after a provider worker has been started. */
+    onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
     archiveResumeMessage(hqRoot: string, laneId: string, message: {
         message_id: string;
         [key: string]: unknown;
@@ -184,7 +186,7 @@ export interface LaneMessageHandlerDeps {
     validateResumeProfileModel(ctx: Ctx, lane: LaneRecord, profile: WorkerProfile): void;
     withResumeHireAdmission<T>(ctx: Ctx, lane: LaneRecord, fn: () => T, grantContext?: OutpostHireGrantContext): Promise<T>;
 }
-export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
+export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "onLaneWorkerStarted" | "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
     dispatchOutpostLaneCommand(ctx: Ctx, lane: LaneRecord, action: "resume", options: LaneResumeOptions, behavior?: OutpostLaneDispatchBehavior): Promise<void>;
     authorizeFailedResume(ctx: Ctx, lane: LaneRecord, encodedContext?: string): string;
     authorizeResumeProfileRepin(ctx: Ctx, lane: LaneRecord, profile: ResolvedResumeProfile | undefined, encodedContext: string | undefined): ResumeProfileRepinAuthorization | undefined;

package/dist/commands/lanes.d.ts

@@ -29,6 +29,8 @@ export declare const LANE_REMOTE_MIRROR_SYNC_FLAG = "lanes.remote-done-mirror";
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
 export interface LanesCommandDeps {
+    /** Test seam for failures after a lane provider worker is started. */
+    onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
     hqRoot?: () => string;
     /** Start HQ-root walk here instead of process.cwd(). Tests only. */
     cwd?: () => string;

package/dist/commands/lanes.js

@@ -7837,6 +7837,7 @@ export function registerLanesCommand(parent, deps = {}) {
         writeAnswerDeliveryFailed,
     });
     const messageHandlerDeps = {
+        onLaneWorkerStarted: deps.onLaneWorkerStarted,
         archiveResumeMessage,
         assertLaneRunsHereForAdmission,
         assertLaneRunsHereForOperatorMutation,
@@ -7862,6 +7863,7 @@ export function registerLanesCommand(parent, deps = {}) {
     };
     const messageHandlers = createLaneMessageHandlers(messageHandlerDeps);
     const resumeHandlers = createLaneResumeHandlers({
+        onLaneWorkerStarted: deps.onLaneWorkerStarted,
         archiveResumeMessage,
         assertLaneRunsHereForAdmission,
         assertLaneRunsHereForOperatorMutation,
@@ -8214,8 +8216,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("Send a follow-up message to a lane")
         .argument("<lane-id>", "Lane id")
         .requiredOption("--text <msg>", "Message text")
-        .option("--project <slug>", "Re-point project attribution from this message")
-        .option("--story <id>", "Re-point story attribution from this message")
+        .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
+        .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
         .option("--account <id>", "Move the lane's session to this account of its provider before the message resumes it")
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")
@@ -8292,8 +8294,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--text <msg>", "Operator message for the resumed turn")
         .option("--from-failed", "Explicitly resume a failed lane as its senior")
         .option("--reason <text>", "Required explanation for resuming from failed")
-        .option("--project <slug>", "Re-point project attribution from this resume")
-        .option("--story <id>", "Re-point story attribution from this resume")
+        .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
+        .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
         .option("--account <id>", "Move the lane's session to this account of its provider before resuming")
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")

package/dist/lib/lanes/reconcile.js

@@ -32,6 +32,7 @@ import { answeredQuestionEntries, questionRecordRefusalCode, raiseEnvelopeQuesti
 import { SILENCE_MS, appendWatcherEvent, classifyLaneExit, isPidAlive, missingExpectedEnvelopeFile, readLatestEnvelopeFile, readLatestEnvelopeRecord, watcherEventsPath, watcherOutLogPath, writeWatcherDecision, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
 import { activeLaneStories, laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
+import { applyStorySwitchEnvelope } from "./story-switch.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { PROVIDER_REJECTED_REASON, providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -1271,11 +1272,28 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     }
                     if (terminalEnvelope && latest) {
                         const envelope = terminalEnvelope;
-                        const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+                        next.last_envelope = {
+                            ref: latest.ref,
+                            decision: envelope.decision,
+                            at: nowIso,
+                            artifacts: envelope.artifacts,
+                            ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
+                        };
+                        const storySwitch = applyStorySwitchEnvelope(current, envelope, nowIso, latest.ref);
+                        if (storySwitch.clearPending) {
+                            next.story_switch_pending = undefined;
+                        }
+                        if (storySwitch.storySwitchUnacknowledged !== undefined) {
+                            next.story_switch_unacknowledged = storySwitch.storySwitchUnacknowledged;
+                            next.attribution_history = storySwitch.attributionHistory ?? current.attribution_history;
+                        }
+                        const storyStatus = storySwitch.suppressCompletion
+                            ? "in_progress"
+                            : terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
                         if (storyStatus !== undefined) {
-                            next.story_status = envelope.story_status;
-                            next.story_complete = envelope.story_complete;
-                            next.story_complete_reason = envelope.story_complete_reason;
+                            next.story_status = storySwitch.suppressCompletion ? "in_progress" : envelope.story_status;
+                            next.story_complete = storySwitch.suppressCompletion ? false : envelope.story_complete;
+                            next.story_complete_reason = storySwitch.suppressCompletion ? undefined : envelope.story_complete_reason;
                             next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
                                 ? {
                                     ...story,

package/dist/lib/lanes/story-switch.d.ts

@@ -0,0 +1,21 @@
+import type { AttributionHistoryEntry, LaneEnvelope, LaneRecord, StorySwitchUnacknowledgedNote } from "./types.js";
+export declare function storySwitchNotice(previousProjectId: string, previousStoryId: string, projectId: string, storyId: string): string | undefined;
+export declare function artifactIdentityKeys(artifacts: readonly unknown[] | undefined): string[];
+export interface StorySwitchRollbackSnapshot {
+    message_id: string;
+    project_id: string;
+    story_id: string;
+    no_story_reason?: string;
+    added_story?: NonNullable<LaneRecord["stories"]>[number];
+    story_switch_unacknowledged: StorySwitchUnacknowledgedNote | undefined;
+}
+/** Restore only the attribution write owned by this failed command attempt. */
+export declare function rollbackStorySwitchAttribution(current: LaneRecord, snapshot: StorySwitchRollbackSnapshot): LaneRecord;
+/** Apply and consume one attribution-switch marker when the next envelope arrives. */
+export declare function applyStorySwitchEnvelope(lane: LaneRecord, envelope: LaneEnvelope, at: string, envelopeRef: string): {
+    suppressCompletion: boolean;
+    clearPending: boolean;
+    storySwitchUnacknowledged?: StorySwitchUnacknowledgedNote;
+    attributionHistory?: AttributionHistoryEntry[];
+};
+//# sourceMappingURL=story-switch.d.ts.map

package/dist/lib/lanes/story-switch.js

@@ -0,0 +1,75 @@
+export function storySwitchNotice(previousProjectId, previousStoryId, projectId, storyId) {
+    if (previousProjectId === projectId && previousStoryId === storyId)
+        return undefined;
+    const from = `${previousProjectId}/${previousStoryId || "(no story)"}`;
+    const to = `${projectId}/${storyId || "(no story)"}`;
+    return `Story changed: ${from} -> ${to}. The previous story is closed; report only on the new story in this turn's envelope.`;
+}
+export function artifactIdentityKeys(artifacts) {
+    if (!Array.isArray(artifacts))
+        return [];
+    return artifacts.flatMap((artifact) => {
+        if (typeof artifact === "string" && artifact.trim())
+            return [`value:${artifact.trim()}`];
+        if (artifact === null || typeof artifact !== "object" || Array.isArray(artifact))
+            return [];
+        const record = artifact;
+        const url = typeof record.url === "string" ? record.url.trim() : "";
+        const path = typeof record.path === "string" ? record.path.trim() : "";
+        const values = [url && `url:${url}`, path && `path:${path}`].filter((value) => Boolean(value));
+        return values;
+    }).sort();
+}
+/** Restore only the attribution write owned by this failed command attempt. */
+export function rollbackStorySwitchAttribution(current, snapshot) {
+    if (current.story_switch_pending?.message_id !== snapshot.message_id)
+        return current;
+    const addedStory = snapshot.added_story;
+    const stories = (current.stories ?? []).filter((story) => !(addedStory && story.project_id === addedStory.project_id && story.story_id === addedStory.story_id &&
+        story.added_at === addedStory.added_at));
+    return {
+        ...current,
+        project_id: snapshot.project_id,
+        story_id: snapshot.story_id,
+        no_story_reason: snapshot.no_story_reason,
+        stories,
+        attribution_history: current.attribution_history.filter((entry) => entry.message_id !== snapshot.message_id),
+        story_switch_pending: undefined,
+        story_switch_unacknowledged: snapshot.story_switch_unacknowledged,
+    };
+}
+function sameKeys(left, right) {
+    return left.length > 0 && left.length === right.length && left.every((key, index) => key === right[index]);
+}
+/** Apply and consume one attribution-switch marker when the next envelope arrives. */
+export function applyStorySwitchEnvelope(lane, envelope, at, envelopeRef) {
+    const pending = lane.story_switch_pending;
+    if (!pending)
+        return { suppressCompletion: false, clearPending: false };
+    if (envelope.story_complete !== true)
+        return { suppressCompletion: false, clearPending: false };
+    const currentKeys = artifactIdentityKeys(envelope.artifacts);
+    const suppressCompletion = sameKeys(pending.previous_artifact_keys, currentKeys);
+    if (!suppressCompletion)
+        return { suppressCompletion: false, clearPending: true };
+    const note = {
+        event: "story_switch_unacknowledged",
+        previous_project_id: pending.previous_project_id,
+        previous_story_id: pending.previous_story_id,
+        project_id: pending.project_id,
+        story_id: pending.story_id,
+        message_id: pending.message_id,
+        envelope_ref: envelopeRef,
+        at,
+        artifact_keys: currentKeys,
+    };
+    return {
+        suppressCompletion: true,
+        clearPending: true,
+        storySwitchUnacknowledged: note,
+        attributionHistory: lane.attribution_history.map((entry) => entry.message_id === pending.message_id
+            ? { ...entry, story_switch_unacknowledged: note }
+            : entry),
+    };
+}
+//# sourceMappingURL=story-switch.js.map

package/dist/lib/lanes/types.d.ts

@@ -351,6 +351,27 @@ export interface AttributionHistoryEntry {
     story_id: string;
     message_id: string;
     at: string;
+    story_switch_unacknowledged?: StorySwitchUnacknowledgedNote;
+}
+export interface StorySwitchPending {
+    previous_project_id: string;
+    previous_story_id: string;
+    project_id: string;
+    story_id: string;
+    message_id: string;
+    at: string;
+    previous_artifact_keys: string[];
+}
+export interface StorySwitchUnacknowledgedNote {
+    event: "story_switch_unacknowledged";
+    previous_project_id: string;
+    previous_story_id: string;
+    project_id: string;
+    story_id: string;
+    message_id: string;
+    envelope_ref: string;
+    at: string;
+    artifact_keys: string[];
 }
 export interface LastEnvelopeRef {
     ref: string;
@@ -573,6 +594,10 @@ export interface LaneRecord {
     envelope_summary?: string;
     attribution_history: AttributionHistoryEntry[];
     last_envelope?: LastEnvelopeRef;
+    /** Pending attribution change, consumed by the next terminal envelope. */
+    story_switch_pending?: StorySwitchPending;
+    /** Last completion suppressed because the new story repeated prior evidence. */
+    story_switch_unacknowledged?: StorySwitchUnacknowledgedNote;
     /** Effective model id recorded at create/spawn. Omitted when the provider chooses. */
     model?: string;
     /** Where the effective model came from; repaired models stay pinned across the account move. */

package/dist/lib/lanes/types.js

@@ -227,7 +227,7 @@ export const LANE_FIELD_WRITERS = {
     priority: ["command"], worker: ["creator", "command"], worker_path: ["creator", "command"], worker_pack: ["creator", "command"], worker_profile: ["creator", "command"], worker_profile_hash: ["creator", "command", "spawn"], registry_worker: ["creator", "command", "spawn"], registry_worker_approval_history: ["command", "watcher", "reconcile"], worker_profile_repin_history: ["command"], worker_profile_ignored: ["creator", "command", "spawn"], worker_policy_delivery: ["command", "spawn"],
     keep_alive: ["creator", "command"], keep_alive_standing: ["command"], keep_alive_opted_in_at: ["creator", "command"], keep_alive_blocked_reason: ["command", "reconcile"], keep_alive_resume_count: ["command", "reconcile"], keep_alive_history: ["reconcile"], keep_alive_blocked_resume_streak: ["reconcile", "spawn", "watcher"], keep_alive_last_resume_at: ["command", "reconcile"], keep_alive_next_eligible_at: ["command", "reconcile"], keep_alive_exhausted_at: ["command", "reconcile"],
     provider: ["creator"], account: ["creator", "spawn", "command", "watcher", "reconcile"], account_selection: ["creator", "command"], admission_accounts: ["creator", "command"], account_history: ["command", "spawn", "watcher", "reconcile"], failed_resume_history: ["command"], pending_resume: ["command", "spawn", "watcher", "reconcile"], placement_default: ["creator"], host: ["creator", "command"], origin_host: ["creator"], origin_host_source: ["creator"],
-    version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command"],
+    version: ["creator"], created_at: ["creator"], updated_at: ["creator"], ended_at: ["reconcile"], envelope_summary: ["reconcile"], attribution_history: ["command", "watcher", "reconcile"], story_switch_pending: ["command", "watcher", "reconcile"], story_switch_unacknowledged: ["watcher", "reconcile"],
     last_envelope: ["watcher", "reconcile"], model: ["creator", "spawn", "command"], model_source: ["creator", "spawn", "command"], effort: ["creator", "spawn", "command"], effort_source: ["creator", "spawn", "command"], fast_mode: ["spawn"],
     last_message_at: ["command"], status_gate: ["spawn", "watcher"], status_gate_history: ["watcher", "reconcile"], blocker_freshness_state: ["watcher"], kr_freshness_state: ["watcher"], last_compaction: ["spawn"], story_complete: ["watcher", "reconcile"], story_complete_reason: ["watcher", "reconcile"], story_status: ["watcher", "reconcile"],
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],

package/dist/lib/lanes/watcher.js

@@ -37,6 +37,7 @@ import { LanesError } from "./errors.js";
 import { questionRecordRefusalCode, raiseEnvelopeQuestions, resolveQuestionCompanyWithFallback, } from "./questions.js";
 import { isTerminalLaneState, ENVELOPE_INVALID_REASON, parseLaneEnvelope, STORY_STATUSES, LANE_PROVIDERS, } from "./types.js";
 import { laneStories, terminalEnvelopeStoryStatus } from "./stories.js";
+import { applyStorySwitchEnvelope } from "./story-switch.js";
 import { appendCappedHistory, listQuestionIds, readLane, readQuestion, retryUpdateLane, withLaneHireLocks } from "./store.js";
 import { enforceRegistryApprovalGate } from "./approval-gate.js";
 import { readWorkerRunResult } from "./delivery.js";
@@ -414,6 +415,7 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
             }), current.registry_worker_approval_history ?? []);
         }
         if (envelope) {
+            const storySwitch = applyStorySwitchEnvelope(current, envelope, at, envelopeRef);
             if (envelope.decision !== "blocked")
                 next.keep_alive_blocked_resume_streak = 0;
             next.last_envelope = {
@@ -423,11 +425,20 @@ export function applyTerminalToLaneWithResult(hqRoot, laneId, classification, op
                 artifacts: envelope.artifacts,
                 ...(envelope.blocked_reason !== undefined ? { blocked_reason: envelope.blocked_reason } : {}),
             };
-            const storyStatus = terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
+            if (storySwitch.clearPending) {
+                next.story_switch_pending = undefined;
+            }
+            if (storySwitch.storySwitchUnacknowledged !== undefined) {
+                next.story_switch_unacknowledged = storySwitch.storySwitchUnacknowledged;
+                next.attribution_history = storySwitch.attributionHistory ?? current.attribution_history;
+            }
+            const storyStatus = storySwitch.suppressCompletion
+                ? "in_progress"
+                : terminalEnvelopeStoryStatus(current, envelope.decision, envelope.story_status);
             if (storyStatus !== undefined) {
-                next.story_status = envelope.story_status;
-                next.story_complete = envelope.story_complete;
-                next.story_complete_reason = envelope.story_complete_reason;
+                next.story_status = storySwitch.suppressCompletion ? "in_progress" : envelope.story_status;
+                next.story_complete = storySwitch.suppressCompletion ? false : envelope.story_complete;
+                next.story_complete_reason = storySwitch.suppressCompletion ? undefined : envelope.story_complete_reason;
                 const currentProject = current.project_id;
                 const currentStory = current.story_id;
                 const updatedStories = laneStories(current).map((story) => story.project_id === currentProject && story.story_id === currentStory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.299.0",
+  "version": "5.300.0",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {