@awak-app/simy-cli 0.5.39 → 0.5.40

package/package.json

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

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

package/src/desktop-host.js

@@ -310,7 +310,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           const context = await (dependencies.readContinuationContext || readContinuationContext)(candidate);
           // Provider activity timestamps can have one-second precision. Re-read
           // the bounded context before enrollment to reject same-second edits.
-          if (context.incomplete || !recommendation.contextDigest || context.contextDigest !== recommendation.contextDigest) {
+          if (context.awaitingTurn || context.incomplete || !recommendation.contextDigest || context.contextDigest !== recommendation.contextDigest) {
             await manager.invalidate(candidate);
             throw new Error('This conversation changed; wait for its updated analysis.');
           }

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

@@ -9,7 +9,7 @@ const RESULT_STATES = new Set(['continue', 'no_action', 'needs_user', 'waiting',
 const keyOf = candidate => `${candidate.provider}:${candidate.session}`;
 const activityOf = candidate => Number.isFinite(candidate.lastActivityAt) ? candidate.lastActivityAt : 0;
 export const continuationAnalysisRevision = candidate => createHash('sha256')
-  .update(JSON.stringify([candidate.provider, candidate.session, candidate.cwd, activityOf(candidate)]))
+  .update(JSON.stringify([candidate.provider, candidate.session, candidate.cwd, activityOf(candidate), ...(candidate.isRunning === true ? ['running'] : [])]))
   .digest('hex');
 const eligible = candidate => candidate.capabilities?.canAnalyze === true &&
   ['unmanaged', 'monitor'].includes(candidate.binding?.mode || 'unmanaged');
@@ -60,15 +60,19 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     } finally { await rm(temporary, { force: true }); }
   };
   const changed = () => { void Promise.resolve().then(onChange).catch(() => {}); };
-  const enqueue = (candidate, force = false) => {
+  const enqueue = (candidate, force = false, forceAnalysis = false) => {
     const key = keyOf(candidate), revision = continuationAnalysisRevision(candidate);
     const entry = entries.get(key);
     if (entry?.revision === revision && (['queued', 'analyzing'].includes(entry.result?.state) ||
       !force && !['failed', 'uncertain'].includes(entry.result?.state))) return false;
     entries.delete(key);
-    entries.set(key, { revision, result: { state: 'queued' } });
+    entries.set(key, { revision, cwd: candidate.cwd, forceAnalysis, settledResult: entry?.cwd === candidate.cwd ? entry.settledResult : null,
+      result: { state: 'queued' } });
     return true;
   };
+  const finishedAnalysis = (result, previous) => result.contextDigest && result.settledTurnId
+    ? { ...result, awaitingTurn: false, analyzedAt: result.contextDigest === previous?.contextDigest ? previous.analyzedAt : now() }
+    : previous;
   const startDrain = () => {
     if (closed || draining) return;
     draining = (async () => {
@@ -80,7 +84,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
             if (entry.result?.state !== 'queued' || !candidate || !eligible(candidate) || entry.revision !== continuationAnalysisRevision(candidate)) continue;
             entry.result = { state: 'analyzing' };
             await persist(); changed();
-            return { key, revision: entry.revision, candidate };
+            return { key, revision: entry.revision, candidate, previousAnalysis: entry.forceAnalysis ? null : entry.settledResult };
           }
           return null;
         });
@@ -96,7 +100,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
         });
         let result, inference;
         try {
-          inference = Promise.resolve(analyze(selected.candidate, { signal }));
+          inference = Promise.resolve(analyze(selected.candidate, { signal, previousAnalysis: selected.previousAnalysis }));
           result = await Promise.race([inference, cancellation]);
           if (!RESULT_STATES.has(result?.state) || typeof result.reason !== 'string' ||
             (result.state === 'continue' && (!result.objective || !result.remaining?.length || !result.nextAction || !result.basis?.some(item => item.role === 'user')))) {
@@ -114,12 +118,22 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
           const current = candidates.get(selected.key), entry = entries.get(selected.key);
           if (closed) return;
           if (!current || !eligible(current) || continuationAnalysisRevision(current) !== selected.revision || entry?.revision !== selected.revision) {
+            // Live timestamps may advance during inference while the completed
+            // boundary stays identical. Retain that snapshot for display/reuse;
+            // never publish it as a current actionable recommendation.
+            if (current && eligible(current) && current.cwd === selected.candidate.cwd && entry?.cwd === current.cwd &&
+                result.contextDigest && result.settledTurnId && ['queued', 'analyzing'].includes(entry.result?.state)) {
+              entry.settledResult = finishedAnalysis(result, selected.previousAnalysis);
+              await persist(); changed();
+            }
             if (entry?.revision === selected.revision && entry.result?.state === 'analyzing') {
               entry.result = { state: 'queued' }; await persist(); changed();
             }
             return;
           }
-          entries.set(selected.key, { revision: selected.revision, result: { ...result, analyzedAt: now() } });
+          const settledResult = finishedAnalysis(result, selected.previousAnalysis || entry.settledResult);
+          entries.set(selected.key, { revision: selected.revision, cwd: current.cwd, settledResult,
+            result: { ...result, analyzedAt: settledResult?.analyzedAt || now() } });
           await persist(); changed();
         });
       }
@@ -141,10 +155,21 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
         for (const candidate of sorted) {
           const key = keyOf(candidate), revision = continuationAnalysisRevision(candidate), previous = known.get(key);
           const active = activityOf(candidate);
-          const newActivity = document.initialized && (previous ? active > previous.activity : active > document.baselineAt);
-          if (eligible(candidate) && (backfill.has(key) || newActivity)) dirty = enqueue(candidate) || dirty;
+          const newActivity = document.initialized && (previous ? active > previous.activity || (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
+          const entry = entries.get(key);
+          // Migrate prior idle cache entries without treating historical sessions
+          // as fresh activity. Its old revision already proves this exact cwd.
+          if (entry && !entry.cwd && entry.revision === continuationAnalysisRevision({ ...candidate, isRunning: false })) {
+            entry.cwd = candidate.cwd;
+            entry.settledResult = entry.result?.contextDigest ? entry.result : null;
+            dirty = true;
+          }
+          // A reader that raced a terminal boundary (or a provider without live
+          // status) is retried at discovery cadence, never a busy inference loop.
+          const recheck = entry?.result?.reasonCode === 'turn_settling' || entry?.result?.awaitingTurn === true && candidate.isRunning !== true;
+          if (eligible(candidate) && (backfill.has(key) || newActivity || recheck)) dirty = enqueue(candidate, recheck) || dirty;
           if (previous?.revision !== revision) {
-            known.delete(key); known.set(key, { revision, activity: active }); dirty = true;
+            known.delete(key); known.set(key, { revision, activity: active, isRunning: candidate.isRunning }); dirty = true;
           }
         }
         // Empty discovery during provider startup must not consume backfill.
@@ -155,14 +180,23 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     },
     project(candidate) {
       const revision = continuationAnalysisRevision(candidate), entry = entries.get(keyOf(candidate));
-      return { ...candidate, analysis: entry?.revision === revision ? { ...entry.result, revision } : { state: 'unanalysed', revision } };
+      let analysis = entry?.revision === revision ? { ...entry.result, revision } : { 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,
+          reason: 'This turn is still running. SIMY analyzes only finished turns and will update automatically when it ends.',
+          ...(previous ? { previousAnalysis: previous } : {}) };
+      } else if (previous && ['queued', 'analyzing'].includes(analysis.state)) {
+        analysis.previousAnalysis = previous;
+      }
+      return { ...candidate, analysis };
     },
     async request(candidate) {
       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)) { await persist(); changed(); }
+        if (enqueue(candidate, true, true)) { await persist(); changed(); }
       });
       startDrain();
     },
@@ -178,7 +212,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     requireRecommendation(candidate) {
       if (closed) throw new Error('Session analysis is unavailable.');
       const analysis = this.project(candidate).analysis;
-      if (!eligible(candidate) || analysis.state !== 'continue') throw new Error('Analyze this conversation before continuing; it needs a current recommendation.');
+      if (!eligible(candidate) || candidate.isRunning === true || analysis.awaitingTurn === true || analysis.state !== 'continue') throw new Error('Analyze this conversation before continuing; it needs a current recommendation.');
       return analysis;
     },
     async whenIdle() { do { await serial; await draining; } while (draining); await serial; },

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

@@ -152,6 +152,7 @@ export function codexThreadMetadata(thread) {
     lastActivityAt: Number.isFinite(thread.updatedAt) ? thread.updatedAt * 1000 : null,
     model: typeof thread.model === 'string' ? thread.model : null,
     observation: { source: 'codex_app_server', observedAt: Date.now() },
+    ...(thread.status?.type === 'active' || thread.status?.type === 'idle' ? { isRunning: thread.status.type === 'active' } : {}),
     availability: 'unknown',
   };
 }
@@ -188,16 +189,14 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     // reads only metadata and a fixed number of recent display summaries.
     const metadata = await readCodexSession(client, candidate.session);
     if (metadata.cwd !== candidate.cwd) throw new CodexAppServerError('identity', 'Exact conversation identity is unavailable.');
-    if (Number.isFinite(candidate.lastActivityAt) && metadata.lastActivityAt !== candidate.lastActivityAt) {
-      throw new CodexAppServerError('revision_changed', 'Conversation changed since discovery.');
-    }
     if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
+    const terminal = turn => ['completed', 'interrupted', 'failed'].includes(turn?.status);
     const turns = [];
     const turnIds = new Set(), cursors = new Set();
     let cursor = null;
     do {
       if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
-      const limit = Math.min(ANALYSIS_PAGE_SIZE, ANALYSIS_MAX_TURNS - turns.length);
+      const limit = Math.min(ANALYSIS_PAGE_SIZE, ANALYSIS_MAX_TURNS - turns.filter(terminal).length);
       let page;
       try {
         page = await client.request('thread/turns/list', { threadId: candidate.session, cursor, limit, sortDirection: 'desc', itemsView: 'summary' });
@@ -217,10 +216,26 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
       cursor = page.nextCursor || null;
       if (cursor && (!page.data.length || cursors.has(cursor))) throw new CodexAppServerError('context_unavailable', 'Codex returned ambiguous conversation pagination.');
       if (cursor) cursors.add(cursor);
-    } while (cursor && turns.length < ANALYSIS_MAX_TURNS);
+    } while (cursor && turns.filter(terminal).length < ANALYSIS_MAX_TURNS && turns.length < ANALYSIS_MAX_TURNS + ANALYSIS_PAGE_SIZE);
+    // A timestamp covers the whole live thread. Instead pin the last terminal
+    // turn and check it again: streaming output in the newer turn is irrelevant
+    // to this read-only snapshot, but a newly settled turn must invalidate it.
+    const settled = turns.filter(terminal).slice(0, ANALYSIS_MAX_TURNS);
+    const boundary = settled[0];
+    const verification = await client.request('thread/turns/list', {
+      threadId: candidate.session, cursor: null, limit: ANALYSIS_PAGE_SIZE, sortDirection: 'desc', itemsView: 'summary',
+    });
+    if (!Array.isArray(verification?.data) || verification.data.length > ANALYSIS_PAGE_SIZE) {
+      throw new CodexAppServerError('context_unavailable', 'Codex returned an invalid snapshot check.');
+    }
+    const latestBoundary = verification.data.find(terminal);
+    // Compare the immutable settled summary, never the running turn's prose.
+    if (JSON.stringify(boundary) !== JSON.stringify(latestBoundary)) {
+      throw new CodexAppServerError('turn_settling', 'The latest turn settled during the snapshot read.');
+    }
     const latestMetadata = await readCodexSession(client, candidate.session);
     if (latestMetadata.cwd !== candidate.cwd) throw new CodexAppServerError('identity', 'Exact conversation identity is unavailable.');
-    if (latestMetadata.lastActivityAt !== metadata.lastActivityAt || latestMetadata.model !== metadata.model) {
+    if (latestMetadata.model !== metadata.model) {
       throw new CodexAppServerError('revision_changed', 'Conversation changed while reading recent history.');
     }
     if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation analysis was cancelled.');
@@ -228,13 +243,13 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
     // A display summary omits intermediate reasoning/tool context even when
     // every turn fits. Never represent it as the complete conversation; the
     // classifier must establish a self-contained objective from retained text.
-    let incomplete = !turns.length, truncated = true;
-    for (const [index, turn] of turns.toReversed().entries()) {
-      if (['inProgress', 'in_progress'].includes(turn?.status)) incomplete = true;
-      if (turn.itemsView === 'notLoaded') { truncated = true; if (turn === turns[0]) incomplete = true; continue; }
+    const awaitingTurn = latestMetadata.isRunning === true || [...turns, ...verification.data].some(turn => ['inProgress', 'in_progress'].includes(turn?.status));
+    let incomplete = !settled.length || turns.some(turn => !terminal(turn) && !['inProgress', 'in_progress'].includes(turn?.status)), truncated = true;
+    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 (turn === turns[0] && !turn.items.length) incomplete = true;
+      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;
@@ -243,7 +258,7 @@ export async function readCodexConversation(candidate, { openClient = openCodexA
         messages.push({ role, turnRef: `${turn.id || index}:${item.id || itemIndex}`, text });
       }
     }
-    return boundConversation(messages, { incomplete, truncated });
+    return { ...boundConversation(messages, { incomplete, truncated }), awaitingTurn, settledTurnId: boundary?.id || null };
   } finally {
     signal?.removeEventListener('abort', cancelled);
     await client.close();

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

@@ -45,6 +45,10 @@ function uncertain(reason) {
 }
 
 function unreadableContext(error) {
+  if (error?.code === 'turn_settling') return {
+    state: 'waiting', reason: 'The current turn is finishing. SIMY will check its completed result automatically.',
+    reasonCode: 'turn_settling', awaitingTurn: true, objective: '', remaining: [], nextAction: null, basis: [],
+  };
   // Provider error messages can include private paths or transcript text. Only
   // these known codes select product copy; never forward the original message.
   const reasons = {
@@ -105,11 +109,11 @@ export async function readContinuationContext(candidate, { signal, readContext,
   if (signal?.aborted) throw new Error('Conversation analysis was cancelled.');
   const context = boundConversation(raw?.messages, { truncated: raw?.truncated === true, incomplete: raw?.incomplete === true });
   const contextDigest = createHash('sha256').update(JSON.stringify({ provider: candidate.provider, session: candidate.session, cwd: candidate.cwd, ...context })).digest('hex');
-  return { ...context, contextDigest };
+  return { ...context, contextDigest, awaitingTurn: raw?.awaitingTurn === true, settledTurnId: typeof raw?.settledTurnId === 'string' ? raw.settledTurnId.slice(0, 160) : null };
 }
 
 export async function analyzeContinuation(candidate, {
-  signal, readContext, openCodexClient, claudeHome,
+  signal, readContext, openCodexClient, claudeHome, previousAnalysis,
   runProvider = runStructuredProviderReview, providerOptions = {},
 } = {}) {
   if (signal?.aborted) return uncertain('Conversation analysis was cancelled.');
@@ -121,6 +125,14 @@ export async function analyzeContinuation(candidate, {
     context = await readContinuationContext(candidate, { signal, readContext, openCodexClient, claudeHome });
   } catch (error) { return unreadableContext(error); }
   if (signal?.aborted) return uncertain('Conversation analysis was cancelled.');
+  const snapshot = { contextDigest: context.contextDigest, awaitingTurn: context.awaitingTurn, settledTurnId: context.settledTurnId };
+  if (context.awaitingTurn && !context.messages.length) return {
+    state: 'waiting', reason: 'The first turn is still running. SIMY will analyze it after it finishes.', ...snapshot,
+    objective: '', remaining: [], nextAction: null, basis: [],
+  };
+  if (previousAnalysis?.contextDigest === context.contextDigest && STATES.includes(previousAnalysis.state)) {
+    return { ...previousAnalysis, ...snapshot };
+  }
   if (context.incomplete || !context.messages.length) return uncertain('The latest conversation request or response is missing or incomplete.');
   try {
     const result = await runProvider(candidate.provider, {
@@ -129,7 +141,7 @@ export async function analyzeContinuation(candidate, {
     if (signal?.aborted) return uncertain('Conversation analysis was cancelled.');
     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 { ...analysis, contextDigest: context.contextDigest, ...(model ? { model } : {}) };
+    return { ...analysis, ...snapshot, ...(model ? { model } : {}) };
   } catch {
     // Provider stderr/errors may contain transcript text or credentials. Never
     // expose them to the desktop, cache, diagnostics or control plane.

package/src/session-supervision/index.js

@@ -56,6 +56,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     const supported = item.provider === 'codex' && item.observation.source === 'codex_app_server' && Boolean(item.model) && !codexError;
     const liveHook = item.provider === 'claude' && !claudeError && await liveClaudeHook(record, item, inspectProcess);
     return { provider: item.provider, session: item.session, cwd: item.cwd, title: item.title, source: item.source,
+      ...(typeof item.isRunning === 'boolean' ? { isRunning: item.isRunning } : {}),
       lastActivityAt: item.lastActivityAt, observation: item.observation, availability: item.availability,
       binding: { mode, taskId: run?.managed?.taskId || null },
       originalSessionTarget: originalSessionTarget(item.provider, item.session),