@awak-app/simy-cli 0.5.57 → 0.5.58

package/package.json

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

package/src/agent.js

@@ -378,8 +378,21 @@ export async function startAgent({
   });
 
   let providerReadInFlight = null;
+  let providerReadForced = false;
+  let providerForcedFollowup = null;
   const readProviderStatuses = ({ force = false } = {}) => {
-    if (providerReadInFlight) return providerReadInFlight;
+    if (providerReadInFlight) {
+      if (!force || providerReadForced) return providerReadInFlight;
+      // A manual refresh must observe changes made after a background probe
+      // began. Queue one fresh batch without overlapping provider subprocesses.
+      if (!providerForcedFollowup) {
+        providerForcedFollowup = providerReadInFlight
+          .then(() => readProviderStatuses({ force: true }))
+          .finally(() => { providerForcedFollowup = null; });
+      }
+      return providerForcedFollowup;
+    }
+    providerReadForced = force;
     providerReadInFlight = (async () => {
       const previous = providerStatuses;
       await Promise.all(["codex", "claude"].map(async (provider) => {
@@ -400,7 +413,7 @@ export async function startAgent({
         refreshAvailableCapabilities();
       }
       return providerStatuses;
-    })().finally(() => { providerReadInFlight = null; });
+    })().finally(() => { providerReadInFlight = null; providerReadForced = false; });
     return providerReadInFlight;
   };
 

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

package/src/desktop-access.js

@@ -37,7 +37,9 @@ export function createDesktopAccessPolicy({ readSession, isValid, fetchAccess, i
     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();
+    if (!force && readSession() === verifiedSession && now() - verifiedAt < ttlMs - Math.min(5000, ttlMs / 5) && verified) return snapshot();
+    // Renew before expiry while the existing grant is still valid. snapshot()
+    // continues to expire closed at the original TTL if the network stalls.
     onChange();
     const job = { session, promise: null };
     job.promise = (async () => {

package/src/desktop-host.js

@@ -67,7 +67,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   }
   const lock = candidate ? null : await acquireDesktopProcessLock(root, { webOrigin });
   const supervisorToken = lock?.nonce || env.SIMY_DESKTOP_SUPERVISOR_TOKEN;
-  let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false;
+  let agent, updater, analysisManager, automaticContinuation, stopWorkflows = async () => {}, timer, closed = false, relay = null, publishing = null, publishAgain = false, scheduledPublish = null;
   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 };
@@ -125,12 +125,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
     }
     return sessionStatus;
   };
-  const selectedSession = async command => {
+  const selectedSession = async (command, { reuseDiscovery = false } = {}) => {
     const scope = await authorizeWork();
-    refreshSessions(true);
+    // Analysis joins an existing discovery instead of scheduling a second
+    // full scan. Enrollment retains its existing fresh-discovery boundary.
+    if (!reuseDiscovery || !sessionRefresh) refreshSessions(true);
     await sessionRefresh;
     // A forced refresh requested during discovery schedules one follow-up.
-    if (sessionRefresh) await sessionRefresh;
+    if (!reuseDiscovery && 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.');
     await authorizeWork(scope);
@@ -162,7 +164,19 @@ export async function startDesktopHost({ input = process.stdin, output = process
     },
     onChange: () => { if (!closed && !relay) setImmediate(() => { void publish().catch(() => {}); }); },
   });
+  // Batch burst notifications and maintenance completions into one frame. The
+  // short window leaves commands responsive and the regular heartbeat intact.
   const publish = () => {
+    if (closed || relay || !agent) return Promise.resolve();
+    if (!scheduledPublish) {
+      let resolve, reject;
+      const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+      scheduledPublish = { promise };
+      setTimeout(() => { scheduledPublish = null; projectStatus().then(resolve, reject); }, 75);
+    }
+    return scheduledPublish.promise;
+  };
+  const projectStatus = () => {
     if (closed || relay || !agent) return Promise.resolve();
     if (publishing) { publishAgain = true; return publishing; }
     publishing = Promise.resolve(agent.getDesktopStatus()).then(async (status) => {
@@ -471,8 +485,8 @@ export async function startDesktopHost({ input = process.stdin, output = process
             maxContinuations: command.maxContinuations, maxFailures: command.maxFailures, maxNoProgressMinutes: command.maxNoProgressMinutes, maxTokens: command.maxTokens });
           await refreshSessions(true);
         } else if (action === "session_analyze") {
-          const candidate = await selectedSession(command);
-          await analysisManager.request(candidate);
+          const candidate = await selectedSession(command, { reuseDiscovery: true });
+          await analysisManager.request(candidate, { requestId: command.analysisRequestId || command.id });
           if (candidate.autoContinue === true && candidate.capabilities?.canContinue === true) automaticContinuation.retry(candidate.provider, candidate.session);
         } else if (action === "session_continue") {
           const candidate = await selectedSession(command);

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

@@ -78,6 +78,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     entries.set(key, { revision, analysisVersion: CONTINUATION_ANALYSIS_VERSION, cwd: candidate.cwd,
       forceAnalysis: forceAnalysis || entry?.forceAnalysis === true && ['queued', 'analyzing'].includes(entry.result?.state),
       settledResult: entry?.cwd === candidate.cwd ? entry.settledResult : null,
+      requestId: entry?.cwd === candidate.cwd && ['queued', 'analyzing'].includes(entry.result?.state) ? entry.requestId : undefined,
       result: { state: 'queued' } });
     return true;
   };
@@ -135,7 +136,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       }
       const settledResult = finishedAnalysis(result, selected.previousAnalysis || entry.settledResult);
       entries.set(selected.key, { revision: selected.revision, analysisVersion: CONTINUATION_ANALYSIS_VERSION, cwd: current.cwd, settledResult,
-        result: { ...result, analyzedAt: settledResult?.analyzedAt || now() } });
+        requestId: selected.entry.requestId, result: { ...result, analyzedAt: settledResult?.analyzedAt || now() } });
       await persist(); changed();
     });
   };
@@ -149,7 +150,9 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
         const selected = await exclusive(async () => {
           if (closed) return [];
           const batch = [];
-          for (const [key, entry] of entries) {
+          // Explicit retries precede historical backfill without interrupting owned jobs.
+          const ordered = [...entries].sort((a, b) => Number(Boolean(b[1].requestId)) - Number(Boolean(a[1].requestId)));
+          for (const [key, entry] of ordered) {
             if (jobs.size >= concurrency) break;
             if (!runnable(key, entry)) continue;
             const candidate = candidates.get(key), controller = new AbortController();
@@ -233,7 +236,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     },
     project(candidate) {
       const revision = continuationAnalysisRevision(candidate), entry = entries.get(keyOf(candidate));
-      let analysis = entry?.revision === revision ? { ...entry.result, revision } : { state: 'unanalysed', revision };
+      let analysis = entry?.revision === revision ? { ...entry.result, revision, requestId: entry.requestId } : { state: 'unanalysed', revision };
       const previous = entry?.cwd === candidate.cwd ? entry.settledResult : null;
       if (candidate.isRunning === true || analysis.awaitingTurn === true) {
         analysis = { state: 'waiting', awaitingTurn: true, revision,
@@ -244,12 +247,16 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       }
       return { ...candidate, analysis };
     },
-    async request(candidate) {
+    async request(candidate, { requestId } = {}) {
+      if (requestId !== undefined && (typeof requestId !== 'string' || !requestId || requestId.length > 128)) throw new Error('Invalid analysis request identity.');
       if (!candidate || !eligible(candidate)) throw new Error('This conversation cannot be analyzed.');
       await exclusive(async () => {
         if (closed) throw new Error('Session analysis is unavailable.');
         candidates.set(keyOf(candidate), candidate);
-        if (enqueue(candidate, true, true)) { await persist(); changed(); }
+        let dirty = enqueue(candidate, true, true);
+        const entry = entries.get(keyOf(candidate));
+        if (requestId && entry.requestId !== requestId) { entry.requestId = requestId; dirty = true; }
+        if (dirty) { await persist(); changed(); }
       });
       startDrain();
     },