@awak-app/simy-cli 0.6.8 → 0.6.9

package/README.md

@@ -60,9 +60,11 @@ that a task can execute successfully; permissions and service availability are
 checked when work starts.
 
 The sidebar's **Organization** selector is global across Sessions, Tasks and SQM
-and shows active memberships of the connected SIMY account. Switching opens browser authorization for the selected organization
-and waits for active tasks to finish. Use the same account in the browser; cancel
-an unfinished switch from the sidebar.
+and shows active memberships of the connected SIMY account. Switching is available
+while work is running and opens browser authorization for the selected organization.
+It cancels running and queued SIMY analyses before changing organizations; ordinary
+implementation tasks keep their original organization. Use the same account in the
+browser; cancel an unfinished switch from the sidebar.
 
 Browser authorization links expire after **20 minutes**. The app shows **Connection
 timed out** and **Reconnect** when an active request expires. Reconnect starts a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.8",
+  "version": "0.6.9",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {

package/src/agent.js

@@ -174,6 +174,8 @@ export async function startAgent({
   deferStartupSynchronization = false,
   enforceDesktopAccess = false,
   onDesktopStatusChange = null,
+  suspendOrganizationAnalyses = async () => {},
+  resumeOrganizationAnalyses = async () => {},
   dependencies = {},
   quiet = false,
 } = {}) {
@@ -230,6 +232,7 @@ export async function startAgent({
       pendingOrganization = null;
       desktopLoginPending = false;
       loginUrl = null;
+      void resumeOrganizationWork().catch(() => {});
       refreshAvailableCapabilities();
       notifyDesktopStatusChange();
     },
@@ -315,8 +318,9 @@ export async function startAgent({
     session?.account_id ?? null, session?.organization_id ?? null, session?.device_id ?? null, session?.token ?? null,
     pendingOrganization?.id ?? null, isSessionValid(session, Date.now(), apiOrigin),
   ])).digest('hex');
-  const desktopWorkAllowed = () => !desktopWorkSuspended && (!enforceDesktopAccess || desktopAccessReady(desktopAccess.snapshot()));
+  const desktopWorkAllowed = () => !desktopWorkSuspended && !pendingOrganization && (!enforceDesktopAccess || desktopAccessReady(desktopAccess.snapshot()));
   const authorizeDesktopWork = async expectedScope => {
+    if (pendingOrganization) throw Object.assign(new Error("Organization switching is in progress."), { code: "desktop_access_required" });
     if (desktopWorkSuspended || shuttingDown) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
     if (enforceDesktopAccess) {
       requireDesktopAccess(await desktopAccess.refresh());
@@ -325,6 +329,9 @@ export async function startAgent({
       if (expectedScope !== undefined && expectedScope !== scope) throw Object.assign(new Error("Desktop account or organization changed."), { code: "desktop_access_required" });
       return scope;
     }
+    const scope = desktopScopeRevision();
+    if (expectedScope !== undefined && expectedScope !== scope) throw Object.assign(new Error("Desktop account or organization changed."), { code: "desktop_access_required" });
+    return scope;
   };
   refreshAvailableCapabilities();
   let durableLocalTaskWorker = null;
@@ -482,9 +489,30 @@ export async function startAgent({
     }
   };
 
-  const organizationBusy = () => Boolean(sqmLocalReviewWorker?.snapshot?.().polling ||
-    durableLocalTaskWorker?.snapshot?.().polling || durableLocalTaskWorker?.snapshot?.().active_turn_id ||
-    desktopTaskStatus([registry, directRegistry, localTaskRegistry]).activeCount);
+  let organizationCancellation = Promise.resolve();
+  const suspendOrganizationWork = () => {
+    durableLocalTaskWorker?.pause?.();
+    const cancellation = Promise.all([
+      sqmLocalReviewWorker?.suspend?.(), suspendOrganizationAnalyses(),
+    ]);
+    // Preserve failures for the authorization callback without an unhandled rejection.
+    cancellation.catch(() => {});
+    organizationCancellation = cancellation;
+    return cancellation;
+  };
+  const resumeOrganizationWork = async () => {
+    const nonce = authNonce;
+    await organizationCancellation;
+    const shouldResume = () => !pendingOrganization && nonce === authNonce && !shuttingDown;
+    if (!shouldResume()) return;
+    await sqmLocalReviewWorker?.resume?.({ shouldResume });
+    if (!shouldResume()) return;
+    await durableLocalTaskWorker?.resume?.();
+    if (!shouldResume()) return;
+    await resumeOrganizationAnalyses({ shouldResume });
+  };
+  const sameRunScope = (left, right) => ["account_id", "organization_id", "device_id"].every(field =>
+    (left?.[field] ?? null) === (right?.[field] ?? null));
   const refreshOrganizations = async () => {
     if (!isSessionValid(session, Date.now(), apiOrigin)) return;
     if (organizationRefresh) return organizationRefresh;
@@ -531,9 +559,9 @@ export async function startAgent({
       if (choice.desktopAccess && choice.desktopAccess !== "ready") throw new Error("This organization does not have SIMY Developer access.");
       organizationSlug = choice.slug;
       if (!organizationSlug) throw new Error('Refresh organizations before switching; its verified slug is unavailable.');
-      if (organizationBusy()) throw Object.assign(new Error("Wait for running tasks to finish before switching organizations."), { code: "desktop_organization_busy" });
       authNonce = randomBytes(16).toString("base64url");
       pendingOrganization = { id: organizationId, accountId: session.account_id };
+      suspendOrganizationWork();
       loginUrl = null;
       refreshAvailableCapabilities();
       notifyDesktopStatusChange();
@@ -575,6 +603,7 @@ export async function startAgent({
   const restoreRemoteRuns = async () => {
     if (!desktopWorkAllowed()) return;
     if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin) || !session?.device_id) return;
+    const requestedSession = session;
     const snapshots = dependencies.listRemoteRuns
       ? await dependencies.listRemoteRuns({
           apiOrigin,
@@ -586,15 +615,17 @@ export async function startAgent({
           apiBaseUrl: session.api_base_url,
           token: session.token,
         });
+    if (session !== requestedSession || !desktopWorkAllowed()) return;
     const remoteIds = new Set();
     let restored = false;
     for (const snapshot of snapshots) {
-      if (shuttingDown) return;
+      if (shuttingDown || session !== requestedSession || !desktopWorkAllowed()) return;
       if (!snapshot?.id) continue;
       remoteIds.add(snapshot.id);
       if (registry.has(snapshot.id)) {
         const localRun = registry.get(snapshot.id);
-        localRun.session = session;
+        if (!sameRunScope(localRun.session, requestedSession)) continue;
+        localRun.session = requestedSession;
         localRun.apiOrigin = apiOrigin;
         // A newer ledger is not permission to replace an active local operation.
         // Keep the owner, child, checkpoint and approval state until it settles.
@@ -644,16 +675,21 @@ export async function startAgent({
 
   const restoreLocalCodingRuns = async () => {
     if (!desktopWorkAllowed()) return;
+    const requestedSession = session;
     const { snapshots, errors } = await loadCodingRunSnapshots(codingRunStateRoot);
+    if (session !== requestedSession || !desktopWorkAllowed()) return;
     for (const error of errors) {
       reportStartupConnectionError(new Error(`Coding run ${error.id}: ${error.message}`), quiet);
     }
     for (const snapshot of snapshots) {
+      const savedActor = snapshot?.metadata?.recovery_actor;
+      if (savedActor && ["account_id", "organization_id", "device_id"].some(field => savedActor[field] && savedActor[field] !== requestedSession?.[field])) continue;
       const boundDevice = snapshot?.metadata?.execution_device_id;
       if (boundDevice && boundDevice !== session?.device_id) continue;
       if (registry.has(snapshot.id)) {
         const existing = registry.get(snapshot.id);
-        existing.session = session;
+        if (!sameRunScope(existing.session, requestedSession)) continue;
+        existing.session = requestedSession;
         existing.apiOrigin = apiOrigin;
         continue;
       }
@@ -705,6 +741,7 @@ export async function startAgent({
     connectionStatus.attempt();
     notifyDesktopStatusChange();
     let deviceHeartbeatSucceeded = false;
+    const requestedSession = session;
     const advertisedProviders = JSON.stringify(providerStatuses);
     heartbeatInFlight = Promise.resolve()
       .then(async () => { if (enforceDesktopAccess) await desktopAccess.refresh(true); })
@@ -742,12 +779,12 @@ export async function startAgent({
         const sqmResult = sqmEnabled && sqmLocalReviewWorker
           ? await sqmLocalReviewWorker.poll()
           : null;
-        if (shuttingDown) return false;
+        if (shuttingDown || pendingOrganization || !desktopWorkAllowed() || session !== requestedSession) return false;
         if (!sqmResult && durableLocalTaskWorker) await durableLocalTaskWorker.poll();
         return true;
       })
       .catch((error) => {
-        if (!deviceHeartbeatSucceeded) {
+        if (!deviceHeartbeatSucceeded && session === requestedSession) {
           const state = connectionStatus.failure(error);
           notifyDesktopStatusChange();
           if (state === "unauthorized") {
@@ -918,7 +955,7 @@ export async function startAgent({
           }
         };
         return (dependencies.runSqmLocalReview || ((value, selected, options) => runStructuredProviderReview(selected, value, options)))(request, provider, {
-          beforeDispatch, readOnlyAnalysis: true, enableEngineFallback: settings.enable_engine_fallback,
+          signal: context.signal, beforeDispatch, readOnlyAnalysis: true, enableEngineFallback: settings.enable_engine_fallback,
           allowedFallbackProviders: settings.allowed_fallback_providers, providerReportingSupported: context.providerReportingSupported === true,
         });
       },
@@ -1248,11 +1285,16 @@ export async function startAgent({
           const nextOrganization = body.organization_id ?? body.org_id;
           const nextAccount = body.account_id ?? body.auth_user_id;
           const changingScope = session && (session.organization_id !== nextOrganization || session.account_id !== nextAccount);
-          if ((changingScope && organizationBusy()) || (pendingOrganization &&
-              (pendingOrganization.id !== nextOrganization || pendingOrganization.accountId !== nextAccount))) {
-            json(res, 409, { error: "Organization authorization does not match, or tasks are still running." });
+          if (pendingOrganization &&
+              (pendingOrganization.id !== nextOrganization || pendingOrganization.accountId !== nextAccount)) {
+            json(res, 409, { error: "Organization authorization does not match." });
             return;
           }
+          if (changingScope && !pendingOrganization) {
+            pendingOrganization = { id: nextOrganization, accountId: nextAccount };
+            suspendOrganizationWork();
+          }
+          await organizationCancellation;
           const previousSession = session ?? reclaimableSession;
           const authorizedSession = {
             token: String(body.token || ""),
@@ -1310,6 +1352,10 @@ export async function startAgent({
             json(res, 410, { error: "Connection expired. Reconnect from SIMY." }); return;
           }
           await writeSession(apiOrigin, authorizedSession, sessionRoot);
+          if (authorizationWindow.snapshot().state === "timed_out" || requestNonce !== authNonce) {
+            await writeSession(apiOrigin, session ?? {}, sessionRoot);
+            json(res, 410, { error: "Connection expired. Reconnect from SIMY." }); return;
+          }
           session = authorizedSession;
           reclaimableSession = null;
           authorizationWindow.clear();
@@ -1327,6 +1373,7 @@ export async function startAgent({
           startHeartbeatTimer();
           loginUrl = null;
           registry.emit("change", registry.list());
+          await resumeOrganizationWork();
           json(res, 200, {
             ok: true,
             expires_at: session.expires_at,
@@ -2517,7 +2564,7 @@ export async function startAgent({
       connection: connectionStatus.snapshot({ authenticated: auth.state === "signed_in" }),
       tasks: desktopTaskStatus([registry, directRegistry, localTaskRegistry]),
       organizations: { state: organizationState, items: organizationItems, selectedId: session?.organization_id ?? null,
-        switching: Boolean(pendingOrganization), canSwitch: auth.state === "signed_in" && !organizationBusy() },
+        switching: Boolean(pendingOrganization), canSwitch: auth.state === "signed_in" },
       sqm: { enabled: sqmEnabled, engineFallbackEnabled: sqmEngineSettings.enable_engine_fallback,
         allowedFallbackProviders: sqmEngineSettings.allowed_fallback_providers,
         paused: sqmLocalReviewWorker?.snapshot?.().paused === true, pauseReason: sqmLocalReviewWorker?.snapshot?.().pause_reason ?? null, canEnable: auth.state === "signed_in" && Boolean(session?.account_id && session?.organization_id) && !pendingOrganization && desktopWorkAllowed(),
@@ -2564,7 +2611,7 @@ export async function startAgent({
     getDesktopAccess: () => ({ ...desktopAccess.snapshot(), revision: desktopScopeRevision() }),
     requireDesktopAccess: authorizeDesktopWork,
     refreshOrganizations,
-    cancelOrganizationSelection() { authorizationWindow.clear(); expiredOrganizationId = null; expiredInteractiveAuthorization = false; authNonce = randomBytes(16).toString("base64url"); pendingOrganization = null; desktopLoginPending = false; loginUrl = null; refreshAvailableCapabilities(); notifyDesktopStatusChange(); },
+    async cancelOrganizationSelection() { authorizationWindow.clear(); expiredOrganizationId = null; expiredInteractiveAuthorization = false; authNonce = randomBytes(16).toString("base64url"); pendingOrganization = null; desktopLoginPending = false; loginUrl = null; refreshAvailableCapabilities(); notifyDesktopStatusChange(); await resumeOrganizationWork(); },
     async setSqmEnabled(enabled) {
       if (enabled) await authorizeDesktopWork();
       if (!isSessionValid(session, Date.now(), apiOrigin) || pendingOrganization) throw new Error("Sign in to an organization first.");

package/src/cli-contract.js

@@ -13,7 +13,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.6.8";
+export const CLI_VERSION = "0.6.9";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/desktop-host.js

@@ -115,11 +115,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
   };
   const accessSnapshot = async () => setAccessSnapshot((await agent?.getDesktopStatus?.())?.access);
   let stoppingForUpdate = false;
+  let organizationAnalysesSuspended = false;
+  let organizationAnalysisDrain = Promise.resolve();
+  let organizationAnalysisEpoch = 0;
   const authorizeWork = async expectedScope => {
-    if (closed || stoppingForUpdate) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
+    if (closed || stoppingForUpdate || organizationAnalysesSuspended) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
     if (agent?.requireDesktopAccess) await agent.requireDesktopAccess();
     const access = await accessSnapshot();
-    if (closed || stoppingForUpdate) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
+    if (closed || stoppingForUpdate || organizationAnalysesSuspended) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
     requireDesktopAccess(access);
     const scope = accessScope(access);
     if (expectedScope !== undefined && expectedScope !== scope) throw Object.assign(new Error("Desktop account or organization changed."), { code: "desktop_access_required" });
@@ -196,6 +199,29 @@ export async function startDesktopHost({ input = process.stdin, output = process
     enroll: guardedEnroll, beforeEnroll: candidate => authorizeWork(selectedScopes.get(candidate)),
     onChange: () => { if (!closed && !relay) refreshSessions(true); },
   });
+  const suspendOrganizationAnalyses = () => {
+    organizationAnalysisEpoch++;
+    organizationAnalysesSuspended = true;
+    discoveryStopped = true;
+    organizationAnalysisDrain = Promise.all([
+      stopDiscovery({ drain: true }), automaticContinuation?.close(), analysisManager?.suspend?.(),
+    ]);
+    return organizationAnalysisDrain;
+  };
+  const resumeOrganizationAnalyses = async ({ shouldResume = () => true } = {}) => {
+    const epoch = organizationAnalysisEpoch;
+    const current = () => epoch === organizationAnalysisEpoch && shouldResume() && !closed && !stoppingForUpdate;
+    await organizationAnalysisDrain;
+    if (!current()) return;
+    await accessSnapshot();
+    if (!current()) return;
+    await analysisManager?.resume?.({ shouldResume: current });
+    if (!current()) return;
+    automaticContinuation = makeAutomaticContinuation();
+    organizationAnalysesSuspended = false;
+    discoveryStopped = false;
+    refreshSessions(true);
+  };
   let pluginSetup = { state: "unknown" };
   let providerPlugins = { codex: { state: 'checking' }, claude: { state: 'checking' } };
   let pluginInspection = null, lastPluginInspectionAt = -Infinity;
@@ -344,6 +370,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     agent = await (dependencies.startAgent || startAgent)({
       daemon: true, webOrigin, sessionRoot: root, quiet: true, updateManager: updater,
       deferStartupSynchronization: true, enforceDesktopAccess: true,
+      suspendOrganizationAnalyses, resumeOrganizationAnalyses,
       onDesktopStatusChange: () => {
         // Let an in-progress frame finish before publishing its new snapshot.
         setImmediate(() => { void publish().catch(() => {}); });
@@ -551,12 +578,9 @@ export async function startDesktopHost({ input = process.stdin, output = process
         else if (action === "sqm_set_enabled") await agent.setSqmEnabled(command.enabled);
         else if (action === "sqm_set_engine_fallback") await agent.setSqmEngineFallback({ enabled: command.enabled, allowedProviders: command.allowedProviders });
         else if (action === "sqm_retry_environment") await agent.retrySqmEnvironment();
-        else if (action === "organization_cancel") agent.cancelOrganizationSelection();
+        else if (action === "organization_cancel") await agent.cancelOrganizationSelection();
         else if (action === "login" || action === "organization_select" || action === "authorization_open") {
           if (action === "organization_select" && (typeof command.organizationId !== "string" || !command.organizationId)) throw new Error("Select an organization first.");
-          if (action === "organization_select" && activeQueuedAction && !["refresh", "reconnect", "task_detail", "organizations_refresh", "check_update"].includes(activeQueuedAction)) {
-            throw Object.assign(new Error("Wait for the current action to finish before switching organizations."), { code: "desktop_organization_busy" });
-          }
           const url = action === "authorization_open" ? (agent.getPendingAuthorizationUrl?.() ?? agent.retryAuthorization?.())
             : await agent.requestDesktopLogin(action === "organization_select" ? command.organizationId : null);
           if (action === 'authorization_open' && !url) throw new Error('No pending authorization.');

package/src/durable-local-task-worker.js

@@ -158,6 +158,17 @@ export function createDurableLocalTaskApi({
   const stepContract = durableLocalTaskStepApiContract();
 
   return {
+    // A claimed task owns its original identity through every heartbeat,
+    // artifact request and final status, even if the desktop changes accounts.
+    capture() {
+      const connection = { ...getConnection() };
+      return createDurableLocalTaskApi({
+        getConnection: () => connection,
+        fetchImpl,
+        requestTimeoutMs,
+        artifactUploadTimeoutMs,
+      });
+    },
     async claimSubtaskParent({
       workerId,
       leaseSeconds = DEFAULT_LEASE_SECONDS,
@@ -633,11 +644,13 @@ export function createDurableLocalTaskWorker({
   }
 
   let closed = false;
+  let paused = false;
   let pollPromise = null;
   let active = null;
   let activeExecutionPromise = null;
   let lastStepDisposition = null;
   let pendingStepTurnId = null;
+  let pendingStepContext = null;
   const boundedTasks = new Map();
 
   const executeBoundedRuntime = runBoundedSubtask ?? (async (runtime, { signal }) => {
@@ -700,7 +713,8 @@ export function createDurableLocalTaskWorker({
     }
   });
 
-  const executeStepClaim = async (claim, releaseWork) => {
+  const executeStepClaim = async (claim, releaseWork, context) => {
+    const { api } = context;
     let task = null;
     let heartbeatTimer = null;
     let heartbeatInFlight = null;
@@ -1010,6 +1024,7 @@ export function createDurableLocalTaskWorker({
           return;
         }
         pendingStepTurnId = normalized.turnId;
+        pendingStepContext = context;
       }
     } catch (error) {
       if (!leaseLost) {
@@ -1051,9 +1066,10 @@ export function createDurableLocalTaskWorker({
     }
   };
 
-  const executeClaim = async (claim, releaseWork) => {
+  const executeClaim = async (claim, releaseWork, context) => {
+    const { api, attachmentStore, deviceId } = context;
     if (isDurableLocalTaskStepClaim(claim)) {
-      return executeStepClaim(claim, releaseWork);
+      return executeStepClaim(claim, releaseWork, context);
     }
     let task = null;
     let heartbeatTimer = null;
@@ -1094,7 +1110,6 @@ export function createDurableLocalTaskWorker({
             "durable_local_task_attachments_unavailable",
           );
         }
-        const deviceId = getDeviceId();
         attachments = await attachmentStore.materialize({
           refs: normalized.attachmentRefs,
           deviceId,
@@ -1374,7 +1389,7 @@ export function createDurableLocalTaskWorker({
       ) {
         await attachmentStore.cleanup({
           refs: materializedAttachmentRefs,
-          deviceId: getDeviceId(),
+          deviceId,
         }).catch((error) => onError(recoveryError(
           "SIMY could not remove the staged attachment copy.",
           error,
@@ -1393,6 +1408,7 @@ export function createDurableLocalTaskWorker({
     snapshot() {
       return {
         closed,
+        paused,
         polling: Boolean(pollPromise),
         active_turn_id: active?.claim?.turn_id || null,
         durable_step_disposition: lastStepDisposition,
@@ -1401,10 +1417,16 @@ export function createDurableLocalTaskWorker({
       };
     },
     async poll() {
-      if (closed || active || pollPromise) return false;
+      if (closed || paused || active || pollPromise) return false;
       const releaseWork = beginWork?.();
       if (!releaseWork) return false;
+      const context = pendingStepContext || {
+        api: typeof api.capture === "function" ? api.capture() : api,
+        deviceId: getDeviceId(),
+        attachmentStore,
+      };
       pollPromise = (async () => {
+        const { api, attachmentStore, deviceId } = context;
         try {
           const requestedTurnId = pendingStepTurnId;
           if (
@@ -1491,7 +1513,7 @@ export function createDurableLocalTaskWorker({
               workspaceRoot,
               prepareWorkspace,
               attachmentStore,
-              deviceId: getDeviceId(),
+              deviceId,
               onError,
             });
             claim = await claimControlledPlanWithReplay(api, {
@@ -1524,7 +1546,7 @@ export function createDurableLocalTaskWorker({
               leaseSeconds,
             });
             lastStepDisposition = normalized.disposition;
-            if (requestedTurnId) pendingStepTurnId = null;
+            if (requestedTurnId) { pendingStepTurnId = null; pendingStepContext = null; }
             if (normalized.disposition !== "execute") {
               // Approval checkpoints and unknown Provider results are durable
               // Backend states, not executable leases. Keep no process,
@@ -1543,7 +1565,7 @@ export function createDurableLocalTaskWorker({
           }
           if (closed) { releaseWork(); return false; }
           active = { claim, task: null };
-          const executionPromise = executeClaim(claim, releaseWork)
+          const executionPromise = executeClaim(claim, releaseWork, context)
             .catch((error) => {
               onError(
                 recoveryError(
@@ -1577,6 +1599,10 @@ export function createDurableLocalTaskWorker({
       })();
       return pollPromise;
     },
+    // Pause claims without interrupting an ordinary implementation task.
+    // Already claimed work and a durable plan handoff keep their old scope.
+    pause() { paused = true; },
+    resume() { if (!closed) paused = false; },
     async waitForIdle() {
       await pollPromise;
       await activeExecutionPromise;

package/src/session-supervision/analysis-manager.js

@@ -54,7 +54,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   for (const [key, entry] of entries) {
     if (entry.result?.state === 'analyzing') entry.result = { state: 'queued' };
   }
-  let serial = Promise.resolve(), draining = null, closed = false, wakeDrain = null, wakeEpoch = 0;
+  let serial = Promise.resolve(), draining = null, closed = false, suspended = false, wakeDrain = null, wakeEpoch = 0;
   const jobs = new Map();
   const wake = () => { wakeEpoch++; wakeDrain?.(); };
   const exclusive = fn => {
@@ -147,7 +147,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     }
     await exclusive(async () => {
       const current = candidates.get(selected.key), entry = entries.get(selected.key);
-      if (closed) return;
+      if (closed || selected.cancelled) return;
       if (!current || !eligible(current) || current.isRunning === true || continuationAnalysisRevision(current) !== selected.revision || entry?.revision !== selected.revision || entry !== selected.entry) {
         // A stale snapshot can help display/reuse a finished boundary but is
         // never the current recommendation or authority to dispatch work.
@@ -170,13 +170,13 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   };
   const startDrain = () => {
     wake();
-    if (closed || draining) return;
+    if (closed || suspended || draining) return;
     let drainFailed = false;
     draining = (async () => {
       while (!closed || jobs.size) {
         const observedWake = wakeEpoch;
         const selected = await exclusive(async () => {
-          if (closed) return [];
+          if (closed || suspended) return [];
           const batch = [];
           // Explicit retries precede historical backfill without interrupting owned jobs.
           const ordered = [...entries].sort((a, b) => Number(Boolean(b[1].requestId)) - Number(Boolean(a[1].requestId)));
@@ -207,13 +207,13 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       }
     })().catch(() => { drainFailed = true; }).finally(() => {
       draining = null;
-      if (!closed && !drainFailed && [...entries].some(([key, entry]) => runnable(key, entry))) startDrain();
+      if (!closed && !suspended && !drainFailed && [...entries].some(([key, entry]) => runnable(key, entry))) startDrain();
     });
   };
   return {
     async updateProviderStatuses(statuses = {}) {
       await exclusive(async () => {
-        if (closed) return;
+        if (closed || suspended) return;
         for (const provider of ['codex', 'claude']) {
           const status = statuses[provider];
           if (!status) continue;
@@ -229,7 +229,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     },
     async update(sessions) {
       await exclusive(async () => {
-        if (closed) return;
+        if (closed || suspended) return;
         candidates.clear();
         for (const candidate of sessions) candidates.set(keyOf(candidate), candidate);
         const sorted = [...candidates.values()].sort((a, b) => activityOf(b) - activityOf(a) || keyOf(a).localeCompare(keyOf(b)));
@@ -296,7 +296,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       if (requestId !== undefined && (typeof requestId !== 'string' || !requestId || requestId.length > 128)) throw new Error('Invalid analysis request identity.');
       if (!candidate || !eligible(candidate)) throw new Error('This conversation cannot be analyzed.');
       await exclusive(async () => {
-        if (closed) throw new Error('Session analysis is unavailable.');
+        if (closed || suspended) throw new Error('Session analysis is unavailable.');
         candidates.set(keyOf(candidate), candidate);
         let dirty = enqueue(candidate, true, true);
         const entry = entries.get(keyOf(candidate));
@@ -307,7 +307,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     },
     async invalidate(candidate) {
       await exclusive(async () => {
-        if (closed) throw new Error('Session analysis is unavailable.');
+        if (closed || suspended) throw new Error('Session analysis is unavailable.');
         entries.delete(keyOf(candidate));
         candidates.set(keyOf(candidate), candidate);
         enqueue(candidate); await persist(); changed();
@@ -316,7 +316,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       startDrain();
     },
     requireRecommendation(candidate) {
-      if (closed) throw new Error('Session analysis is unavailable.');
+      if (closed || suspended) throw new Error('Session analysis is unavailable.');
       const analysis = this.project(candidate).analysis;
       if (!eligible(candidate) || candidate.isRunning === true || analysis.awaitingTurn === true || analysis.state !== 'continue') throw new Error('Analyze this conversation before continuing; it needs a current recommendation.');
       return analysis;
@@ -329,6 +329,36 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       } while (draining || jobs.size);
       await serial;
     },
+    async suspend() {
+      // Gate new work before waiting on cache writes. Provider cleanup retains
+      // its slot, and cancelled results never publish after an organization switch.
+      suspended = true;
+      for (const job of jobs.values()) { job.cancelled = true; job.controller.abort(); }
+      wake();
+      try {
+        await exclusive(async () => {
+          if (closed) return;
+          candidates.clear();
+          let dirty = false;
+          for (const entry of entries.values()) {
+            if (!['queued', 'analyzing'].includes(entry.result?.state)) continue;
+            entry.result = { state: 'failed', reasonCode: 'analysis_cancelled',
+              reason: 'The analysis was stopped for an organization switch. Request analysis again to retry.' };
+            entry.completedAt = now();
+            dirty = true;
+          }
+          if (dirty) { await persist(); changed(); }
+        });
+      } finally { await this.whenIdle(); }
+    },
+    async resume({ shouldResume = () => true } = {}) {
+      await this.whenIdle();
+      await exclusive(() => {
+        if (!shouldResume()) return;
+        if (closed) throw new Error('Session analysis is unavailable.');
+        suspended = false;
+      });
+    },
     async close() { closed = true; for (const job of jobs.values()) job.controller.abort(); wake(); await this.whenIdle(); },
   };
 }

package/src/sqm/review-worker.js

@@ -113,6 +113,7 @@ export function createSqmLocalReviewWorker({
   let activeJobId = null;
   let pollPromise = null;
   let closed = false;
+  let suspended = false;
   let reviewController = null;
   let issue = null, pausedEnvironment = null, pauseReason = null;
   let issueContext = null;
@@ -167,7 +168,9 @@ export function createSqmLocalReviewWorker({
       if (reviewOptions.signal?.aborted) throw providerFailure("analysis_cancelled");
       setStage(true);
       try {
-        return { review, response: await submit(review) };
+        const response = await submit(review);
+        if (reviewOptions.signal?.aborted) throw providerFailure("analysis_cancelled");
+        return { review, response };
       } catch (error) {
         if (attempt >= 1 || error.status !== 422 || error.code !== code || !error.validationFeedback) throw error;
         nextRequest = { ...request, prompt: `${request.prompt}\n\nThe previous result failed validation. Return a corrected complete JSON object using only the supplied evidence. Fix these constraints:\n${error.validationFeedback}` };
@@ -246,7 +249,7 @@ export function createSqmLocalReviewWorker({
   return {
     snapshot() {
       const pause = currentPause();
-      return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, paused: pausedEnvironment !== null, pause_reason: pauseReason, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
+      return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, suspended, paused: pausedEnvironment !== null, pause_reason: pauseReason, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
         ...(pause ? { provider_pause: { code: pause.code, status: pause.status, retry_at: new Date(pause.retryAt).toISOString(), message: pause.message } } : {}) };
     },
     desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item, canStop: item.id === activeJobId })) }; },
@@ -254,10 +257,10 @@ export function createSqmLocalReviewWorker({
       const item = visibleHistory().find(item => item.key === key);
       return item ? { key, instruction: `SQM local review · ${item.provider}`, result: item.state === "completed" ? "SQM review submitted." : "", error: item.error || "", links: item.webUrl ? [{ label: "Analysis details", url: item.webUrl }] : [] } : null;
     },
-    retry() { if (closed || pollPromise) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
+    retry() { if (closed || suspended || pollPromise) return false; pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; onChange(); return true; },
     resetHistory() { if (!pollPromise) { history.splice(0); issue = null; pausedEnvironment = null; pauseReason = null; } },
     poll() {
-      if (closed || pollPromise) return pollPromise || Promise.resolve(null);
+      if (closed || suspended || pollPromise) return pollPromise || Promise.resolve(null);
       const environmentKey = getEnvironmentKey();
       if (pausedEnvironment !== null && pausedEnvironment === environmentKey) return Promise.resolve(null);
       if (pausedEnvironment !== null) { pausedEnvironment = null; pauseReason = null; pauses.delete(contextKey(getProvider(), getHistoryScope())); issue = null; }
@@ -325,6 +328,21 @@ export function createSqmLocalReviewWorker({
       reviewController?.abort();
       await pollPromise;
     },
+    async suspend() {
+      suspended = true;
+      reviewController?.abort();
+      onChange();
+      // Keep the original connection until provider cleanup and the final
+      // cancellation report finish, including a claim that returns after abort.
+      await pollPromise;
+    },
+    async resume({ shouldResume = () => true } = {}) {
+      await pollPromise;
+      if (!shouldResume()) return;
+      if (closed) throw new Error("SQM analysis is unavailable.");
+      suspended = false;
+      onChange();
+    },
     async close() {
       closed = true;
       reviewController?.abort();