@awak-app/simy-cli 0.5.38 → 0.5.40

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

@@ -44,6 +44,27 @@ function uncertain(reason) {
   return { state: 'uncertain', reason, objective: '', remaining: [], nextAction: null, basis: [] };
 }
 
+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 = {
+    response_too_large: 'A conversation response exceeded the supported size. Open the original conversation or retry after updating SIMY.',
+    revision_changed: 'This conversation changed while it was being read. Wait until it finishes, then retry analysis.',
+    timeout: 'The provider did not return the conversation in time. Retry analysis when it is available.',
+    identity: 'The original conversation identity or workspace no longer matches. Refresh sessions and retry analysis.',
+    unsupported: 'This Codex version does not support the required conversation reader. Update Codex and retry analysis.',
+    unavailable: 'The local provider is unavailable. Open its app, then retry analysis.',
+    cancelled: 'Conversation analysis was cancelled.',
+  };
+  const code = error?.code === -32601 ? 'unsupported' : error?.code;
+  const reasonCode = Object.hasOwn(reasons, code) ? code : 'context_unavailable';
+  return { ...uncertain(reasons[reasonCode] || 'The conversation could not be read. Refresh sessions and retry analysis.'), reasonCode };
+}
+
 function boundedString(value, maximum, required = false) {
   if (typeof value !== 'string' || value.length > maximum || sanitizedText(value) !== value || (required && !value)) throw new Error('Invalid string');
   return value;
@@ -88,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.');
@@ -102,8 +123,16 @@ export async function analyzeContinuation(candidate, {
   let context;
   try {
     context = await readContinuationContext(candidate, { signal, readContext, openCodexClient, claudeHome });
-  } catch { return uncertain('Conversation context could not be read safely.'); }
+  } 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, {
@@ -112,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/handoff.js

@@ -6,7 +6,7 @@ import { openCodexAppServer, readCodexSession } from './codex-app-server.js';
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function unsettled(managed) {
-  return managed.phase === 'understanding' || managed.executionUncertain || managed.executionAttempt && managed.executionAttempt.phase !== 'checkpointed' || managed.providerWarning || managed.resumeLease || managed.pendingApproval || managed.approvedAction && !managed.approvedAction.dispatchedAt ||
+  return ['understanding', 'action_association'].includes(managed.phase) || managed.executionUncertain || managed.executionAttempt && managed.executionAttempt.phase !== 'checkpointed' || managed.providerWarning || managed.resumeLease || managed.pendingApproval || managed.approvedAction && !managed.approvedAction.dispatchedAt ||
     managed.dispatchLedger?.some(entry => !['settled', 'cancelled'].includes(entry.status)) ||
     managed.dispatches?.some(entry => entry.status && !['settled', 'cancelled', 'completed'].includes(entry.status));
 }

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),

package/src/sqm/claude-plugin.js

@@ -21,6 +21,7 @@ export async function claudePluginFiles() {
     files.set(relative, content.replaceAll("current Codex thread", "current Claude Code conversation"));
   }
   files.set("hooks/delivery-loop.mjs", await readFile(path.join(SOURCE, "hooks/delivery-loop.mjs"), "utf8"));
+  files.set("hooks/action-association.mjs", await readFile(path.join(SOURCE, "hooks/action-association.mjs"), "utf8"));
   files.set("hooks/workspace-lease.mjs", await readFile(path.join(SOURCE, "hooks/workspace-lease.mjs"), "utf8"));
   files.set("hooks/connection-reminder.mjs", await readFile(path.join(SOURCE, "hooks/connection-reminder.mjs"), "utf8"));
   const hooks = JSON.parse(await readFile(path.join(SOURCE, "hooks/hooks.json"), "utf8"));