@awak-app/simy-cli 0.6.8 → 0.6.10

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.10",
   "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.10";
 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

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { analyzeContinuation, CONTINUATION_ANALYSIS_VERSION } from './continuation-analysis.js';
+import { providerGoalEvidence } from './conversation-context.js';
 
 const BACKFILL_LIMIT = 10;
 const MAX_CACHE_ENTRIES = 2000;
@@ -9,12 +10,17 @@ const AUTH_RECOVERY_COOLDOWN_MS = 60_000;
 const RESULT_STATES = new Set(['continue', 'no_action', 'needs_user', 'waiting', 'uncertain']);
 const keyOf = candidate => `${candidate.provider}:${candidate.session}`;
 const activityOf = candidate => Number.isFinite(candidate.lastActivityAt) ? candidate.lastActivityAt : 0;
-const goalOf = candidate => candidate.providerGoal && typeof candidate.providerGoal === 'object'
-  ? [candidate.providerGoal.objective ?? null, candidate.providerGoal.status ?? null, candidate.providerGoal.updatedAt ?? null,
-    candidate.providerGoal.textTruncated === true] : null;
+const turnOf = candidate => candidate.provider === 'codex' && typeof candidate.latestTurnId === 'string' && candidate.latestTurnId
+  ? candidate.latestTurnId : null;
+const goalOf = candidate => providerGoalEvidence(candidate.providerGoal);
+const legacyRevision = candidate => createHash('sha256').update(JSON.stringify([
+  candidate.provider, candidate.session, candidate.cwd, activityOf(candidate), ...(candidate.isRunning === true ? ['running'] : []),
+  ...(goalOf(candidate) === null ? [] : ['goal', [candidate.providerGoal.objective ?? null, candidate.providerGoal.status ?? null,
+    candidate.providerGoal.updatedAt ?? null, candidate.providerGoal.textTruncated === true]]),
+])).digest('hex');
 const goalRevisionOf = candidate => goalOf(candidate) === null ? null : createHash('sha256').update(JSON.stringify(goalOf(candidate))).digest('hex');
 export const continuationAnalysisRevision = candidate => createHash('sha256')
-  .update(JSON.stringify([candidate.provider, candidate.session, candidate.cwd, activityOf(candidate),
+  .update(JSON.stringify([candidate.provider, candidate.session, candidate.cwd, turnOf(candidate) ? ['turn', turnOf(candidate)] : activityOf(candidate),
     ...(candidate.isRunning === true ? ['running'] : []), ...(goalOf(candidate) === null ? [] : ['goal', goalOf(candidate)])]))
   .digest('hex');
 const eligible = candidate => candidate.capabilities?.canAnalyze === true &&
@@ -50,11 +56,19 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   const known = new Map(document.known.slice(-MAX_CACHE_ENTRIES));
   const entries = new Map(document.entries.slice(-MAX_CACHE_ENTRIES));
   const candidates = new Map();
+  const observedCandidate = candidate => {
+    const previous = known.get(keyOf(candidate));
+    // A bounded discovery may skip this turn probe. Preserve its prior ID
+    // only while identity and activity still match; changed activity must be read.
+    return !turnOf(candidate) && candidate.provider === 'codex' && previous?.latestTurnId &&
+      previous.cwd === candidate.cwd && previous.activity === activityOf(candidate)
+      ? { ...candidate, latestTurnId: previous.latestTurnId } : candidate;
+  };
   const providerStatuses = new Map(), signedOutChecks = new Map();
   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 +161,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 +184,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 +221,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,9 +243,9 @@ 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);
+        for (const candidate of sessions) candidates.set(keyOf(candidate), observedCandidate(candidate));
         const sorted = [...candidates.values()].sort((a, b) => activityOf(b) - activityOf(a) || keyOf(a).localeCompare(keyOf(b)));
         const backfill = document.initialized ? new Set() : new Set(sorted.slice(0, BACKFILL_LIMIT).map(keyOf));
         let dirty = !document.initialized;
@@ -242,10 +256,19 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
           // Old cache formats did not observe goal/tracking metadata. Establish
           // their baseline once, rather than mistaking the upgrade for activity.
           const goalObserved = candidate.goalReadState !== 'unavailable';
-          const goalChanged = previous && Object.hasOwn(previous, 'goalRevision') && previous.goalObserved !== false && goalObserved && previous.goalRevision !== goalRevision;
+          const goalChanged = previous && previous.goalEvidenceVersion === 1 && Object.hasOwn(previous, 'goalRevision') && previous.goalObserved !== false && goalObserved && previous.goalRevision !== goalRevision;
           const trackingEnabled = candidate.tracked === true && (!previous || Object.hasOwn(previous, 'tracked') && previous.tracked !== true);
-          const newActivity = document.initialized && (previous ? active > previous.activity || (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
+          // A known turn boundary is stronger than updated_at: tool/status
+          // events in that same turn must not enqueue or cancel paid inference.
+          const newActivity = document.initialized && (previous ?
+            (turnOf(candidate) && previous.latestTurnId ? turnOf(candidate) !== previous.latestTurnId : active > previous.activity) ||
+            (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
           const entry = entries.get(key);
+          // Rebase unchanged old cache keys once without rerunning historical
+          // inference when semantic goal/turn keys become available.
+          if (entry && entry.revision !== revision && entry.cwd === candidate.cwd && entry.revision === legacyRevision(candidate)) {
+            entry.revision = revision; dirty = true;
+          }
           // Migrate prior idle cache entries without treating historical sessions
           // as fresh activity. Its old revision already proves this exact cwd.
           if (entry && !entry.cwd && entry.revision === continuationAnalysisRevision({ ...candidate, isRunning: false })) {
@@ -261,9 +284,10 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
           if (eligible(candidate) && (backfill.has(key) || newActivity || recheck || trackingEnabled || goalChanged || schemaRefresh)) {
             dirty = enqueue(candidate, recheck || trackingEnabled || goalChanged || schemaRefresh, trackingEnabled || goalChanged || schemaRefresh) || dirty;
           }
-          if (previous?.revision !== revision || previous?.goalObserved !== goalObserved || (previous?.tracked === true) !== (candidate.tracked === true) ||
+          if (previous?.revision !== revision || previous?.activity !== active || previous?.goalEvidenceVersion !== 1 || previous?.goalObserved !== goalObserved || (previous?.tracked === true) !== (candidate.tracked === true) ||
               previous && (!Object.hasOwn(previous, 'goalRevision') || !Object.hasOwn(previous, 'tracked'))) {
-            known.delete(key); known.set(key, { revision, activity: active, isRunning: candidate.isRunning, tracked: candidate.tracked === true, goalRevision, goalObserved }); dirty = true;
+            known.delete(key); known.set(key, { revision, cwd: candidate.cwd, activity: active, isRunning: candidate.isRunning, latestTurnId: turnOf(candidate),
+              tracked: candidate.tracked === true, goalRevision, goalObserved, goalEvidenceVersion: 1 }); dirty = true;
           }
         }
         // Cancelling owned analysis is separate from stopping the original
@@ -280,6 +304,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       startDrain();
     },
     project(candidate) {
+      candidate = observedCandidate(candidate);
       const revision = continuationAnalysisRevision(candidate), entry = entries.get(keyOf(candidate));
       let analysis = entry?.revision === revision ? { ...entry.result, revision, requestId: entry.requestId } : { state: 'unanalysed', revision };
       const previous = entry?.cwd === candidate.cwd ? entry.settledResult : null;
@@ -295,8 +320,9 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     async request(candidate, { requestId } = {}) {
       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.');
+      candidate = observedCandidate(candidate);
       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));
@@ -306,8 +332,9 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       startDrain();
     },
     async invalidate(candidate) {
+      candidate = observedCandidate(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 +343,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 +356,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/session-supervision/codex-app-server.js

@@ -262,6 +262,7 @@ export async function readCodexObservation(client, session, { deadline = Date.no
     const page = await client.request('thread/turns/list', { threadId: session, cursor: null, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded' }, timeout());
     if (Array.isArray(page?.data) && page.data.length === 1 && ['inProgress', 'completed', 'interrupted', 'failed'].includes(page.data[0]?.status)) {
       observation.isRunning = page.data[0].status === 'inProgress';
+      if (typeof page.data[0].id === 'string' && page.data[0].id && page.data[0].id.length <= 160) observation.latestTurnId = page.data[0].id;
     }
   } catch (error) {
     if (['timeout', 'closed', 'unavailable'].includes(error?.code)) return { goalReadState: 'unavailable', providerUnavailable: true };

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

@@ -1,6 +1,6 @@
 import { readCodexConversation } from './codex-app-server.js';
 import { readClaudeConversation } from './claude-sessions.js';
-import { boundConversation, boundProviderGoal, sanitizedText } from './conversation-context.js';
+import { boundConversation, boundProviderGoal, providerGoalEvidence, sanitizedText } from './conversation-context.js';
 import { runStructuredProviderReview } from '../sqm/review-worker.js';
 import { inspectProviderStatus } from '../desktop-status.js';
 import { createHash } from 'node:crypto';
@@ -152,7 +152,7 @@ export async function readContinuationContext(candidate, { signal, readContext,
   const context = boundConversation(raw?.messages, { truncated: raw?.truncated === true, incomplete: raw?.incomplete === true });
   const providerGoal = boundProviderGoal(raw?.providerGoal);
   const contextDigest = createHash('sha256').update(JSON.stringify({ provider: candidate.provider, session: candidate.session, cwd: candidate.cwd, ...context,
-    ...(providerGoal ? { providerGoal } : {}) })).digest('hex');
+    ...(providerGoal ? { providerGoal: providerGoalEvidence(providerGoal) } : {}) })).digest('hex');
   return { ...context, providerGoal, contextDigest, awaitingTurn: raw?.awaitingTurn === true, settledTurnId: typeof raw?.settledTurnId === 'string' ? raw.settledTurnId.slice(0, 160) : null };
 }
 
@@ -185,7 +185,7 @@ export async function analyzeContinuation(candidate, {
     basis: [{ role: 'goal', turnRef: 'provider-goal', snippet: context.providerGoal.objective.slice(0, 280) }],
   };
   if (previousAnalysis?.analysisVersion === CONTINUATION_ANALYSIS_VERSION && previousAnalysis?.contextDigest === context.contextDigest && STATES.includes(previousAnalysis.state)) {
-    return { ...snapshot, ...previousAnalysis };
+    return { ...previousAnalysis, ...snapshot };
   }
   if (context.incomplete || !context.messages.length) return uncertain('The latest request or reply could not be read completely. Open the original conversation to review it, then retry.', 'context_incomplete');
   let result;

package/src/session-supervision/conversation-context.js

@@ -21,6 +21,13 @@ export function textContent(content) {
 }
 
 const GOAL_STATES = new Set(['active', 'paused', 'blocked', 'usageLimited', 'budgetLimited', 'complete']);
+// Goal timestamps can advance with provider bookkeeping without changing the
+// evidence relevant to triage. Keep timestamps for provenance, not cache keys.
+export function providerGoalEvidence(goal) {
+  return goal && typeof goal === 'object' ? { objective: goal.objective ?? null, status: goal.status ?? null,
+    textTruncated: goal.textTruncated === true } : null;
+}
+
 // Original provider metadata is evidence about the goal, never permission for
 // this separate read-only classifier to execute work or change provider limits.
 export function boundProviderGoal(goal) {

package/src/session-supervision/index.js

@@ -114,6 +114,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     return { provider: item.provider, session: item.session, cwd: item.cwd,
       title: sessionTitle(item.title) || (item.provider === 'codex' ? codexTitles.get(item.session) || '' : ''), source: item.source,
       ...(typeof isRunning === 'boolean' ? { isRunning } : {}),
+      ...(item.latestTurnId ? { latestTurnId: item.latestTurnId } : {}),
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,

package/src/sqm/provider-diagnostics.js

@@ -11,7 +11,7 @@ export function safeProviderDiagnostic(value) {
   if (SIGNALS.has(value.signal)) result.signal = value.signal;
   if (Number.isInteger(value.outputBytes) && value.outputBytes >= 0 && value.outputBytes <= 2147483647) result.outputBytes = value.outputBytes;
   if (value.retryAttempt === 0 || value.retryAttempt === 1) result.retryAttempt = value.retryAttempt;
-  if (typeof value.model === "string" && /^(?:gpt-6-(?:astra)|gpt-6\.1-sol|claude-(?:sonnet|opus|haiku)-[0-9]+(?:-[0-9]+){0,3})$/.test(value.model) && value.model.length <= 64) result.model = value.model;
+  if (typeof value.model === "string" && /^(?:gpt-6-(?:astra|sol)|gpt-6\.1-sol|claude-(?:sonnet|opus|haiku)-[0-9]+(?:-[0-9]+){0,3})$/.test(value.model) && value.model.length <= 64) result.model = value.model;
   return result;
 }
 

package/src/sqm/review-worker.js

@@ -20,7 +20,8 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 75_000;
 const DEFAULT_EXECUTION_TIMEOUT_MS = 240_000;
 // Keep analysis independent of interactive config. Availability varies by
 // account and CLI; only an explicit model rejection may try the next model.
-export const SQM_CODEX_MODELS = Object.freeze(["gpt-6-astra", "gpt-6.1-sol"]);
+// Background SQM and conversation triage use Sol models to limit usage.
+export const SQM_CODEX_MODELS = Object.freeze(["gpt-6.1-sol", "gpt-6-sol"]);
 export const SQM_CODEX_MODEL = SQM_CODEX_MODELS[0];
 
 export class SqmLocalReviewError extends Error {
@@ -113,6 +114,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 +169,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 +250,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 +258,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 +329,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();