@awak-app/simy-cli 0.5.47 → 0.5.49

package/package.json

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

package/src/agent.js

@@ -1,6 +1,7 @@
+import { createDesktopAccessPolicy, desktopAccessReady, requireDesktopAccess } from './desktop-access.js';
 import { readSqmEnabled, writeSqmEnabled } from "./desktop-sqm-settings.js";
 import { createServer } from "node:http";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 
@@ -142,6 +143,7 @@ import { inspectSqmAgentSkill, installSqmAgentSkill } from "./sqm/agent-skill.js
 import {
   createSqmLocalReviewApi,
   createSqmLocalReviewWorker,
+  runStructuredProviderReview,
 } from "./sqm/review-worker.js";
 import { createCodexWorkPatternSync, workPatternHistoryHomes } from "./codex-work-pattern-sync.js";
 import {
@@ -159,6 +161,7 @@ export async function startAgent({
   sessionRoot,
   updateManager = null,
   deferStartupSynchronization = false,
+  enforceDesktopAccess = false,
   onDesktopStatusChange = null,
   dependencies = {},
   quiet = false,
@@ -228,14 +231,13 @@ export async function startAgent({
     availableCapabilities = withCliContract({
       ...contractSourceCapabilities,
       ...(features ? { features: { ...features, ...(Object.hasOwn(features, "sqm_local_review")
-        ? { sqm_local_review: features.sqm_local_review === true && sqmEnabled && !pendingOrganization } : {}) } } : {}),
+        ? { sqm_local_review: features.sqm_local_review === true && sqmEnabled && !pendingOrganization && desktopWorkAllowed() } : {}) } } : {}),
       ...(providerStatuses ? { provider_statuses: providerStatuses } : {}),
     }, installMode, {
       authenticated: isSessionValid(session, Date.now(), apiOrigin) && Boolean(session?.device_id),
     });
     return availableCapabilities;
   };
-  refreshAvailableCapabilities();
   const heartbeatDevice = dependencies.heartbeatDevice || heartbeatLocalDevice;
   const reclaimDevice = dependencies.reclaimDevice || reclaimLocalDevice;
   const runOptions = dependencies.runOptions || {};
@@ -257,6 +259,33 @@ export async function startAgent({
     if (shuttingDown) return;
     try { onDesktopStatusChange?.(); } catch { /* Desktop status polling remains available. */ }
   };
+  const desktopAccess = createDesktopAccessPolicy({
+    readSession: () => session,
+    isValid: value => isSessionValid(value, Date.now(), apiOrigin),
+    isSwitching: () => Boolean(pendingOrganization),
+    onChange: notifyDesktopStatusChange,
+    fetchAccess: dependencies.fetchDesktopAccess || (async selected => {
+      const response = await (dependencies.fetch || globalThis.fetch)(webApiUrl('desktop-access', {
+        webOrigin: apiOrigin, apiBaseUrl: selected.api_base_url,
+      }), { headers: webApiHeaders({ token: selected.token }), signal: AbortSignal.timeout(10_000), cache: 'no-store' });
+      if (!response.ok) throw Object.assign(new Error('Desktop access could not be verified.'), { status: response.status });
+      return response.json();
+    }),
+  });
+  const desktopScopeRevision = () => createHash('sha256').update(JSON.stringify([
+    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 = () => !enforceDesktopAccess || desktopAccessReady(desktopAccess.snapshot());
+  const authorizeDesktopWork = async expectedScope => {
+    if (enforceDesktopAccess) {
+      requireDesktopAccess(await desktopAccess.refresh());
+      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;
   let sqmLocalReviewWorker = null;
   let codexWorkPatternSync = null;
@@ -264,6 +293,7 @@ export async function startAgent({
 
   let codexWorkPatternSkipReason = null;
   const pollCodexWorkPatterns = () => {
+    if (!desktopWorkAllowed()) return Promise.resolve();
     if (shuttingDown) return;
     const skipReason = codexWorkPatternSkipReasonFor({
       daemon,
@@ -385,8 +415,10 @@ export async function startAgent({
   };
 
   const requireRunProvider = async (run) => {
+    const scope = await authorizeDesktopWork();
     const backend = run.request.backend;
     const inspection = await inspectReadyBackend(backend, { force: true });
+    await authorizeDesktopWork(scope);
     if (!inspection.compatible) {
       throw Object.assign(new Error(backendPreflightSummary(backend, inspection)), {
         code: `desktop_executor_${inspection.status}`,
@@ -412,7 +444,8 @@ export async function startAgent({
         if (!Array.isArray(payload.organizations)) throw new Error("Invalid organization list.");
         if (session !== requestedSession) return;
         organizationItems = payload.organizations.filter(org => typeof org.id === "string" && typeof org.name === "string")
-          .slice(0, 100).map(org => ({ id: org.id, name: org.name.slice(0, 120) }));
+          .slice(0, 100).map(org => ({ id: org.id, name: org.name.slice(0, 120),
+            ...(typeof org.slug === 'string' && org.slug && org.slug.length <= 160 && !/[\/\\?#\x00-\x1f]/.test(org.slug) ? { slug: org.slug } : {}) }));
         organizationState = "ready";
       } catch {
         if (session === requestedSession) organizationState = "unavailable";
@@ -421,16 +454,23 @@ export async function startAgent({
     return organizationRefresh;
   };
   const requestDesktopLogin = (organizationId = null) => {
+    let organizationSlug = null;
     if (organizationId) {
       if (!isSessionValid(session, Date.now(), apiOrigin)) throw new Error("Sign in before switching organizations.");
       if (organizationState !== "ready" || !organizationItems.some(org => org.id === organizationId)) throw new Error("Refresh the organization list before selecting an organization.");
+      organizationSlug = organizationItems.find(org => org.id === organizationId)?.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 };
       loginUrl = null;
       refreshAvailableCapabilities();
       notifyDesktopStatusChange();
-    } else if (isSessionValid(session, Date.now(), apiOrigin)) return null;
+    } else if (isSessionValid(session, Date.now(), apiOrigin)) {
+      if (!enforceDesktopAccess || desktopAccess.snapshot().state !== 'signed_out') return null;
+      authNonce = randomBytes(16).toString("base64url");
+      loginUrl = null;
+    }
     if (!loginUrl) {
       loginUrl = new URL("/local-cli/connect", apiOrigin);
       loginUrl.searchParams.set("port", String(port));
@@ -438,7 +478,10 @@ export async function startAgent({
       loginUrl.searchParams.set("cli_version", CLI_VERSION);
       loginUrl.searchParams.set("api_contract_version", String(CLI_API_CONTRACT_VERSION));
       if (installMode) loginUrl.searchParams.set("install_mode", installMode);
-      if (organizationId) loginUrl.searchParams.set("org_id", organizationId);
+      if (organizationId) {
+        loginUrl.searchParams.set('org_id', organizationId);
+        loginUrl.searchParams.set('org_slug', organizationSlug);
+      }
     }
     return loginUrl.toString();
   };
@@ -452,6 +495,7 @@ export async function startAgent({
   };
 
   const restoreRemoteRuns = async () => {
+    if (!desktopWorkAllowed()) return;
     if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin) || !session?.device_id) return;
     const snapshots = dependencies.listRemoteRuns
       ? await dependencies.listRemoteRuns({
@@ -518,6 +562,7 @@ export async function startAgent({
   };
 
   const restoreLocalCodingRuns = async () => {
+    if (!desktopWorkAllowed()) return;
     const { snapshots, errors } = await loadCodingRunSnapshots(codingRunStateRoot);
     for (const error of errors) {
       reportStartupConnectionError(new Error(`Coding run ${error.id}: ${error.message}`), quiet);
@@ -548,6 +593,7 @@ export async function startAgent({
   };
 
   const monitorCodingRuns = () => {
+    if (!desktopWorkAllowed()) return Promise.resolve();
     if (!daemon || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve();
     if (codingRunMonitorInFlight) return codingRunMonitorInFlight;
     codingRunMonitorInFlight = (async () => {
@@ -564,6 +610,7 @@ export async function startAgent({
   };
 
   const startCodingRunMonitor = () => {
+    if (!desktopWorkAllowed()) return;
     if (!daemon || codingRunMonitorTimer) return;
     codingRunMonitorTimer = setInterval(() => {
       void monitorCodingRuns().catch((error) => reportStartupConnectionError(error, quiet));
@@ -579,6 +626,7 @@ export async function startAgent({
     let deviceHeartbeatSucceeded = false;
     const advertisedProviders = JSON.stringify(providerStatuses);
     heartbeatInFlight = Promise.resolve()
+      .then(async () => { if (enforceDesktopAccess) await desktopAccess.refresh(true); })
       .then(() =>
         heartbeatDevice({
           apiOrigin,
@@ -604,12 +652,12 @@ export async function startAgent({
           }
           pollCodexWorkPatterns();
         };
-        if (deferStartupSynchronization) {
+        if (desktopWorkAllowed() && deferStartupSynchronization) {
           void publishVerifiedProviders().catch((error) => reportHeartbeatError(error, quiet));
-        } else {
+        } else if (desktopWorkAllowed()) {
           await publishVerifiedProviders();
         }
-        if (shuttingDown || pendingOrganization) return false;
+        if (shuttingDown || pendingOrganization || !desktopWorkAllowed()) return false;
         const sqmResult = sqmEnabled && sqmLocalReviewWorker
           ? await sqmLocalReviewWorker.poll()
           : null;
@@ -661,9 +709,11 @@ export async function startAgent({
   };
 
   const scanRepositories = async (root) => {
+    const scope = await authorizeDesktopWork();
     const scan = dependencies.scanRepositories
       ? await dependencies.scanRepositories(root)
       : await scanGitRepositories(root);
+    await authorizeDesktopWork(scope);
     repositoryInventory = mergeRepositoryInventory(repositoryInventory, scan.repositories);
     authorizedRepositoryRoots = [
       ...new Set([...authorizedRepositoryRoots, scan.root].filter(Boolean)),
@@ -731,12 +781,14 @@ export async function startAgent({
       workspaceRoot: dependencies.localTaskWorkspaceRoot,
       resolveRepository: ensureRepositoryIndexed,
       runLocalTask: async (task, options) => {
+        const scope = await authorizeDesktopWork();
         const inspection = await inspectReadyBackend(task.backend);
         if (!inspection.compatible) {
           throw Object.assign(new Error(backendPreflightSummary(task.backend, inspection)), {
             code: `desktop_executor_${inspection.status}`,
           });
         }
+        await authorizeDesktopWork(scope);
         return (dependencies.runLocalTask || startLocalTask)(task, options);
       },
       attachmentStore: localTaskAttachmentStore,
@@ -762,9 +814,13 @@ export async function startAgent({
     sqmLocalReviewWorker = createWorker({
       api: sqmApi,
       beginWork: () => acquireUpdateWork(updateManager),
-      runReview: dependencies.runSqmLocalReview,
+      runReview: async (request, provider) => {
+        const scope = await authorizeDesktopWork();
+        const beforeDispatch = () => authorizeDesktopWork(scope);
+        return (dependencies.runSqmLocalReview || ((value, selected, options) => runStructuredProviderReview(selected, value, options)))(request, provider, { beforeDispatch });
+      },
       onChange: notifyDesktopStatusChange,
-      getProvider: () => availableCapabilities?.features?.sqm_local_review !== true ? null : ["codex", "claude"].find(
+      getProvider: () => !desktopWorkAllowed() || availableCapabilities?.features?.sqm_local_review !== true ? null : ["codex", "claude"].find(
         (provider) => availableCapabilities?.backends?.[provider] === true &&
           providerStatuses[provider]?.state === "ready",
       ) || null,
@@ -773,6 +829,7 @@ export async function startAgent({
   }
 
   const selectRepository = async (run, repository) => {
+    await authorizeDesktopWork();
     if (run) ensureAcceptingNewWork(updateManager);
     const selected = repository?.local_path
       ? repositoryInventory.find(
@@ -812,6 +869,14 @@ export async function startAgent({
 
       const url = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
       const agenticLoopPath = canonicalAgenticLoopPath(url.pathname);
+      const desktopRecoveryRoute = ['/v1/health', '/v1/capabilities', '/v1/auth/complete'].includes(url.pathname) ||
+        req.method === 'POST' && (/^\/v1\/local-tasks\/[^/]+\/control$/.test(url.pathname) || /^\/v1\/agentic-loop\/[^/]+\/control$/.test(agenticLoopPath));
+      let requestAccessScope;
+      if (enforceDesktopAccess && !desktopRecoveryRoute) {
+        try { requestAccessScope = await authorizeDesktopWork(); }
+        catch { json(res, 403, { error: 'Desktop access is required.', code: 'desktop_access_required', access: desktopAccess.snapshot() }); return; }
+      }
+
       const startsLocalExecution =
         url.pathname === "/v1/local-tasks/start" ||
         url.pathname === "/v1/direct-execution/start";
@@ -1168,7 +1233,7 @@ export async function startAgent({
       }
       const localTaskControlMatch = url.pathname.match(/^\/v1\/local-tasks\/([^/]+)\/control$/);
       if (req.method === "POST" && localTaskControlMatch) {
-        if (!isSessionValid(session, Date.now(), apiOrigin)) {
+        if (!enforceDesktopAccess && !isSessionValid(session, Date.now(), apiOrigin)) {
           json(res, 401, { error: "simy session expired; run simy again" });
           return;
         }
@@ -1485,6 +1550,7 @@ export async function startAgent({
           const runLocalTask =
             dependencies.runLocalTask ||
             ((localTask) => startLocalTask(localTask, { session, apiOrigin }));
+          await authorizeDesktopWork(requestAccessScope);
           task.operation_promise = Promise.resolve(runLocalTask(task))
             .catch(async (error) => {
               task.status = "failed";
@@ -1600,6 +1666,7 @@ export async function startAgent({
           });
           return;
         }
+        await authorizeDesktopWork(requestAccessScope);
         const task = createDirectTask({
           instruction,
           backend: body.backend,
@@ -1795,6 +1862,7 @@ export async function startAgent({
           await cleanupRunAttachments(stagedAttachments);
           throw error;
         }
+        await authorizeDesktopWork(requestAccessScope);
         void startLocalCodingRun(run, dependencies.runOptions);
         json(res, 202, { ok: true, run_id: run.id });
         return;
@@ -1802,7 +1870,7 @@ export async function startAgent({
 
       const controlMatch = agenticLoopPath.match(/^\/v1\/agentic-loop\/([^/]+)\/control$/);
       if (req.method === "POST" && controlMatch) {
-        if (!isSessionValid(session, Date.now(), apiOrigin)) {
+        if (!enforceDesktopAccess && !isSessionValid(session, Date.now(), apiOrigin)) {
           json(res, 401, { error: "simy session expired; run simy again" });
           return;
         }
@@ -1821,6 +1889,8 @@ export async function startAgent({
         } else if (body.action === "pause") {
           pauseLocalCodingRun(run);
         } else if (body.action === "resume") {
+          try { await authorizeDesktopWork(); }
+          catch { json(res, 403, { error: "Desktop access is required.", code: "desktop_access_required" }); return; }
           if (!acceptsNewWork(updateManager)) {
             json(res, 503, updateInProgressResponse(updateManager));
             return;
@@ -2074,6 +2144,7 @@ export async function startAgent({
 
   const synchronizeStartup = async () => {
     try {
+      if (enforceDesktopAccess) { await desktopAccess.refresh(); if (!desktopWorkAllowed()) { await heartbeat(); return; } }
       await refreshAuthorizedRepositoryInventory();
       if (shuttingDown) return;
       await heartbeat();
@@ -2088,7 +2159,7 @@ export async function startAgent({
   if (deferStartupSynchronization) {
     // The desktop can show restored tasks and account state while network and
     // provider checks run. Unknown remains unknown until each probe succeeds.
-    void readProviderStatuses().catch((error) => reportStartupConnectionError(error, quiet));
+    if (desktopWorkAllowed()) void readProviderStatuses().catch((error) => reportStartupConnectionError(error, quiet));
     if (isSessionValid(session, Date.now(), apiOrigin)) {
       startHeartbeatTimer();
       void synchronizeStartup();
@@ -2129,7 +2200,8 @@ export async function startAgent({
   const getDesktopStatus = async () => {
     const auth = desktopAuthStatus(session, { webOrigin: apiOrigin });
     if (auth.state === "signed_in" && organizationState === "unknown") void refreshOrganizations();
-    if (deferStartupSynchronization && !shuttingDown) {
+    if (enforceDesktopAccess) void desktopAccess.refresh().catch(() => {});
+    if (deferStartupSynchronization && !shuttingDown && desktopWorkAllowed()) {
       // Cached checks return immediately; expired checks refresh in the
       // background without making the desktop frame wait for subprocesses.
       void readProviderStatuses().catch((error) => reportStartupConnectionError(error, quiet));
@@ -2143,11 +2215,12 @@ export async function startAgent({
       version: CLI_VERSION,
       webOrigin: apiOrigin,
       auth,
+      ...(enforceDesktopAccess ? { access: { ...desktopAccess.snapshot(), revision: desktopScopeRevision() } } : {}),
       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() },
-      sqm: { enabled: sqmEnabled, canEnable: auth.state === "signed_in" && Boolean(session?.account_id && session?.organization_id) && !pendingOrganization,
+      sqm: { enabled: sqmEnabled, canEnable: auth.state === "signed_in" && Boolean(session?.account_id && session?.organization_id) && !pendingOrganization && desktopWorkAllowed(),
         activeJobId: sqmLocalReviewWorker?.snapshot?.().active_job_id ?? null,
         issue: sqmLocalReviewWorker?.snapshot?.().issue ?? null,
         providerReady: [codex, claude].some(provider => provider?.state === "ready") },
@@ -2173,9 +2246,20 @@ export async function startAgent({
       return requestDesktopLogin();
     },
     requestDesktopLogin,
+    async refreshDesktopAccess() {
+      const previous = desktopAccess.snapshot().state;
+      const result = await desktopAccess.refresh(true);
+      if (enforceDesktopAccess && result.state === 'ready' && previous !== 'ready' && !shuttingDown) {
+        void synchronizeAuthorizedSession().catch(error => reportStartupConnectionError(error, quiet));
+      }
+      return { ...result, revision: desktopScopeRevision() };
+    },
+    getDesktopAccess: () => ({ ...desktopAccess.snapshot(), revision: desktopScopeRevision() }),
+    requireDesktopAccess: authorizeDesktopWork,
     refreshOrganizations,
     cancelOrganizationSelection() { authNonce = randomBytes(16).toString("base64url"); pendingOrganization = null; loginUrl = null; refreshAvailableCapabilities(); notifyDesktopStatusChange(); },
     async setSqmEnabled(enabled) {
+      if (enabled) await authorizeDesktopWork();
       if (!isSessionValid(session, Date.now(), apiOrigin) || pendingOrganization) throw new Error("Sign in to an organization first.");
       const settingsSession = session;
       await writeSqmEnabled(sessionRoot, apiOrigin, settingsSession, enabled);
@@ -2206,6 +2290,7 @@ export async function startAgent({
       scanRepositories,
       selectRepository,
       create: (input) => withUpdateWork(updateManager, async () => {
+        const scope = await authorizeDesktopWork();
         if (!isSessionValid(session, Date.now(), apiOrigin)) {
           throw new Error("Sign in to SIMY before starting a coding task.");
         }
@@ -2252,6 +2337,7 @@ export async function startAgent({
         const run = createRun({ runId, request, session, apiOrigin, localStateRoot: codingRunStateRoot });
         await saveCodingRunSnapshot(codingRunStateRoot, run.snapshot);
         registry.create(run);
+        await authorizeDesktopWork(scope);
         void startLocalCodingRun(run, runOptions);
         return run;
       }),
@@ -2265,7 +2351,10 @@ export async function startAgent({
           await requireRunProvider(run);
           return applyLocalHumanDecision(run, decision, runOptions);
         }),
-      queueGuidance: queueLocalCodingGuidance,
+      queueGuidance: (run, guidance) => {
+        if (enforceDesktopAccess) requireDesktopAccess(desktopAccess.snapshot());
+        return queueLocalCodingGuidance(run, guidance);
+      },
       pause: pauseLocalCodingRun,
       resume: (run) => withUpdateWork(updateManager, async () => {
         await requireRunProvider(run);
@@ -2273,9 +2362,10 @@ export async function startAgent({
       }),
       stop: stopLocalCodingRun,
       recheck: (run) =>
-        withUpdateWork(updateManager, () =>
-          recheckLocalCodingRun(run, { collectEvidence: runOptions.collectEvidence }),
-        ),
+        withUpdateWork(updateManager, async () => {
+          await authorizeDesktopWork();
+          return recheckLocalCodingRun(run, { collectEvidence: runOptions.collectEvidence });
+        }),
     },
   };
 }

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.5.47";
+export const CLI_VERSION = "0.5.49";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

package/src/delivery-hooks/supervisor.js

@@ -54,7 +54,7 @@ export function parseAgentCheckpoint(output, expectedSession) {
 
 // The provider CLI is a new process. It is used only for an exact Codex UUID
 // enrolled for this recovery channel after a corroborated process exit.
-export async function executeCodexResume(record, { signal, root, leaseId, executable = resolveBackendExecutable, currentTime = Date.now, onActivity = () => {} } = {}) {
+export async function executeCodexResume(record, { signal, root, leaseId, executable = resolveBackendExecutable, currentTime = Date.now, onActivity = () => {}, beforeDispatch = async () => {} } = {}) {
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
   const binary = await executable('codex');
   if (!binary) throw new Error('Codex executable unavailable.');
@@ -70,6 +70,9 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   const args = ['exec', '--json', '--skip-git-repo-check', '-s', sandbox, '-m', run.managed.resumeModel, 'resume', record.session, prompt];
   if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
   if (currentTime() >= run.deadline) throw new Error('Managed recovery deadline expired before provider dispatch.');
+  await beforeDispatch();
+  if (signal?.aborted) throw new Error('Managed recovery cancelled before provider dispatch.');
+  if (currentTime() >= run.deadline) throw new Error('Managed recovery deadline expired before provider dispatch.');
   return new Promise((resolve, reject) => {
     const child = spawn(binary, args, { cwd: record.cwd, stdio: ['ignore', 'pipe', 'pipe'], signal,
       env: { ...process.env, SIMY_HOME: dirname(root) } });
@@ -116,7 +119,7 @@ export async function executeCodexResume(record, { signal, root, leaseId, execut
   });
 }
 
-export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim } = {}) {
+export async function tickManagedTasks({ root, now = Date.now(), execute, inspectProcess = processIdentity, signal, beforeClaim, authorizeDispatch } = {}) {
   const tickWallStart = Date.now();
   const currentTime = () => now + Math.max(0, Date.now() - tickWallStart);
   if (signal?.aborted) return;
@@ -152,6 +155,16 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
     if (run.managed.executionUncertain && run.managed.recoveryDiagnosisDecisionId !== run.managed.decision?.id) continue;
     if (['pending', 'transferred', 'pending_received'].includes(run.managed.handoff?.status)) continue;
     if (run.state !== 'recovery_required' || !causeAllowed || !run.managed.autoRecovery || run.managed.pendingApproval || run.managed.autonomyPolicy && run.managed.decision?.outcome === 'wait' && !approvedWait || appServer && run.managed.nextAttemptAt > claimNow) continue;
+    let authorizationScope;
+    const authorizeClaim = async () => {
+      if (!authorizeDispatch) return;
+      const latest = await authorizeDispatch();
+      if (authorizationScope !== undefined && latest !== authorizationScope) throw Object.assign(new Error("Desktop authorization scope changed."), { code: "desktop_access_required" });
+      authorizationScope = latest;
+    };
+    if (authorizeDispatch) {
+      try { await authorizeClaim(); } catch { continue; }
+    }
     if (beforeClaim) {
       try {
         const prepared = await beforeClaim(record);
@@ -237,6 +250,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         else if (['local_edit', 'local_test'].includes(claimed.run.managed.decision?.action.kind) &&
           (await listRecords(root)).some(other => other.cwd === claimed.cwd && other.run?.managed?.executionUncertain)) result = { code: -3, busy: true };
         if (!result) {
+        await authorizeClaim();
         const runner = execute || (appServer ? executeCodexAppServer : executeCodexResume);
         result = await runner(claimed, { signal: controller.signal, root, leaseId, currentTime,
           onActivity: observation => { lastActivityAt = currentTime(); waitingForTool = observation?.waitingForTool === true; },
@@ -268,11 +282,14 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
               }
               return current;
             });
+            await authorizeClaim();
           } });
         }
       }
-    } catch (error) { result = { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
-      errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
+    } catch (error) { result = error?.code === 'desktop_access_required'
+      ? { code: -3, busy: true, accessDenied: true }
+      : { code: controller.signal.aborted ? -2 : -1, cancelled: controller.signal.aborted,
+        errorCode: error?.code || 'provider_error', restorationUnverified: error?.restorationUnverified === true }; }
     finally { clearTimeout(timeout); clearInterval(watch); signal?.removeEventListener('abort', abort); }
     if (controller.signal.aborted) result = { ...result, code: -2, cancelled: true };
     if (claimed.run.managed.maxTokens && !usage && !result.busy && dispatched) {
@@ -319,7 +336,7 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         checkpointRevision: live.revision, outcome: result.busy ? 'busy' : result.cancelled ? 'cancelled' : result.code === 0 ? 'checkpoint' : 'failed',
         errorCode: result.code === 0 || result.busy || result.cancelled ? null : safeProviderCode(result.errorCode),
         restorationUnverified: result.restorationUnverified === true,
-        reason: result.busy ? 'Exact provider session currently has another writer.' : result.cancelled ? 'Managed recovery cancelled before completion.' : result.code === 0 ? 'Structured checkpoint recorded.' : 'Provider failed or returned an invalid checkpoint.',
+        reason: result.accessDenied ? 'Desktop organization access is required before another provider turn.' : result.busy ? 'Exact provider session currently has another writer.' : result.cancelled ? 'Managed recovery cancelled before completion.' : result.code === 0 ? 'Structured checkpoint recorded.' : 'Provider failed or returned an invalid checkpoint.',
         nextStep: live.nextStep });
       live.managed.attempts = live.managed.attempts.slice(-20);
       if (result.restorationUnverified) {
@@ -340,8 +357,16 @@ export async function tickManagedTasks({ root, now = Date.now(), execute, inspec
         live.state = 'recovery_required'; live.managed.autoRecovery = false;
         live.reason = 'Provider usage was unavailable; token-budgeted continuation cannot safely start another turn.';
       } else if (result.busy) {
+        if (result.accessDenied && dispatched) {
+          // The final guard rejected before the provider call. Keep its one-shot approval unused.
+          if (live.managed.approvedAction?.id === live.managed.decision?.id) delete live.managed.approvedAction.dispatchedAt;
+          if (live.managed.executionAttempt?.id === claimed.run.managed.executionAttempt?.id) {
+            delete live.managed.executionAttempt.dispatchedAt;
+            live.managed.executionAttempt.phase = 'claimed';
+          }
+        }
         live.state = 'recovery_required'; live.recoveryCause = 'session_supervision';
-        live.reason = 'Original Codex conversation is in use; SIMY will retry after the writer lock becomes available.';
+        live.reason = result.accessDenied ? 'Sign in to a SIMY organization with SQM and Developer access before continuing.' : 'Original Codex conversation is in use; SIMY will retry after the writer lock becomes available.';
         live.managed.nextAttemptAt = Date.now() + 15_000;
       } else if (result.errorCode === 'provider_approval') {
         live.state = 'blocked'; live.blocker = 'authorization'; live.managed.autoRecovery = false;

package/src/desktop-access.js

@@ -0,0 +1,65 @@
+// Desktop entitlement is a server-authenticated organization/member decision.
+// Local provider readiness and the local SQM consent switch never grant access.
+const SERVER_STATES = new Set(['ready', 'sqm_required', 'developer_required']);
+export function validDesktopAccessPath(path, slug) {
+  if (typeof slug !== 'string' || !slug || ['.', '..'].includes(slug) || slug.length > 160 || /[\/\\?#\x00-\x1f]/.test(slug)) return false;
+  const expected = `/org/${encodeURIComponent(slug)}/settings/plan`;
+  return path === expected || path === `${expected}/`;
+}
+export const desktopAccessReady = value => value?.state === 'ready';
+const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'organization_select', 'organization_cancel', 'organizations_refresh',
+  'check_update', 'update', 'quit', 'delivery_stop', 'delivery_pause', 'delivery_reject',
+  'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
+export function desktopActionAllowed(access, command) {
+  return desktopAccessReady(access) || recoveryActions.has(command?.action) ||
+    command?.action === 'session_set_auto_continue' && command.enabled === false;
+}
+export function requireDesktopAccess(access) {
+  if (!desktopAccessReady(access)) throw Object.assign(new Error('Sign in to an organization with SQM and Developer access before using SIMY.'), { code: 'desktop_access_required' });
+}
+export function createDesktopAccessPolicy({ readSession, isValid, fetchAccess, isSwitching = () => false, now = Date.now, ttlMs = 30_000, onChange = () => {} }) {
+  let verified = null, verifiedSession = null, verifiedAt = 0, pending = null;
+  const basic = () => {
+    const session = readSession();
+    if (!isValid(session)) return { state: 'signed_out', organizationId: null, organizationName: null };
+    const organizationId = typeof session.organization_id === 'string' && session.organization_id ? session.organization_id : null;
+    if (!organizationId) return { state: 'organization_required', organizationId: null, organizationName: null };
+    return { state: 'checking', organizationId, organizationName: null };
+  };
+  const snapshot = () => {
+    const base = basic();
+    if (base.state !== 'checking' || isSwitching()) return base;
+    if (readSession() !== verifiedSession || now() - verifiedAt >= ttlMs || !verified) return base;
+    return { ...verified };
+  };
+  const refresh = async (force = false) => {
+    const base = basic();
+    if (base.state !== 'checking' || isSwitching()) return base;
+    const session = readSession();
+    if (pending?.session === session) return pending.promise;
+    if (!force && readSession() === verifiedSession && now() - verifiedAt < ttlMs && verified) return snapshot();
+    onChange();
+    const job = { session, promise: null };
+    job.promise = (async () => {
+      let result;
+      try {
+        const payload = await fetchAccess(session);
+        if (!payload || payload.schemaVersion !== 1 || payload.organizationId !== session.organization_id ||
+            typeof payload.organizationName !== 'string' || !SERVER_STATES.has(payload.state) ||
+            !validDesktopAccessPath(payload.settingsPath, payload.organizationSlug) || !validDesktopAccessPath(payload.membersPath, payload.organizationSlug)) throw new Error('Invalid entitlement response');
+        result = { state: payload.state,
+          organizationId: payload.organizationId, organizationName: payload.organizationName.slice(0, 120), organizationSlug: payload.organizationSlug, settingsPath: payload.settingsPath, membersPath: payload.membersPath };
+      } catch (error) {
+        result = { ...base, state: error?.status === 401 ? 'signed_out' : 'unavailable' };
+      }
+      // Late responses never authorize a new account or a switched organization.
+      if (readSession() === session && basic().state === 'checking') {
+        verified = result; verifiedSession = session; verifiedAt = now(); onChange();
+      }
+      return snapshot();
+    })().finally(() => { if (pending === job) pending = null; });
+    pending = job;
+    return job.promise;
+  };
+  return { snapshot, refresh };
+}

package/src/desktop-host.js

@@ -1,3 +1,4 @@
+import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
 import { controlDelivery, verifyDelivery } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
@@ -5,7 +6,7 @@ import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { answerSession, continueSession, discoverSessions, enrollSession, monitorSession, trackSession, setSessionAutoContinue } from "./session-supervision/index.js";
 import { createContinuationAnalysisManager } from "./session-supervision/analysis-manager.js";
-import { readContinuationContext } from "./session-supervision/continuation-analysis.js";
+import { analyzeContinuation, readContinuationContext } from "./session-supervision/continuation-analysis.js";
 import { continueAnalyzedSession, createAutomaticContinuation } from "./session-supervision/automatic-continuation.js";
 import { createWindowsDesktopUpdater } from "./windows-desktop-updater.js";
 import { spawn, execFile } from "node:child_process";
@@ -38,6 +39,9 @@ const silentLogger = { log() {}, error() {} };
 const MAX_DESKTOP_FRAME_BYTES = 8 * 1024 * 1024;
 
 function desktopActionError(action, error) {
+  if (error?.code === "desktop_access_required") return "Sign in to an organization with SQM and Developer access before using SIMY.";
+  if (action === "session_deadline_decide") return error?.code === "conflict"
+    ? "Deadline changed; refresh before deciding." : "The deadline is unavailable. Refresh this conversation before deciding.";
   if (typeof action === "string" && action.startsWith("session_")) {
     return action.startsWith("session_action_") ? associationActionError(error) : sessionActionError(error);
   }
@@ -66,18 +70,55 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false;
   const makeActionAssociations = () => (dependencies.createActionAssociationHost || createActionAssociationHost)({ root: join(root, "delivery-hooks"), sessionRoot: root, webOrigin, onChange: () => { if (!closed) setImmediate(() => { void publish().catch(() => {}); }); } });
   let actionAssociations = makeActionAssociations();
+  let currentAccess = { state: 'checking', organizationId: null, organizationName: null };
+  const accessScope = access => JSON.stringify([access?.revision ?? null, access?.organizationId ?? null]);
+  const setAccessSnapshot = async access => {
+    const previousScope = accessScope(currentAccess);
+    currentAccess = access || { state: 'unavailable', organizationId: null, organizationName: null };
+    if (previousScope !== accessScope(currentAccess)) {
+      for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
+      sessionStatus = { sessions: [], providers: {}, refreshedAt: null }; sessionRefreshedAt = 0;
+      await analysisManager?.update([]);
+    }
+    return currentAccess;
+  };
+  const accessSnapshot = async () => setAccessSnapshot((await agent?.getDesktopStatus?.())?.access);
+  const authorizeWork = async expectedScope => {
+    if (agent?.requireDesktopAccess) await agent.requireDesktopAccess();
+    const access = await accessSnapshot();
+    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" });
+    return scope;
+  };
+  const selectedScopes = new WeakMap();
+  const guardedEnroll = async options => {
+    await authorizeWork();
+    return (dependencies.continueSession || continueSession)(options);
+  };
+
   const deadlines = createActionDeadlineService({ root: join(root, "action-deadlines") });
   const managedSupervisor = (dependencies.createManagedSupervisor || createManagedSupervisor)({ root: join(root, "delivery-hooks"),
+    authorizeDispatch: authorizeWork,
     beforeClaim: record => actionAssociations.prepareCached?.(record) || record });
   let shuttingDown = null;
   let commands;
   let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null };
   let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false;
   const refreshSessions = (force = false) => {
+    if (!desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
     if (force && sessionRefresh) sessionRefreshAgain = true;
     if (!sessionRefresh && (force || Date.now() - sessionRefreshedAt >= 15_000)) {
+      const requestedScope = accessScope(currentAccess);
       sessionRefresh = Promise.resolve().then(() => (dependencies.discoverSessions || discoverSessions)({ root: join(root, "delivery-hooks") }))
-        .then(async value => { await analysisManager.update(value.sessions); sessionStatus = value; sessionRefreshedAt = Date.now(); })
+        .then(async value => {
+          const latestAccess = await accessSnapshot();
+          if (!desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope) {
+            await analysisManager.update([]);
+            sessionRefreshAgain = desktopAccessReady(latestAccess);
+            return;
+          }
+          await analysisManager.update(value.sessions); sessionStatus = value; sessionRefreshedAt = Date.now(); })
         .catch(() => { sessionStatus = { ...sessionStatus, providers: { codex: { discovery: "unavailable", reason: "Conversation discovery unavailable." }, claude: { discovery: "unavailable", reason: "Conversation discovery unavailable." } } }; sessionRefreshedAt = Date.now(); })
         .finally(() => { sessionRefresh = null; if (sessionRefreshAgain) { sessionRefreshAgain = false; refreshSessions(true); }
           if (!closed) setImmediate(() => { void publish().catch(() => {}); }); });
@@ -85,19 +126,23 @@ export async function startDesktopHost({ input = process.stdin, output = process
     return sessionStatus;
   };
   const selectedSession = async command => {
+    const scope = await authorizeWork();
     refreshSessions(true);
     await sessionRefresh;
     // A forced refresh requested during discovery schedules one follow-up.
     if (sessionRefresh) await sessionRefresh;
     const candidate = sessionStatus.sessions.find(item => item.provider === command.provider && item.session === command.session);
     if (!candidate) throw new Error('This conversation is unavailable; refresh its provider.');
-    return candidate;
+    await authorizeWork(scope);
+    const selected = { ...candidate };
+    selectedScopes.set(selected, scope);
+    return selected;
   };
   const makeAutomaticContinuation = () => createAutomaticContinuation({ root: join(root, 'delivery-hooks'),
     getManager: () => analysisManager, selectCandidate: selectedSession,
     readSetting: dependencies.readSessionAutoContinue,
     readContext: dependencies.readContinuationContext || readContinuationContext,
-    enroll: dependencies.continueSession || continueSession,
+    enroll: guardedEnroll, beforeEnroll: candidate => authorizeWork(selectedScopes.get(candidate)),
     onChange: () => { if (!closed && !relay) refreshSessions(true); },
   });
   let pluginSetup = { state: "unknown" };
@@ -110,14 +155,31 @@ export async function startDesktopHost({ input = process.stdin, output = process
   };
   const packageInfo = dependencies.packageInfo || await readCliPackageInfo();
   const makeAnalysisManager = () => (dependencies.createAnalysisManager || createContinuationAnalysisManager)({
-    root: join(root, 'session-analysis'), analyze: dependencies.analyzeContinuation,
+    root: join(root, 'session-analysis'), analyze: async (...args) => {
+      const scope = await authorizeWork();
+      const [candidate, options] = args;
+      return (dependencies.analyzeContinuation || analyzeContinuation)(candidate, { ...options, beforeProviderDispatch: () => authorizeWork(scope) });
+    },
     onChange: () => { if (!closed && !relay) setImmediate(() => { void publish().catch(() => {}); }); },
   });
   const publish = () => {
     if (closed || relay || !agent) return Promise.resolve();
     if (publishing) { publishAgain = true; return publishing; }
     publishing = Promise.resolve(agent.getDesktopStatus()).then(async (status) => {
+      await setAccessSnapshot(status.access);
+      status.access = currentAccess;
+      const requestedScope = accessScope(currentAccess);
       status.pluginSetup = { ...pluginSetup };
+      if (!desktopAccessReady(currentAccess)) {
+        for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
+        if (currentAccess.state !== 'checking') await analysisManager.update([]);
+        status.tasks = { activeCount: status.tasks?.activeCount || 0, items: [] };
+        status.sqmTasks = { activeCount: status.sqmTasks?.activeCount || 0, items: [] };
+        status.deliveryHooks = { runs: [], providers: {} };
+        status.sessionSupervision = { sessions: [], providers: {}, refreshedAt: null };
+        if (!closed && !relay) emit({ type: 'status', status });
+        return;
+      }
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: join(root, "delivery-hooks") }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
       await actionAssociations.decorate(status.deliveryHooks);
       const discovery = refreshSessions();
@@ -132,6 +194,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
         if (run) run.actionDeadline = session.actionDeadline;
       }
       status.sessionSupervision = { ...discovery, sessions };
+      const latestAccess = await accessSnapshot();
+      if (!desktopAccessReady(latestAccess) || accessScope(latestAccess) !== requestedScope) { publishAgain = true; return; }
       if (!closed && !relay) emit({ type: "status", status });
     }).finally(() => { publishing = null; if (publishAgain && !closed) { publishAgain = false; setImmediate(() => { void publish().catch(() => {}); }); } });
     return publishing;
@@ -173,7 +237,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,
+      deferStartupSynchronization: true, enforceDesktopAccess: true,
       onDesktopStatusChange: () => {
         // Let an in-progress frame finish before publishing its new snapshot.
         setImmediate(() => { void publish().catch(() => {}); });
@@ -251,13 +315,20 @@ export async function startDesktopHost({ input = process.stdin, output = process
     await publish();
     void actionAssociations.tick().then(publish).catch(() => {});
     timer = setInterval(() => {
-      void actionAssociations.tick().then(publish).catch(() => {});
-      void managedSupervisor.tick().then(publish).catch(() => {});
+      if (desktopAccessReady(currentAccess)) {
+        void actionAssociations.tick().then(publish).catch(() => {});
+        void managedSupervisor.tick().then(publish).catch(() => {});
+      }
       void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." }));
     }, 3_000);
   } catch (error) { await close(); throw error; }
 
   let queue = Promise.resolve();
+  // Authorization must not wait behind remote refresh/detail/provider work.
+  // Keep these commands ordered with each other; the agent still owns all
+  // membership, active-work and nonce checks.
+  let authorizationQueue = Promise.resolve();
+  let activeQueuedAction = null;
   commands = createInterface({ input, crlfDelay: Infinity });
   commands.on("line", (line) => {
     if (closed) return;
@@ -268,28 +339,48 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (!relay.stdin.destroyed && relay.exitCode === null) relay.stdin.write(`${JSON.stringify(command)}\n`);
       return;
     }
-    queue = queue.then(async () => {
+    const execute = async () => {
+      if (closed) return;
       try {
         const action = command.action;
+        const access = await accessSnapshot();
+        const commandScope = accessScope(access);
+        if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
+        if (desktopAccessReady(access) && !desktopActionAllowed({ state: 'unavailable' }, command)) await authorizeWork();
+
         if (action === "task_detail") {
           const task = await agent.getDesktopTask?.(command.taskKey);
+          await authorizeWork(commandScope);
           emit({ type: "task_detail", id: command.id, taskKey: command.taskKey, task: task ?? null });
           emit({ type: "result", id: command.id, ok: Boolean(task) });
           return;
         }
-        if (action === "refresh" || action === "reconnect") {
-          if (agent.refreshProviderStatus) await agent.refreshProviderStatus();
-          else await agent.refreshCodexStatus?.();
+        if (action === 'desktop_access_refresh') {
+          await agent.refreshDesktopAccess?.();
+        } else if (action === 'desktop_access_settings' || action === 'desktop_access_members') {
+          const verified = await agent.refreshDesktopAccess?.();
+          const path = verified?.[action === 'desktop_access_settings' ? 'settingsPath' : 'membersPath'];
+          if (!validDesktopAccessPath(path, verified?.organizationSlug)) throw new Error('Organization settings are unavailable; refresh access first.');
+          const url = new URL(path, webOrigin);
+          if (url.origin !== webOrigin) throw new Error('Organization settings are unavailable.');
+          const result = await (dependencies.openLogin || openAuthorizationUrl)(url.toString(), { logger: silentLogger });
+          if (!result.opened) throw new Error('Could not open organization settings.');
+        } else if (action === "refresh" || action === "reconnect") {
+          if (desktopAccessReady(access) && agent.refreshProviderStatus) await agent.refreshProviderStatus();
+          else if (desktopAccessReady(access)) await agent.refreshCodexStatus?.();
           await agent.refreshDesktopStatus();
           await refreshPlugins();
           refreshSessions(true);
-          void actionAssociations.tick().then(publish).catch(() => {});
+          if (desktopAccessReady(currentAccess)) void actionAssociations.tick().then(publish).catch(() => {});
         }
         else if (action === "organizations_refresh") await agent.refreshOrganizations();
         else if (action === "sqm_set_enabled") await agent.setSqmEnabled(command.enabled);
         else if (action === "organization_cancel") agent.cancelOrganizationSelection();
         else if (action === "login" || action === "organization_select") {
           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 = await agent.requestDesktopLogin(action === "organization_select" ? command.organizationId : null);
           if (url) {
             if (new URL(url).origin !== webOrigin) throw new Error("Invalid login origin.");
@@ -332,6 +423,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             taskId: command.taskId, criterionId: command.criterionId });
         } else if (["session_action_select", "session_action_unlink", "session_action_refresh"].includes(action)) {
           const candidate = await selectedSession(command);
+          await authorizeWork(commandScope);
           await actionAssociations.correct(command, analysisManager.project(candidate));
         } else if (action === "session_set_auto_continue") {
           if (typeof command.enabled !== 'boolean') throw new Error('Choose whether automatic continuation is enabled.');
@@ -339,6 +431,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
             const candidate = await selectedSession(command);
             if (candidate.capabilities?.canAutoContinue !== true) throw new Error('Automatic continuation is unavailable for this conversation.');
           }
+          if (command.enabled) await authorizeWork(commandScope);
           await (dependencies.setSessionAutoContinue || setSessionAutoContinue)({ root: join(root, 'delivery-hooks'),
             provider: command.provider, session: command.session, enabled: command.enabled });
           if (!command.enabled) automaticContinuation.revoke(command.provider, command.session);
@@ -356,11 +449,13 @@ export async function startDesktopHost({ input = process.stdin, output = process
           const context = await actionAssociations.deadlineContext?.(projected);
           if (!context || context.taskId !== command.taskId) throw new Error('Refresh this conversation before deciding its deadline.');
           await deadlines.reconcile(context);
+          await authorizeWork(commandScope);
           const result = await deadlines.decide(context, { ...command, requestId: command.requestId || command.decisionId });
           if (result.status === 'conflict') throw Object.assign(new Error('Deadline changed; refresh before deciding.'), { code: 'conflict' });
         } else if (action === "session_track" || action === "session_untrack") {
           const candidate = await selectedSession(command);
           if (candidate.capabilities?.canMonitor !== true) throw new Error('Tracking is unavailable for this conversation.');
+          await authorizeWork(commandScope);
           await (dependencies.trackSession || trackSession)({ root: join(root, "delivery-hooks"), provider: command.provider,
             session: command.session, tracked: action === "session_track" });
           await refreshSessions(true);
@@ -383,7 +478,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           const manager = analysisManager;
           await continueAnalyzedSession({ root: join(root, 'delivery-hooks'), candidate, manager,
             readContext: dependencies.readContinuationContext || readContinuationContext,
-            enroll: dependencies.continueSession || continueSession,
+            enroll: async options => { await authorizeWork(commandScope); return guardedEnroll(options); }, beforeEnroll: () => authorizeWork(commandScope),
             settings: { autonomyPolicy: command.autonomyPolicy, maxMinutes: command.maxMinutes,
               maxContinuations: command.maxContinuations, maxFailures: command.maxFailures,
               maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens } });
@@ -404,7 +499,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
       } catch (error) {
         emit({ type: "result", id: command.id, ok: false, message: desktopActionError(command.action, error) });
       }
-    }).catch(() => {});
+    };
+    if (["login", "organization_select", "organization_cancel"].includes(command.action)) {
+      authorizationQueue = authorizationQueue.then(execute).catch(() => {});
+    } else {
+      queue = queue.then(async () => {
+        activeQueuedAction = command.action;
+        try { await execute(); } finally { activeQueuedAction = null; }
+      }).catch(() => {});
+    }
   });
   commands.on("close", () => { if (!closed) void close().then(() => exit(0)); });
   return { close, publish, agent };

package/src/session-supervision/association-store.js

@@ -49,7 +49,7 @@ export function createOrdinaryAssociationStore({
   now = Date.now,
   onChange = () => {},
 }) {
-  const inFlight = new Map();
+  const inFlight = new Map(), syncTails = new Map();
   const views = new Map(),
     abort = new AbortController();
   let serial = Promise.resolve(),
@@ -90,9 +90,16 @@ export function createOrdinaryAssociationStore({
       },
     );
   }
-  async function sync(candidate, force = false, known) {
-    const task = candidate.taskId || known?.associationTaskId;
-    if (inFlight.has(task)) await inFlight.get(task);
+  function sync(candidate, force = false, known) {
+    // Forced user refreshes and background decoration share the same local
+    // binding writer; an in-flight check alone leaves a race after its await.
+    const key = `${candidate.provider}:${candidate.session}`;
+    const work = (syncTails.get(key) || Promise.resolve()).then(() => performSync(candidate, force, known));
+    const tail = work.catch(() => {}).finally(() => { if (syncTails.get(key) === tail) syncTails.delete(key); });
+    syncTails.set(key, tail);
+    return work;
+  }
+  async function performSync(candidate, force = false, known) {
     if (closed) return;
     const record = known || (await ensure(candidate)),
       taskId = record.run?.managed?.taskId || record.associationTaskId;

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

@@ -13,7 +13,7 @@ export async function continueAnalyzedSession({ candidate, manager, root, settin
     throw new Error('This conversation changed; wait for its updated analysis.');
   }
   manager.requireRecommendation(candidate);
-  await beforeEnroll();
+  await beforeEnroll(candidate);
   if (signal?.aborted) throw new Error('Automatic continuation was cancelled before enrollment.');
   return enroll({ root, provider: candidate.provider, session: candidate.session, ...settings });
 }
@@ -22,7 +22,7 @@ export async function continueAnalyzedSession({ candidate, manager, root, settin
 // context/opt-in changes; an existing (including terminal) run is never reset.
 export function createAutomaticContinuation({ root, getManager, selectCandidate,
   readSetting = readSessionAutoContinue, readContext = readContinuationContext, enroll = continueSession,
-  onChange = () => {} }) {
+  beforeEnroll = async () => {}, onChange = () => {} }) {
   const pending = new Map(), attempted = new Map(), errors = new Map();
   let closed = false;
   const tick = candidates => {
@@ -51,7 +51,7 @@ export function createAutomaticContinuation({ root, getManager, selectCandidate,
         const fresh = await selectCandidate(candidate);
         if (!fresh.autoContinue || fresh.autoContinueEpoch !== candidate.autoContinueEpoch) throw new Error('Automatic continuation setting changed.');
         await continueAnalyzedSession({ root, candidate: fresh, manager, signal: controller.signal,
-          readContext, enroll, beforeEnroll: guard,
+          readContext, enroll, beforeEnroll: async selected => { await guard(); await beforeEnroll(selected); },
           settings: { ...setting.settings, autoContinueEpoch: candidate.autoContinueEpoch } });
       }).catch(error => {
         if (!closed && !controller.signal.aborted && !/disabled|already enrolled|setting changed|conversation changed; wait|needs a current recommendation/i.test(error?.message || '')) {

package/src/session-supervision/codex-app-server.js

@@ -315,13 +315,16 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     for (const [index, turn] of settled.toReversed().entries()) {
       if (turn.itemsView === 'notLoaded') { truncated = true; if (turn === boundary) incomplete = true; continue; }
       if (turn.itemsView !== 'summary') throw new CodexAppServerError('context_unavailable', 'Codex did not return the requested conversation summaries.');
-      if (!Array.isArray(turn?.items)) { incomplete = true; continue; }
+      if (!Array.isArray(turn?.items)) { if (turn === boundary) incomplete = true; continue; }
       if (turn === boundary && !turn.items.length) incomplete = true;
       for (const [itemIndex, item] of turn.items.entries()) {
         const role = item?.type === 'userMessage' ? 'user' : item?.type === 'agentMessage' ? 'assistant' : null;
         if (!role) continue;
         const text = role === 'user' ? textContent(item.content) : item.text;
-        if (typeof text !== 'string' || !text.trim()) { incomplete = true; continue; }
+        // An older interrupted/empty answer is an omission in the display
+        // history, not a missing latest exchange. Retain human corrections;
+        // the classifier must still establish a self-contained current goal.
+        if (typeof text !== 'string' || !text.trim()) { if (turn === boundary) incomplete = true; continue; }
         messages.push({ role, turnRef: `${turn.id || index}:${item.id || itemIndex}`, text });
       }
     }

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

@@ -2,9 +2,10 @@ import { readCodexConversation } from './codex-app-server.js';
 import { readClaudeConversation } from './claude-sessions.js';
 import { boundConversation, boundProviderGoal, sanitizedText } from './conversation-context.js';
 import { runStructuredProviderReview } from '../sqm/review-worker.js';
+import { inspectProviderStatus } from '../desktop-status.js';
 import { createHash } from 'node:crypto';
 
-export const CONTINUATION_ANALYSIS_VERSION = 2;
+export const CONTINUATION_ANALYSIS_VERSION = 3;
 const BLOCKER_TYPES = ['approval', 'missing_information', 'external_dependency', 'execution_failure'];
 const STATES = ['continue', 'no_action', 'needs_user', 'waiting', 'uncertain'];
 const string = maximum => ({ type: 'string', maxLength: maximum });
@@ -50,8 +51,22 @@ Older history may be omitted. Set assessment.contextSufficient=true only if the
 Return blocker=null unless concrete unfinished original work is currently prevented by a specific unresolved approval, missing_information, external_dependency or execution_failure. State and needsUser/externalWait flags alone are not blockers. Running/status-only waiting, future reminders, voluntary pauses, budget limits, uncertainty, optional follow-ups and resolved historical failures must have blocker=null. A recoverable failure with a feasible next step is not a blocker. A blocker never changes continuation authority. Its reason must describe the actual obstacle concisely; basis must quote exact original conversation excerpts that establish the obstacle, checking all later supplied messages to establish that it is still current. Evidence may originate in an earlier turn when no later message resolves the obstacle. Goal metadata alone cannot establish a blocker. Later authorization, supplied information, resolution or completion clears older blockers. For execution_failure, require explicit evidence that the failure prevents further useful progress, not simply that a command failed.
 Return concise reasons and exact short supporting excerpts, each tied to the role and turnRef provided. Excerpts must occur verbatim in the supplied message. Do not reproduce secrets, credentials or large private passages. Set nextAction=null except for continue. Populate assessment honestly; nextActionKind names the concrete action, not merely a plan to act.`;
 
-function uncertain(reason) {
-  return { state: 'uncertain', reason, objective: '', remaining: [], nextAction: null, basis: [], blocker: null, analysisVersion: CONTINUATION_ANALYSIS_VERSION };
+function uncertain(reason, reasonCode) {
+  return { state: 'uncertain', reason, ...(reasonCode ? { reasonCode } : {}), objective: '', remaining: [], nextAction: null, basis: [], blocker: null, analysisVersion: CONTINUATION_ANALYSIS_VERSION };
+}
+
+async function unavailableAnalysis(candidate, error, inspectProvider, signal) {
+  if (error?.code === 'analysis_cancelled') return uncertain('Conversation analysis was cancelled.', 'cancelled');
+  if (error?.code === 'analysis_timeout') return uncertain('The local AI app did not finish checking this turn in time. Retry when it is available.', 'timeout');
+  if (error?.code === `${candidate.provider}_local_unavailable`) return uncertain('The local AI app is unavailable. Open or update it, then retry.', 'unavailable');
+  let status;
+  try { status = await inspectProvider(candidate.provider); } catch { /* Unknown is never proof of sign-out. */ }
+  if (signal?.aborted) return uncertain('Conversation analysis was cancelled.', 'cancelled');
+  if (error?.code === 'provider_sign_in_required' || status?.state === 'signed_out') {
+    const label = candidate.provider === 'claude' ? 'Claude Code' : 'Codex';
+    return uncertain(`Sign in to ${label} to check this conversation and continue its unfinished work. After signing in, retry this check.`, 'provider_sign_in_required');
+  }
+  return uncertain('The local AI app could not check this turn. Check its connection, then retry.', 'analysis_unavailable');
 }
 
 function unreadableContext(error) {
@@ -143,7 +158,7 @@ export async function readContinuationContext(candidate, { signal, readContext,
 
 export async function analyzeContinuation(candidate, {
   signal, readContext, openCodexClient, claudeHome, previousAnalysis,
-  runProvider = runStructuredProviderReview, providerOptions = {},
+  runProvider = runStructuredProviderReview, providerOptions = {}, inspectProvider = inspectProviderStatus, beforeProviderDispatch = async () => {},
 } = {}) {
   if (signal?.aborted) return uncertain('Conversation analysis was cancelled.');
   if (!['codex', 'claude'].includes(candidate?.provider) || typeof candidate?.session !== 'string' || typeof candidate?.cwd !== 'string') {
@@ -172,18 +187,29 @@ export async function analyzeContinuation(candidate, {
   if (previousAnalysis?.analysisVersion === CONTINUATION_ANALYSIS_VERSION && previousAnalysis?.contextDigest === context.contextDigest && STATES.includes(previousAnalysis.state)) {
     return { ...snapshot, ...previousAnalysis };
   }
-  if (context.incomplete || !context.messages.length) return uncertain('The latest conversation request or response is missing or incomplete.');
+  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;
   try {
-    const result = await runProvider(candidate.provider, {
+    await beforeProviderDispatch();
+    if (signal?.aborted) return uncertain('Conversation analysis was cancelled.', 'cancelled');
+    result = await runProvider(candidate.provider, {
       system: SYSTEM, prompt: `Classify this conversation evidence only (older history omitted: ${context.truncated}):\n${JSON.stringify(context.providerGoal ? { originalProviderGoal: context.providerGoal, messages: context.messages } : context.messages)}`, output_schema: OUTPUT_SCHEMA,
-    }, { ...providerOptions, signal, readOnlyAnalysis: true });
-    if (signal?.aborted) return uncertain('Conversation analysis was cancelled.');
+    }, { ...providerOptions, signal, readOnlyAnalysis: true, beforeDispatch: beforeProviderDispatch });
+  } catch (error) {
+    if (error?.code === 'desktop_access_required') return uncertain('SIMY organization access is required before checking this conversation.', 'desktop_access_required');
+    if (signal?.aborted) return uncertain('Conversation analysis was cancelled.', 'cancelled');
+    // Only a known machine code or the provider's own login probe can
+    // establish sign-out. SIMY account login is unrelated to local analysis.
+    return unavailableAnalysis(candidate, error, inspectProvider, signal);
+  }
+  if (signal?.aborted) return uncertain('Conversation analysis was cancelled.');
+  try {
     const analysis = validateContinuationAnalysis(result?.output, context);
     const model = typeof result?.model === 'string' && /^[a-zA-Z0-9._/-]{1,120}$/.test(result.model) ? result.model : null;
     return { ...snapshot, ...analysis, ...(model ? { model } : {}) };
   } catch {
     // Provider stderr/errors may contain transcript text or credentials. Never
     // expose them to the desktop, cache, diagnostics or control plane.
-    return uncertain('Local conversation analysis is unavailable or returned an invalid result.');
+    return uncertain('The AI app returned a check that could not be verified. Retry this check or review the original conversation.', 'analysis_invalid_result');
   }
 }

package/src/sqm/review-worker.js

@@ -208,6 +208,7 @@ export async function runStructuredProviderReview(
     signal,
     readOnlyAnalysis = false,
     terminationGraceMs = 1_000,
+    beforeDispatch = async () => {},
   } = {},
 ) {
   assertProvider(provider);
@@ -230,6 +231,8 @@ export async function runStructuredProviderReview(
       "Return only JSON that strictly matches the provided output schema.",
       request.prompt,
     ].join("\n\n");
+    await beforeDispatch();
+    if (signal?.aborted) throw new SqmLocalReviewError('Local analysis was cancelled.', { code: 'analysis_cancelled' });
     const stdout = await spawnReview(
       inspection.executable,
       provider === "claude" ? [
@@ -260,6 +263,9 @@ export async function runStructuredProviderReview(
     );
     const envelope = provider === "claude" ? JSON.parse(stdout) : null;
     if (envelope?.is_error || (envelope && envelope.subtype !== "success")) {
+      if (readOnlyAnalysis && envelope?.is_error === true && providerSignInRequired(envelope.result)) {
+        throw new SqmLocalReviewError('Sign in to the local AI app again.', { code: 'provider_sign_in_required' });
+      }
       throw new Error("Claude Code did not complete a structured review");
     }
     const output = provider === "claude"
@@ -273,7 +279,7 @@ export async function runStructuredProviderReview(
       model: `${provider}-local/${inspection.installed_version || "unknown"}`,
     };
   } catch (error) {
-    if (error instanceof SqmLocalReviewError) throw error;
+    if (error instanceof SqmLocalReviewError || error?.code === 'desktop_access_required') throw error;
     throw new SqmLocalReviewError(`Local ${label} review failed: ${errorMessage(error)}`, {
       code: `${provider}_local_review_failed`,
     });
@@ -322,7 +328,7 @@ function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, lab
     };
     const cancelled = () => halt(new Error('Local analysis was cancelled'));
     const timer = setTimeout(() => {
-      halt(new Error(`${label} timed out after ${executionTimeoutMs}ms`));
+      halt(readOnlyAnalysis ? new SqmLocalReviewError('Local analysis timed out.', { code: 'analysis_timeout' }) : new Error(`${label} timed out after ${executionTimeoutMs}ms`));
     }, executionTimeoutMs);
     timer.unref?.();
     const finish = (error = null) => {
@@ -341,6 +347,10 @@ function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, lab
         for (const line of stdout.split('\n').filter(Boolean)) {
           let event;
           try { event = JSON.parse(line); } catch { continue; }
+          if (['error', 'turn.failed'].includes(event.type) && providerSignInRequired(event.message ?? event.error?.message)) {
+            halt(new SqmLocalReviewError('Sign in to the local AI app again.', { code: 'provider_sign_in_required' }));
+            return;
+          }
           if (/command_execution|mcp_tool_call|web_search|file_change|tool_call/.test(event.item?.type || '')) {
             halt(new Error('Read-only analysis attempted to use a tool'));
             return;
@@ -358,6 +368,14 @@ function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, lab
     });
     child.on("error", finish);
     child.on("close", (code) => {
+      if (readOnlyAnalysis && provider === 'claude' && !terminalError) {
+        let envelope;
+        try { envelope = JSON.parse(stdout); } catch { /* Non-JSON failure remains unavailable. */ }
+        if (envelope?.is_error === true && providerSignInRequired(envelope.result)) {
+          finish(new SqmLocalReviewError('Sign in to the local AI app again.', { code: 'provider_sign_in_required' }));
+          return;
+        }
+      }
       finish(terminalError || (code === 0 ? null : new Error(stderr.trim() || `${label} exited with code ${code}`)));
     });
     signal?.addEventListener('abort', cancelled, { once: true });
@@ -366,6 +384,12 @@ function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, lab
   });
 }
 
+function providerSignInRequired(message) {
+  // Match explicit provider authentication failures only, never general 403s
+  // (which can be permissions/quotas) or model-generated prose/tool output.
+  return typeof message === 'string' && /(?:not logged in|please (?:log|sign) in|invalid api key|authentication token (?:is )?(?:invalid|expired)|refresh token (?:has )?expired)/i.test(message.slice(0, 4000));
+}
+
 function safeReviewEnvironment(environment, provider) {
   const allowed = [
     "HOME", "PATH", "CODEX_HOME", "CLAUDE_CONFIG_DIR",