@awak-app/simy-cli 0.6.13 → 0.6.16

package/README.md

@@ -2,6 +2,15 @@
 
 Local execution agent for SIMY Local Tasks and Agentic Loop runs.
 
+Action candidate search runs once for each authenticated live conversation context,
+and again when that context changes or **Refresh** is selected. Background binding
+renewal uses the lightweight binding endpoint instead of repeating candidate search.
+Settled ordinary conversations and terminal managed tasks do not automatically
+search candidates. Bound Actions still renew to reflect changes to deadlines and
+manual links. Candidate text expires after one minute; select **Refresh** to retrieve
+current suggestions after editing Actions in SIMY. Candidate search identities are
+cached in memory, so restarting the host may retrieve live contexts again.
+
 `simy --version` prints the installed CLI version without starting an agent or
 checking for updates. `simy doctor` performs read-only local connection and
 provider login checks and prints a JSON diagnostic report: installed/running

package/package.json

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

package/src/auto-update.js

@@ -69,6 +69,9 @@ export class CliAutoUpdater extends EventEmitter {
   #stopped = false;
   #registryListener = null;
   #activeWork = 0;
+  #confirmedUpdate = null;
+  #confirmedReady = false;
+  #desktopIdle = () => true;
 
   constructor(options) {
     super();
@@ -95,7 +98,39 @@ export class CliAutoUpdater extends EventEmitter {
   }
 
   snapshot() {
-    return structuredClone(this.#snapshot);
+    return structuredClone({ ...this.#snapshot, requires_task_stop: !this.#isIdle() });
+  }
+
+  // Close admission before cancellation begins. The same transaction owns the
+  // idle check and installation, so a releasing worker cannot race the stop.
+  applyConfirmed(stopWork) {
+    if (this.#confirmedUpdate) return this.#confirmedUpdate;
+    if (this.#applying) return this.#applying;
+    if (!this.#snapshot.target_version || !this.#options.lastRelease) {
+      return Promise.reject(new Error('Check for an available update first.'));
+    }
+    this.#setState('stopping_tasks', { message: 'Stopping unfinished tasks before updating…', error: null });
+    this.#confirmedUpdate = (async () => {
+      try {
+        await Promise.resolve().then(stopWork);
+        await this.#checking;
+        if (!this.#snapshot.target_version) throw new Error('The update is no longer available.');
+        if (!this.#isIdle()) throw new Error('Task shutdown did not finish. Restart SIMY and retry the update.');
+        if (!this.#snapshot.automatic || classifyVersionChange(this.#options.currentVersion, this.#snapshot.target_version) === 'major') {
+          this.#setState('update_available', { message: 'Tasks stopped. Opening the update installer…' });
+          await this.performAction();
+          return this.snapshot();
+        }
+        this.#confirmedReady = true;
+        this.#setState('waiting_for_idle', { message: 'Tasks stopped. Installing the update…' });
+        return await this.maybeApply();
+      } catch (error) {
+        this.#setState('failed', { message: 'Update could not finish after stopping tasks. Restart SIMY and retry.',
+          error: errorMessage(error), action: updateAction(this.#snapshot.target_version, this.#options) });
+        return this.snapshot();
+      } finally { this.#confirmedUpdate = null; this.#confirmedReady = false; }
+    })();
+    return this.#confirmedUpdate;
   }
 
   async performAction() {
@@ -110,7 +145,7 @@ export class CliAutoUpdater extends EventEmitter {
   }
 
   acceptsNewWork() {
-    return !["updating", "restarting"].includes(this.#snapshot.state);
+    return !this.#confirmedUpdate && !["stopping_tasks", "updating", "restarting"].includes(this.#snapshot.state);
   }
 
   beginWork() {
@@ -127,10 +162,11 @@ export class CliAutoUpdater extends EventEmitter {
     };
   }
 
-  start({ registry, restartDaemon } = {}) {
+  start({ registry, restartDaemon, isDesktopIdle = () => true } = {}) {
     if (this.#snapshot.state === "disabled" || this.#checkTimer || this.#stopped) return this;
     this.#registry = registry;
     this.#restartDaemon = restartDaemon;
+    this.#desktopIdle = isDesktopIdle;
     this.#registryListener = () => {
       if (this.#snapshot.state === "waiting_for_idle") void this.maybeApply();
     };
@@ -156,7 +192,7 @@ export class CliAutoUpdater extends EventEmitter {
   async checkNow() {
     if (this.#stopped || this.#snapshot.state === "disabled") return this.snapshot();
     if (this.#checking) return this.#checking;
-    if (["updating", "restarting"].includes(this.#snapshot.state)) return this.snapshot();
+    if (["stopping_tasks", "updating", "restarting"].includes(this.#snapshot.state) || this.#confirmedUpdate) return this.snapshot();
 
     this.#checking = this.#performCheck().finally(() => {
       this.#checking = null;
@@ -237,6 +273,7 @@ export class CliAutoUpdater extends EventEmitter {
   }
 
   async maybeApply() {
+    if (this.#confirmedUpdate && !this.#confirmedReady) return this.snapshot();
     if (this.#stopped || this.#snapshot.state !== "waiting_for_idle") {
       return this.snapshot();
     }
@@ -333,7 +370,7 @@ export class CliAutoUpdater extends EventEmitter {
   }
 
   #isIdle() {
-    return this.#activeWork === 0 && isRegistryIdle(this.#registry);
+    return this.#activeWork === 0 && isRegistryIdle(this.#registry) && this.#desktopIdle();
   }
 
   #clearIdleTimer() {

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

package/src/desktop-access.js

@@ -52,7 +52,9 @@ export function createDesktopAccessPolicy({ readSession, isValid, fetchAccess, i
         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' };
+        result = { ...base, state: error?.status === 401 ? 'signed_out' : 'unavailable',
+          reason: error?.status === 401 ? 'authentication_required' :
+            ['TimeoutError', 'AbortError'].includes(error?.name) ? 'timeout' : 'service_unavailable' };
       }
       // Late responses never authorize a new account or a switched organization.
       if (readSession() === session && basic().state === 'checking') {

package/src/desktop-host.js

@@ -4,10 +4,11 @@ import { inspectProviderPlugins, unavailablePluginStatus } from './sqm/provider-
 import { openCodexAppServer } from './session-supervision/codex-app-server.js';
 import { conversationSqmChecks } from './session-supervision/sqm-presentation.js';
 import { stopOwnedDesktopHost } from "./desktop-force-quit.js";
+import { stopDesktopWorkForUpdate } from './desktop-update-stop.js';
 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, createRecordReader } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
+import { controlDelivery, verifyDelivery, createRecordReader, TERMINAL } from "./codex-plugins/simy/hooks/delivery-loop.mjs";
 import { createManagedSupervisor } from "./delivery-hooks/supervisor.js";
 import { createActionAssociationHost } from "./session-supervision/action-association-host.js";
 import { createStopNotifier } from "./session-supervision/stop-notifications.js";
@@ -63,6 +64,7 @@ function desktopActionError(action, error) {
   if (["sqm_set_enabled", "sqm_set_engine_fallback", "sqm_retry_environment"].includes(action)) {
     return "Could not save SQM settings. Check your SIMY connection and try again.";
   }
+  if (action === 'update') return 'Update could not finish. Restart SIMY and retry; stopped tasks stay stopped.';
   return "Action could not finish. Refresh the status and try again.";
 }
 
@@ -115,14 +117,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
   };
   const accessSnapshot = async () => setAccessSnapshot((await agent?.getDesktopStatus?.())?.access);
   let stoppingForUpdate = false;
+  let unfinishedDesktopWork = true;
   let organizationAnalysesSuspended = false;
   let organizationAnalysisDrain = Promise.resolve();
   let organizationAnalysisEpoch = 0;
   const authorizeWork = async expectedScope => {
-    if (closed || stoppingForUpdate || organizationAnalysesSuspended) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
+    if (closed || stoppingForUpdate || updater?.acceptsNewWork?.() === false || 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 || organizationAnalysesSuspended) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
+    if (closed || stoppingForUpdate || updater?.acceptsNewWork?.() === false || 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" });
@@ -142,11 +145,37 @@ export async function startDesktopHost({ input = process.stdin, output = process
   let commands;
   let sessionStatus = { sessions: [], providers: { codex: { discovery: "loading", reason: null }, claude: { discovery: "loading", reason: null } }, refreshedAt: null, initialLoading: true };
   let sessionRefresh = null, sessionRefreshedAt = 0, sessionRefreshAgain = false, discoveryController = null, discoveryStopped = false;
+  const hasUnfinishedSessions = records => records.some(record => record.autoContinue === true || record.run && !TERMINAL.has(record.run.state)) ||
+    sessionStatus.sessions.some(candidate => candidate.autoContinue === true || ['queued', 'analyzing'].includes(analysisManager.project(candidate).analysis?.state));
   const stopDiscovery = async ({ drain = false } = {}) => {
     discoveryController?.abort();
     sessionRefreshAgain = false;
     if (drain && !dependencies.discoverSessions) await sessionRefresh;
   };
+  let confirmedUpdateStop;
+  const stopWorkForUpdate = () => confirmedUpdateStop ||= (async () => {
+    stoppingForUpdate = true; discoveryStopped = true;
+    void stopDiscovery();
+    await stopDesktopWorkForUpdate({
+      stopWork: () => Promise.all([
+        agent.stopDesktopTasks(), managedSupervisor.close(),
+        automaticContinuation?.close(), analysisManager?.close(),
+        (async () => {
+          const records = await recordReader.list();
+          await Promise.all(records.map(async record => {
+            if (record.autoContinue === true) await (dependencies.setSessionAutoContinue || setSessionAutoContinue)({
+              root: deliveryRoot, provider: record.provider, session: record.session, enabled: false });
+            if (record.run && !TERMINAL.has(record.run.state)) await controlDelivery({ root: deliveryRoot,
+              provider: record.provider, session: record.session, taskId: record.run.managed?.taskId, action: 'stop' });
+          }));
+        })(),
+      ]),
+      killOwned: () => (dependencies.stopOwnedHost || stopOwnedDesktopHost)(process.pid,
+        { parentPid: process.ppid, includeRoot: false }),
+      timeoutMs: dependencies.updateStopTimeoutMs ?? 12_000,
+    });
+    unfinishedDesktopWork = false;
+  })();
   const refreshSessions = (force = false) => {
     if (discoveryStopped && !closed && !relay) return sessionStatus;
     if (closed || relay || !desktopAccessReady(currentAccess)) return { sessions: [], providers: {}, refreshedAt: null };
@@ -277,6 +306,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
       const requestedScope = accessScope(currentAccess);
       status.pluginSetup = { ...pluginSetup };
       status.providerPlugins = structuredClone(providerPlugins);
+      const records = await recordReader.list();
+      const update = status.update || updater.snapshot?.() || {};
+      if (!stoppingForUpdate) unfinishedDesktopWork = hasUnfinishedSessions(records);
+      status.update = { ...update, requires_task_stop: update.requires_task_stop === true ||
+        (status.tasks?.activeCount || 0) + (status.sqmTasks?.activeCount || 0) > 0 || hasUnfinishedSessions(records) };
       if (!desktopAccessReady(currentAccess)) {
         for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
         if (currentAccess.state !== 'checking') await analysisManager.update([]);
@@ -289,7 +323,6 @@ export async function startDesktopHost({ input = process.stdin, output = process
         return;
       }
       await analysisManager.updateProviderStatuses?.(status.providers);
-      const records = await recordReader.list();
       stopNotifier.observe(records);
       const projection = await actionAssociations.beginProjection?.({ records });
       status.deliveryHooks = await (dependencies.deliveryHookStatus || deliveryHookStatus)({ root: deliveryRoot, records: projection?.records || records }).catch(() => ({ error: "Delivery hook status unavailable", providers: {}, runs: [] }));
@@ -378,7 +411,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
     });
     stopWorkflows = (dependencies.startWorkflowUpdates || startWorkflowUpdates)({ enabled: env.SIMY_AUTO_UPDATE !== "0" });
     updater.on?.("change", () => { void publish().catch(() => {}); });
-    updater.start({ registry: agent.registry, restartDaemon: async (targetVersion, installation) => {
+    updater.start({ registry: agent.registry, isDesktopIdle: () => !unfinishedDesktopWork,
+      restartDaemon: async (targetVersion, installation) => {
       if (!installation?.entryPath || !installation?.executablePath) throw new Error("Signed update runtime is unavailable.");
       discoveryStopped = true;
       await stopDiscovery({ drain: true });
@@ -499,6 +533,10 @@ export async function startDesktopHost({ input = process.stdin, output = process
       try {
         const action = command.action;
         if (action === "quit") {
+          if (command.forUpdate === true) {
+            if (command.force !== true) throw new Error('Confirm before stopping unfinished tasks.');
+            await stopWorkForUpdate();
+          }
           if (command.force !== true) {
             const status = await agent.getDesktopStatus();
             if ((status.tasks?.activeCount || 0) + (status.sqmTasks?.activeCount || 0) > 0) throw new Error("Tasks are still running. Confirm before quitting.");
@@ -595,16 +633,15 @@ export async function startDesktopHost({ input = process.stdin, output = process
           }
         } else if (action === "check_update") await updater.checkNow();
         else if (action === "update") {
-          if (command.force === true) {
-            stoppingForUpdate = true; discoveryStopped = true;
-            void stopDiscovery();
-            // Abort dispatch immediately; existing Delivery Loop records retain
-            // their cancelled checkpoint so another host cannot silently resume.
-            await Promise.all([agent.stopDesktopTasks(), managedSupervisor.close(),
-              automaticContinuation?.close(), analysisManager?.close()]);
+          if (command.force === true && updater.applyConfirmed) await updater.applyConfirmed(stopWorkForUpdate);
+          else if (command.force === true) { await stopWorkForUpdate(); await updater.performAction(); }
+          else {
+            const status = await agent.getDesktopStatus();
+            if ((status.tasks?.activeCount || 0) + (status.sqmTasks?.activeCount || 0) > 0 ||
+              updater.snapshot().requires_task_stop === true || hasUnfinishedSessions(await recordReader.list())) throw new Error('Confirm before stopping unfinished tasks.');
+            if (updater.snapshot().state === "waiting_for_idle") await updater.maybeApply();
+            else await updater.performAction();
           }
-          if (updater.snapshot().state === "waiting_for_idle") await updater.maybeApply();
-          else await updater.performAction();
           if (command.force === true && ["failed", "error"].includes(updater.snapshot().state)) throw new Error("Update failed after stopping tasks.");
         } else if (action === "codex_login" || action === "claude_login") {
           const provider = action === "claude_login" ? "claude" : "codex";
@@ -710,7 +747,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
         emit({ type: "result", id: command.id, ok: false, message: command.action === "update" && stoppingForUpdate ? "Could not finish the update after stopping tasks. Reopen SIMY and retry the update." : desktopActionError(command.action, error) });
       }
     };
-    if (command.action === "quit") {
+    if (command.action === "quit" || command.action === "update" && command.force === true) {
       void execute();
     } else if (["login", "organization_select", "organization_cancel", "authorization_open"].includes(command.action)) {
       authorizationQueue = authorizationQueue.then(execute).catch(() => {});

package/src/desktop-update-stop.js

@@ -0,0 +1,22 @@
+// Confirmed updates must not wait indefinitely on a provider or remote flush.
+// SIGKILL is ownership checked by the caller; the desktop host itself survives
+// long enough to settle its local checkpoints and perform the signed handoff.
+export async function stopDesktopWorkForUpdate({ stopWork, killOwned, timeoutMs = 12_000 }) {
+  let timer;
+  const stopping = Promise.resolve().then(stopWork);
+  // A kill failure or deadline can win the race before checkpoint cancellation
+  // settles. Observe its eventual rejection as well.
+  void stopping.catch(() => {});
+  const deadline = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error('Task shutdown timed out. Restart SIMY and retry the update.')), timeoutMs);
+  });
+  try {
+    await Promise.race([(async () => {
+      // Start cancellation before taking the process snapshot so queued work is
+      // fenced and live workers observe their stop intent before termination.
+      await Promise.resolve();
+      await killOwned();
+      await stopping;
+    })(), deadline]);
+  } finally { clearTimeout(timer); }
+}

package/src/session-supervision/action-association-host.js

@@ -3,6 +3,7 @@ import { listRecords, readRecord, updateRecord, TERMINAL, managedBudgetReason }
 import { createActionAssociationApi, ActionAssociationApiError } from './action-association-api.js';
 import { actionCandidateRequest, prepareActionAssociation, importActionBinding,
   settleActionAssociation, cancelActionAssociation } from './action-association.js';
+import { CANDIDATE_DISPLAY_MS, needsCandidateSearch, hasFreshCandidates } from './association-refresh.js';
 
 const namespaceFor = (origin, scope) => JSON.stringify([new URL(origin).origin, scope.organizationId, scope.userId]);
 const identity = record => ({ provider: record.provider, session: record.session, taskId: record.run.managed.taskId });
@@ -90,22 +91,34 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     let view = views.get(target.taskId);
     const request = actionCandidateRequest(record);
     const contextRevision = request?.context.revision || null;
-    if (!force && view?.auth === expected && view.contextRevision === contextRevision && now() < view.nextRefresh && (!association?.outbox || view.error)) {
-      if (queue && !view.error && view.snapshot && !association?.manualOverride && !association?.job && !association?.outbox && !TERMINAL.has(record.run.state)) await prepareActionAssociation({ root, record, snapshot: view.snapshot, webOrigin, now: now(), validate: validateScope(expected) });
+    const active = !TERMINAL.has(record.run.state);
+    if (!force && view?.auth === expected && view.active === active && view.contextRevision === contextRevision && now() < view.nextRefresh && (!association?.outbox || view.error)) {
+      if (queue && !view.error && hasFreshCandidates(view, now()) && !association?.manualOverride && !association?.job && !association?.outbox && !TERMINAL.has(record.run.state)) await prepareActionAssociation({ root, record, snapshot: view.snapshot, webOrigin, now: now(), validate: validateScope(expected) });
       return;
     }
-    view = { ...view, auth: expected, contextRevision, nextRefresh: now() + refreshMs };
+    const search = request && (needsCandidateSearch(view, expected, contextRevision, active, force) ||
+      association?.outbox && !view?.snapshot);
+    view = { ...view, auth: expected, active, contextRevision, nextRefresh: now() + refreshMs };
     views.delete(target.taskId); views.set(target.taskId, view);
     while (views.size > 500) views.delete(views.keys().next().value);
     try {
       // Never publish an outbox from an earlier organization or login before a
       // scoped server response confirms who owns the current request.
-      const snapshot = request ? await api.candidates(request, { signal: abort.signal }) : await api.readBinding(target.taskId, { signal: abort.signal });
-      const namespace = await importEnvelope(record, snapshot, expected);
+      const envelope = search ? await api.candidates(request, { signal: abort.signal }) : await api.readBinding(target.taskId, { signal: abort.signal });
+      const namespace = await importEnvelope(record, envelope, expected);
+      const reusable = view.auth === expected && view.namespace === namespace && view.snapshot?.contextRevision === contextRevision;
+      const snapshot = search ? envelope : { ...(reusable ? view.snapshot : {}), ...envelope };
       view.namespace = namespace; view.error = null;
-      view.candidates = (snapshot.candidates || []).map(publicCandidate);
+      if (search) {
+        view.candidateAuth = expected; view.candidateContextRevision = contextRevision;
+        view.candidatesExpireAt = now() + CANDIDATE_DISPLAY_MS;
+      } else if (!reusable) {
+        view.candidateAuth = null; view.candidateContextRevision = null;
+      }
+      view.candidates = (search || hasFreshCandidates(view, now()) ? snapshot.candidates || [] : []).map(publicCandidate);
       view.candidateTruncated = snapshot.retrieval?.truncated === true || view.candidates.length > 5;
-      view.snapshot = request ? snapshot : null;
+      view.snapshot = snapshot.candidateRevision ? snapshot : null;
+      if (!active && !snapshot.binding?.action && !association?.outbox) view.nextRefresh = Infinity;
       let latest = await fresh(target);
       if (!latest || !await valid(expected)) return;
       const pending = latest.run.managed.actionAssociation?.outbox;
@@ -123,7 +136,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
         await settleActionAssociation({ root, ...target, outboxId: pending.id, namespace, binding: saved.binding, now: now(), validate: validateScope(expected) });
         return;
       }
-      if (queue && request && !latest.run.managed.actionAssociation?.manualOverride && !TERMINAL.has(latest.run.state)) {
+      if (queue && request && hasFreshCandidates(view, now()) && !latest.run.managed.actionAssociation?.manualOverride && !TERMINAL.has(latest.run.state)) {
         // A read turn is queued only at the original session's safe boundary.
         // Blocked tasks retain candidates for auxiliary correction in the UI.
         await prepareActionAssociation({ root, record: latest, snapshot, webOrigin, now: now(), validate: validateScope(expected) });
@@ -245,7 +258,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     async prepareCached(record) {
       const expected = await current();
       const view = views.get(record?.run?.managed?.taskId), request = actionCandidateRequest(record);
-      if (closed || !auth || !view || view.auth !== auth || view.error || !view.snapshot || !request || view.contextRevision !== request.context.revision || view.snapshot.contextRevision !== request.context.revision || view.namespace !== namespaceFor(webOrigin, view.snapshot.scope)) return record;
+      if (closed || !auth || !view || view.auth !== auth || view.error || !hasFreshCandidates(view, now()) || !request || view.contextRevision !== request.context.revision || view.snapshot.contextRevision !== request.context.revision || view.namespace !== namespaceFor(webOrigin, view.snapshot.scope)) return record;
       try {
         const prepared = await prepareActionAssociation({ root, record, snapshot: view.snapshot, webOrigin, now: now(), validate: validateScope(expected) });
         return prepared || record;
@@ -268,7 +281,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
           !view || view.auth !== expected ? { status: 'loading', binding: null, candidates: [], canCorrect: false } : {
             status: view.error || local?.status || 'waiting_boundary',
             binding: view.namespace && local?.namespace === view.namespace ? publicBinding(local.binding) : null,
-            candidates: (view.candidates || []).slice(0,5), canCorrect: !view.error,
+            candidates: (hasFreshCandidates(view, now()) ? view.candidates || [] : []).slice(0,5), canCorrect: !view.error,
             contextRevision: view.contextRevision, candidateRevision: view.snapshot?.candidateRevision || null, retryOn: local?.retryOn || null, truncated: view.candidateTruncated || false,
           };
         let bytes = Buffer.byteLength(JSON.stringify(run.actionAssociation));

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

@@ -0,0 +1,12 @@
+// Candidate search is event-driven; binding reads remain independently renewable.
+// Retain only the search identity after expiry, so a timer cannot restart search
+// or keep displaying candidate text after its authorization window has elapsed.
+export const CANDIDATE_DISPLAY_MS = 60_000;
+
+export function needsCandidateSearch(view, auth, contextRevision, active, force = false) {
+  return force || active && (view?.candidateAuth !== auth || view.candidateContextRevision !== contextRevision);
+}
+
+export function hasFreshCandidates(view, now) {
+  return Boolean(view?.snapshot?.candidateRevision && now < view.candidatesExpireAt);
+}

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

@@ -3,9 +3,14 @@ import {
   listRecords,
   readRecord,
   updateRecord,
+  TERMINAL,
 } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { associationRevision } from './action-association.js';
 import { ActionAssociationApiError } from './action-association-api.js';
+import { CANDIDATE_DISPLAY_MS, needsCandidateSearch, hasFreshCandidates } from './association-refresh.js';
+
+const activeConversation = (candidate, record) => !TERMINAL.has(record.run?.state) &&
+  (candidate.isRunning !== false || candidate.autoContinue === true || candidate.analysis?.state === 'continue');
 
 export const sessionAssociationContext = (candidate) => {
   const grounded =
@@ -111,6 +116,7 @@ export function createOrdinaryAssociationStore({
     if (record.run?.managed) return;
     const auth = await api.authRevision(),
       context = sessionAssociationContext(candidate);
+    const active = activeConversation(candidate, record);
     let view = views.get(taskId);
     if (!auth) {
       rememberView(taskId, { auth, status: 'signed_out' });
@@ -120,13 +126,15 @@ export function createOrdinaryAssociationStore({
       !force &&
       view?.auth === auth &&
       view.contextRevision === context.revision &&
+      view.active === active &&
       now() < view.nextRefresh
     )
       return;
     const previous = view?.auth === auth ? view : null;
     const sameContext = previous?.contextRevision === context.revision;
+    const search = needsCandidateSearch(previous, auth, context.revision, active, force);
     view = {
-      ...previous, auth, contextRevision: context.revision,
+      ...previous, auth, active, contextRevision: context.revision,
       // Background renewal retains the last stable presentation. A user refresh
       // can show progress without flashing every cached result back to loading.
       status: force ? 'loading' : previous?.status || 'loading',
@@ -134,19 +142,22 @@ export function createOrdinaryAssociationStore({
     };
     rememberView(taskId, view);
     try {
-      const snapshot = await api.candidates(
+      const envelope = search ? await api.candidates(
         { taskId, context, limit: 10 },
         { signal: abort.signal },
-      );
+      ) : await api.readBinding(taskId, { signal: abort.signal });
       if (closed || (await api.authRevision()) !== auth)
         throw new ActionAssociationApiError('account_changed');
       if (
-        snapshot.taskId !== taskId ||
-        snapshot.contextRevision !== context.revision ||
-        (snapshot.binding && snapshot.binding.taskId !== taskId)
+        search && (envelope.taskId !== taskId || envelope.contextRevision !== context.revision) ||
+        (envelope.binding && envelope.binding.taskId !== taskId)
       )
         throw new ActionAssociationApiError('invalid_response');
-      const namespace = namespaceFor(webOrigin, snapshot.scope);
+      const namespace = namespaceFor(webOrigin, envelope.scope);
+      const reusable = sameContext && previous.namespace === namespace && hasFreshCandidates(previous, now());
+      const snapshot = search ? envelope : {
+        ...(reusable ? previous.snapshot : {}), ...envelope, taskId, contextRevision: context.revision,
+      };
       const persisted = await updateRecord(
         root,
         candidate.provider,
@@ -184,7 +195,10 @@ export function createOrdinaryAssociationStore({
       Object.assign(view, {
         namespace,
         snapshot,
-        nextRefresh: now() + (snapshot.binding?.action ? 15_000 : 60_000),
+        candidateAuth: search ? auth : previous?.namespace === namespace ? previous?.candidateAuth : null,
+        candidateContextRevision: search ? context.revision : previous?.namespace === namespace ? previous?.candidateContextRevision : null,
+        candidatesExpireAt: search ? now() + CANDIDATE_DISPLAY_MS : previous?.candidatesExpireAt,
+        nextRefresh: snapshot.binding?.action ? now() + 15_000 : active ? now() + 60_000 : Infinity,
         failures: 0,
         status: snapshot.binding?.action
           ? 'bound'
@@ -230,7 +244,8 @@ export function createOrdinaryAssociationStore({
         candidate.binding = { ...candidate.binding, taskId };
         if (record.run?.managed) continue;
         const cached = views.get(taskId),
-          context = sessionAssociationContext(candidate);
+          context = sessionAssociationContext(candidate),
+          active = activeConversation(candidate, record);
         if (
           auth &&
           !closed &&
@@ -238,6 +253,7 @@ export function createOrdinaryAssociationStore({
           (!cached ||
             cached.auth !== auth ||
             cached.contextRevision !== context.revision ||
+            cached.active !== active ||
             now() >= cached.nextRefresh)
         ) {
           const scopedBinding = cached?.auth === auth && cached.snapshot && record.actionAssociation?.authRevision === auth && record.actionAssociation.namespace === cached.namespace;
@@ -247,7 +263,7 @@ export function createOrdinaryAssociationStore({
         }
         const view = views.get(taskId);
         const bindingSnapshot = view?.auth === auth && auth ? view.snapshot : null;
-        const snapshot = bindingSnapshot?.contextRevision === context.revision ? bindingSnapshot : null;
+        const snapshot = bindingSnapshot?.contextRevision === context.revision && hasFreshCandidates(view, now()) ? bindingSnapshot : null;
         const local = record.actionAssociation;
         const scoped = Boolean(bindingSnapshot && local?.authRevision === auth && local.namespace === view.namespace);
         const newer = scoped &&