@awak-app/simy-cli 0.6.9 → 0.6.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.9",
+  "version": "0.6.10",
   "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.6.9";
+export const CLI_VERSION = "0.6.10";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function withCliContract(

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

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { analyzeContinuation, CONTINUATION_ANALYSIS_VERSION } from './continuation-analysis.js';
+import { providerGoalEvidence } from './conversation-context.js';
 
 const BACKFILL_LIMIT = 10;
 const MAX_CACHE_ENTRIES = 2000;
@@ -9,12 +10,17 @@ const AUTH_RECOVERY_COOLDOWN_MS = 60_000;
 const RESULT_STATES = new Set(['continue', 'no_action', 'needs_user', 'waiting', 'uncertain']);
 const keyOf = candidate => `${candidate.provider}:${candidate.session}`;
 const activityOf = candidate => Number.isFinite(candidate.lastActivityAt) ? candidate.lastActivityAt : 0;
-const goalOf = candidate => candidate.providerGoal && typeof candidate.providerGoal === 'object'
-  ? [candidate.providerGoal.objective ?? null, candidate.providerGoal.status ?? null, candidate.providerGoal.updatedAt ?? null,
-    candidate.providerGoal.textTruncated === true] : null;
+const turnOf = candidate => candidate.provider === 'codex' && typeof candidate.latestTurnId === 'string' && candidate.latestTurnId
+  ? candidate.latestTurnId : null;
+const goalOf = candidate => providerGoalEvidence(candidate.providerGoal);
+const legacyRevision = candidate => createHash('sha256').update(JSON.stringify([
+  candidate.provider, candidate.session, candidate.cwd, activityOf(candidate), ...(candidate.isRunning === true ? ['running'] : []),
+  ...(goalOf(candidate) === null ? [] : ['goal', [candidate.providerGoal.objective ?? null, candidate.providerGoal.status ?? null,
+    candidate.providerGoal.updatedAt ?? null, candidate.providerGoal.textTruncated === true]]),
+])).digest('hex');
 const goalRevisionOf = candidate => goalOf(candidate) === null ? null : createHash('sha256').update(JSON.stringify(goalOf(candidate))).digest('hex');
 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, turnOf(candidate) ? ['turn', turnOf(candidate)] : activityOf(candidate),
     ...(candidate.isRunning === true ? ['running'] : []), ...(goalOf(candidate) === null ? [] : ['goal', goalOf(candidate)])]))
   .digest('hex');
 const eligible = candidate => candidate.capabilities?.canAnalyze === true &&
@@ -50,6 +56,14 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
   const known = new Map(document.known.slice(-MAX_CACHE_ENTRIES));
   const entries = new Map(document.entries.slice(-MAX_CACHE_ENTRIES));
   const candidates = new Map();
+  const observedCandidate = candidate => {
+    const previous = known.get(keyOf(candidate));
+    // A bounded discovery may skip this turn probe. Preserve its prior ID
+    // only while identity and activity still match; changed activity must be read.
+    return !turnOf(candidate) && candidate.provider === 'codex' && previous?.latestTurnId &&
+      previous.cwd === candidate.cwd && previous.activity === activityOf(candidate)
+      ? { ...candidate, latestTurnId: previous.latestTurnId } : candidate;
+  };
   const providerStatuses = new Map(), signedOutChecks = new Map();
   for (const [key, entry] of entries) {
     if (entry.result?.state === 'analyzing') entry.result = { state: 'queued' };
@@ -231,7 +245,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       await exclusive(async () => {
         if (closed || suspended) return;
         candidates.clear();
-        for (const candidate of sessions) candidates.set(keyOf(candidate), candidate);
+        for (const candidate of sessions) candidates.set(keyOf(candidate), observedCandidate(candidate));
         const sorted = [...candidates.values()].sort((a, b) => activityOf(b) - activityOf(a) || keyOf(a).localeCompare(keyOf(b)));
         const backfill = document.initialized ? new Set() : new Set(sorted.slice(0, BACKFILL_LIMIT).map(keyOf));
         let dirty = !document.initialized;
@@ -242,10 +256,19 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
           // Old cache formats did not observe goal/tracking metadata. Establish
           // their baseline once, rather than mistaking the upgrade for activity.
           const goalObserved = candidate.goalReadState !== 'unavailable';
-          const goalChanged = previous && Object.hasOwn(previous, 'goalRevision') && previous.goalObserved !== false && goalObserved && previous.goalRevision !== goalRevision;
+          const goalChanged = previous && previous.goalEvidenceVersion === 1 && Object.hasOwn(previous, 'goalRevision') && previous.goalObserved !== false && goalObserved && previous.goalRevision !== goalRevision;
           const trackingEnabled = candidate.tracked === true && (!previous || Object.hasOwn(previous, 'tracked') && previous.tracked !== true);
-          const newActivity = document.initialized && (previous ? active > previous.activity || (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
+          // A known turn boundary is stronger than updated_at: tool/status
+          // events in that same turn must not enqueue or cancel paid inference.
+          const newActivity = document.initialized && (previous ?
+            (turnOf(candidate) && previous.latestTurnId ? turnOf(candidate) !== previous.latestTurnId : active > previous.activity) ||
+            (candidate.isRunning === true) !== (previous.isRunning === true) : active > document.baselineAt);
           const entry = entries.get(key);
+          // Rebase unchanged old cache keys once without rerunning historical
+          // inference when semantic goal/turn keys become available.
+          if (entry && entry.revision !== revision && entry.cwd === candidate.cwd && entry.revision === legacyRevision(candidate)) {
+            entry.revision = revision; dirty = true;
+          }
           // 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 })) {
@@ -261,9 +284,10 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
           if (eligible(candidate) && (backfill.has(key) || newActivity || recheck || trackingEnabled || goalChanged || schemaRefresh)) {
             dirty = enqueue(candidate, recheck || trackingEnabled || goalChanged || schemaRefresh, trackingEnabled || goalChanged || schemaRefresh) || dirty;
           }
-          if (previous?.revision !== revision || previous?.goalObserved !== goalObserved || (previous?.tracked === true) !== (candidate.tracked === true) ||
+          if (previous?.revision !== revision || previous?.activity !== active || previous?.goalEvidenceVersion !== 1 || previous?.goalObserved !== goalObserved || (previous?.tracked === true) !== (candidate.tracked === true) ||
               previous && (!Object.hasOwn(previous, 'goalRevision') || !Object.hasOwn(previous, 'tracked'))) {
-            known.delete(key); known.set(key, { revision, activity: active, isRunning: candidate.isRunning, tracked: candidate.tracked === true, goalRevision, goalObserved }); dirty = true;
+            known.delete(key); known.set(key, { revision, cwd: candidate.cwd, activity: active, isRunning: candidate.isRunning, latestTurnId: turnOf(candidate),
+              tracked: candidate.tracked === true, goalRevision, goalObserved, goalEvidenceVersion: 1 }); dirty = true;
           }
         }
         // Cancelling owned analysis is separate from stopping the original
@@ -280,6 +304,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       startDrain();
     },
     project(candidate) {
+      candidate = observedCandidate(candidate);
       const revision = continuationAnalysisRevision(candidate), entry = entries.get(keyOf(candidate));
       let analysis = entry?.revision === revision ? { ...entry.result, revision, requestId: entry.requestId } : { state: 'unanalysed', revision };
       const previous = entry?.cwd === candidate.cwd ? entry.settledResult : null;
@@ -295,6 +320,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
     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.');
+      candidate = observedCandidate(candidate);
       await exclusive(async () => {
         if (closed || suspended) throw new Error('Session analysis is unavailable.');
         candidates.set(keyOf(candidate), candidate);
@@ -306,6 +332,7 @@ export async function createContinuationAnalysisManager({ root, analyze = analyz
       startDrain();
     },
     async invalidate(candidate) {
+      candidate = observedCandidate(candidate);
       await exclusive(async () => {
         if (closed || suspended) throw new Error('Session analysis is unavailable.');
         entries.delete(keyOf(candidate));

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

@@ -262,6 +262,7 @@ export async function readCodexObservation(client, session, { deadline = Date.no
     const page = await client.request('thread/turns/list', { threadId: session, cursor: null, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded' }, timeout());
     if (Array.isArray(page?.data) && page.data.length === 1 && ['inProgress', 'completed', 'interrupted', 'failed'].includes(page.data[0]?.status)) {
       observation.isRunning = page.data[0].status === 'inProgress';
+      if (typeof page.data[0].id === 'string' && page.data[0].id && page.data[0].id.length <= 160) observation.latestTurnId = page.data[0].id;
     }
   } catch (error) {
     if (['timeout', 'closed', 'unavailable'].includes(error?.code)) return { goalReadState: 'unavailable', providerUnavailable: true };

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

@@ -1,6 +1,6 @@
 import { readCodexConversation } from './codex-app-server.js';
 import { readClaudeConversation } from './claude-sessions.js';
-import { boundConversation, boundProviderGoal, sanitizedText } from './conversation-context.js';
+import { boundConversation, boundProviderGoal, providerGoalEvidence, sanitizedText } from './conversation-context.js';
 import { runStructuredProviderReview } from '../sqm/review-worker.js';
 import { inspectProviderStatus } from '../desktop-status.js';
 import { createHash } from 'node:crypto';
@@ -152,7 +152,7 @@ export async function readContinuationContext(candidate, { signal, readContext,
   const context = boundConversation(raw?.messages, { truncated: raw?.truncated === true, incomplete: raw?.incomplete === true });
   const providerGoal = boundProviderGoal(raw?.providerGoal);
   const contextDigest = createHash('sha256').update(JSON.stringify({ provider: candidate.provider, session: candidate.session, cwd: candidate.cwd, ...context,
-    ...(providerGoal ? { providerGoal } : {}) })).digest('hex');
+    ...(providerGoal ? { providerGoal: providerGoalEvidence(providerGoal) } : {}) })).digest('hex');
   return { ...context, providerGoal, contextDigest, awaitingTurn: raw?.awaitingTurn === true, settledTurnId: typeof raw?.settledTurnId === 'string' ? raw.settledTurnId.slice(0, 160) : null };
 }
 
@@ -185,7 +185,7 @@ export async function analyzeContinuation(candidate, {
     basis: [{ role: 'goal', turnRef: 'provider-goal', snippet: context.providerGoal.objective.slice(0, 280) }],
   };
   if (previousAnalysis?.analysisVersion === CONTINUATION_ANALYSIS_VERSION && previousAnalysis?.contextDigest === context.contextDigest && STATES.includes(previousAnalysis.state)) {
-    return { ...snapshot, ...previousAnalysis };
+    return { ...previousAnalysis, ...snapshot };
   }
   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;

package/src/session-supervision/conversation-context.js

@@ -21,6 +21,13 @@ export function textContent(content) {
 }
 
 const GOAL_STATES = new Set(['active', 'paused', 'blocked', 'usageLimited', 'budgetLimited', 'complete']);
+// Goal timestamps can advance with provider bookkeeping without changing the
+// evidence relevant to triage. Keep timestamps for provenance, not cache keys.
+export function providerGoalEvidence(goal) {
+  return goal && typeof goal === 'object' ? { objective: goal.objective ?? null, status: goal.status ?? null,
+    textTruncated: goal.textTruncated === true } : null;
+}
+
 // Original provider metadata is evidence about the goal, never permission for
 // this separate read-only classifier to execute work or change provider limits.
 export function boundProviderGoal(goal) {

package/src/session-supervision/index.js

@@ -114,6 +114,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
     return { provider: item.provider, session: item.session, cwd: item.cwd,
       title: sessionTitle(item.title) || (item.provider === 'codex' ? codexTitles.get(item.session) || '' : ''), source: item.source,
       ...(typeof isRunning === 'boolean' ? { isRunning } : {}),
+      ...(item.latestTurnId ? { latestTurnId: item.latestTurnId } : {}),
       ...(item.providerGoal !== undefined ? { providerGoal: item.providerGoal } : {}),
       ...(item.goalReadState ? { goalReadState: item.goalReadState } : {}),
       tracked: typeof record?.tracked === 'boolean' ? record.tracked : record?.monitor === true,

package/src/sqm/provider-diagnostics.js

@@ -11,7 +11,7 @@ export function safeProviderDiagnostic(value) {
   if (SIGNALS.has(value.signal)) result.signal = value.signal;
   if (Number.isInteger(value.outputBytes) && value.outputBytes >= 0 && value.outputBytes <= 2147483647) result.outputBytes = value.outputBytes;
   if (value.retryAttempt === 0 || value.retryAttempt === 1) result.retryAttempt = value.retryAttempt;
-  if (typeof value.model === "string" && /^(?:gpt-6-(?:astra)|gpt-6\.1-sol|claude-(?:sonnet|opus|haiku)-[0-9]+(?:-[0-9]+){0,3})$/.test(value.model) && value.model.length <= 64) result.model = value.model;
+  if (typeof value.model === "string" && /^(?:gpt-6-(?:astra|sol)|gpt-6\.1-sol|claude-(?:sonnet|opus|haiku)-[0-9]+(?:-[0-9]+){0,3})$/.test(value.model) && value.model.length <= 64) result.model = value.model;
   return result;
 }
 

package/src/sqm/review-worker.js

@@ -20,7 +20,8 @@ const DEFAULT_REQUEST_TIMEOUT_MS = 75_000;
 const DEFAULT_EXECUTION_TIMEOUT_MS = 240_000;
 // Keep analysis independent of interactive config. Availability varies by
 // account and CLI; only an explicit model rejection may try the next model.
-export const SQM_CODEX_MODELS = Object.freeze(["gpt-6-astra", "gpt-6.1-sol"]);
+// Background SQM and conversation triage use Sol models to limit usage.
+export const SQM_CODEX_MODELS = Object.freeze(["gpt-6.1-sol", "gpt-6-sol"]);
 export const SQM_CODEX_MODEL = SQM_CODEX_MODELS[0];
 
 export class SqmLocalReviewError extends Error {