@indigoai-us/hq-cli 5.299.0 → 5.301.0

package/dist/commands/integrations-api.js

@@ -74,33 +74,24 @@ export async function installIntegration(token, companyUid, input) {
     }
     return (await res.json());
 }
-export async function uninstallIntegration(token, companyUid, installationId) {
+export async function uninstallIntegration(token, companyUid, target) {
     const res = await vaultApiFetch({
         token,
         path: "/v1/integrations/factory/uninstall",
         method: "POST",
-        body: { companyUid, installationId },
+        body: { companyUid, ...target },
     });
     if (!res.ok)
         await raiseForResponse(res, "Failed to disconnect the app");
     return (await res.json());
 }
-/**
- * Permanently remove a revoked connection tombstone. The admin purge endpoint
- * deliberately accepts only the connection id: it derives the company and
- * enforces owner authorization from the authenticated connection record.
- */
+/** Permanently remove a revoked connection tombstone for one company. */
 export async function purgeConnection(token, companyUid, connectionId) {
-    // Keep the company in this client's call signature with the other
-    // connection mutations. It is resolved before the target connection so a
-    // caller cannot use a slug from a different company, but the server's purge
-    // contract intentionally takes only connectionId in its body.
-    void companyUid;
     const res = await vaultApiFetch({
         token,
         path: "/v1/integrations/admin/purge",
         method: "POST",
-        body: { connectionId },
+        body: { companyUid, connectionId },
     });
     if (!res.ok)
         await raiseForResponse(res, "Failed to purge the revoked connection");

package/dist/commands/integrations-manage.js

@@ -610,9 +610,6 @@ export function registerManageCommands(integrations) {
         const companyUid = await getCompanyUid(token, opts.company);
         const connection = await resolveConnection(token, companyUid, app, opts);
         const installationId = connection.installation?.id;
-        if (!installationId) {
-            throw new IntegrationsCliError(`${connectionLabel(connection)} was not installed through the app catalog, so it cannot be disconnected from here.`, { expected: true });
-        }
         if (!opts.yes) {
             const label = connectionLabel(connection);
             // Warning + prompt go to stderr: with --json, stdout must stay parseable,
@@ -625,7 +622,7 @@ export function registerManageCommands(integrations) {
                 throw new IntegrationsCliError("Not disconnected. Re-run with --yes if you are sure.", { expected: true });
             }
         }
-        const result = await uninstallIntegration(token, companyUid, installationId);
+        const result = await uninstallIntegration(token, companyUid, installationId ? { installationId } : { connectionId: connection.id });
         if (opts.json) {
             printJson(result);
             return;

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;
@@ -436,6 +488,8 @@ export function createLaneMessageHandlers(deps) {
                 });
                 lane = move.lane;
                 if (move.queued) {
+                    storySwitchDeliveryStarted = true;
+                    deps.onLaneMessageQueued?.(laneId, "account_move");
                     archiveResumeMessage(hqRoot, laneId, dropboxMessage);
                 }
             }
@@ -461,8 +515,11 @@ export function createLaneMessageHandlers(deps) {
                             accountSelection: selection,
                         });
                         lane = move.lane;
-                        if (move.queued)
+                        if (move.queued) {
+                            storySwitchDeliveryStarted = true;
+                            deps.onLaneMessageQueued?.(laneId, "account_move");
                             archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                        }
                     }
                     else {
                         lane = persistClaudeAccountSelection(hqRoot, lane, selection);
@@ -491,6 +548,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 () => {
@@ -512,7 +570,7 @@ export function createLaneMessageHandlers(deps) {
                                     }
                                     archiveResumeMessage(hqRoot, laneId, dropboxMessage);
                                     queuedOnAdmission = true;
-                                    return casUpdateLane(hqRoot, laneId, (current) => {
+                                    const queued = casUpdateLane(hqRoot, laneId, (current) => {
                                         if (current.version !== lane.version || current.state !== lane.state) {
                                             throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
                                                 lane_id: laneId,
@@ -539,6 +597,9 @@ export function createLaneMessageHandlers(deps) {
                                             },
                                         };
                                     });
+                                    storySwitchDeliveryStarted = true;
+                                    deps.onLaneMessageQueued?.(laneId, "admission");
+                                    return queued;
                                 }
                                 const started = spawnLaneWorker(hqRoot, lane, {
                                     env: ctx.env,
@@ -565,6 +626,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 +639,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 +692,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), {