@awak-app/simy-cli 0.6.4 → 0.6.6

package/README.md

@@ -178,7 +178,12 @@ marketplace still points to SIMY’s generated local source. Plugin versions inc
 receive a fresh cache. Use a new Codex task to pick up updated skills; running
 tasks are not restarted. Missing or disabled plugins are not enabled automatically.
 Failed refreshes retry on the next check without blocking daemon startup.
-The desktop Sessions page discovers existing provider conversations and lets users
+The desktop Sessions page loads a recent window of up to 200 conversations,
+ranked by last activity. Explicitly tracked, monitored, auto-continue and unsettled
+supervision records remain visible even outside that window. Claude discovery
+ranks file metadata before opening selected transcripts. A conflicting saved
+workspace leaves only that conversation's Action association unavailable; it
+does not stop discovery or change the saved identity. The page lets users
 choose monitoring or supported session supervision with a goal, acceptance
 criteria and an autonomy policy. Local time, token and continuation counters do not stop work. Codex enrollment uses an exact
 app-server session and checks writer ownership before each continuation. Claude

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -38,7 +38,7 @@
     "test:e2e:console:real-provider": "node ./scripts/real-provider-console-e2e.js",
     "test:e2e:console:fullstack": "node ./scripts/fullstack-cli-smoke.js",
     "check": "npm run check:auto-update && node --check ./src/desktop-executor.js && node --check ./src/local-task.js && node --check ./scripts/desktop-executor-e2e.js && node --check ./scripts/pre-guardrail-e2e.js && node --check ./scripts/fixtures/fake-desktop-provider.js && npm run check:syntax && npm run check:session-supervision-syntax && npm run check:real-provider-syntax && npm test && npm run check:package",
-    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
+    "check:session-supervision-syntax": "node --check ./src/session-supervision/index.js && node --check ./src/session-supervision/discovery-window.js && node --check ./src/session-supervision/codex-app-server.js && node --check ./src/session-supervision/claude-sessions.js && node --check ./src/session-supervision/original-session-target.js && node --check ./src/session-supervision/action-association.js && node --check ./src/session-supervision/action-association-host.js && node --check ./src/session-supervision/action-association-api.js && node --check ./src/session-supervision/association-store.js && node --check ./src/session-supervision/action-deadline.js && node --check ./src/session-supervision/action-deadline-store.js && node --check ./src/codex-plugins/simy/hooks/action-association.mjs",
     "check:auto-update": "node --check ./src/auto-update.js && node --check ./scripts/auto-update-e2e.js && npm run check:sqm",
     "check:workflow-observation-sender": "node --check ./src/workflow-observation-sender.js",
     "check:sqm": "node --check ./src/sqm/canonical.js && node --check ./src/sqm/validation.js && node --check ./src/sqm/reliability.js && node --check ./src/sqm/repository.js && node --check ./src/sqm/checkers.js && node --check ./src/sqm/bundle-store.js && node --check ./src/sqm/proof.js && node --check ./src/sqm/evidence-client.js && node --check ./src/sqm/session.js && node --check ./src/sqm/index.js && node --check ./src/sqm/command.js && node --check ./src/sqm/agent-skill.js && node --check ./src/sqm/workflow-onboarding.js && node --check ./src/sqm/workflow-update.js && node --check ./src/sqm/history-store.js && node --check ./src/sqm/review-worker.js && node --check ./scripts/sqm-complete-loop-e2e.js && node --check ./scripts/sqm-local-review-e2e.js",

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

package/src/desktop-host.js

@@ -462,7 +462,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           if (command.force !== true) throw new Error("Confirm before stopping this task.");
           await agent.stopDesktopTask(command.taskKey);
           emit({ type: "result", id: command.id, ok: true });
-          void publish(); return;
+          void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); return;
         }
         const access = await accessSnapshot();
         const commandScope = accessScope(access);
@@ -482,7 +482,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
           statisticsCache.clear(); // Only the selected conversation needs chart data.
           statisticsCache.set(`${candidate.provider}:${candidate.session}`, statistics);
           emit({ type: "result", id: command.id, ok: true });
-          void publish(); return;
+          void publish().catch(() => emit({ type: "error", message: "SIMY status could not be refreshed." })); return;
         }
         if (action === "my_ai_session") {
           const ticket = await agent.createDesktopWebSession();

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

@@ -200,7 +200,10 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
     async decorateSessions(sessions, projection) {
       await ordinary.decorate(sessions, projection);
       const records = projection?.byKey || new Map((await list(root)).map(record => [`${record.provider}:${record.session}`, record]));
-      const status = { runs: sessions.filter(item => records.get(`${item.provider}:${item.session}`)?.run?.managed).map(item => {
+      const status = { runs: sessions.filter(item => {
+        const record = records.get(`${item.provider}:${item.session}`);
+        return record?.run?.managed && record.cwd === item.cwd;
+      }).map(item => {
         const record = records.get(`${item.provider}:${item.session}`);
         return { managed: true, taskId: record.run.managed.taskId, actionAssociation: record.run.managed.actionAssociation, candidate: item };
       }) };
@@ -212,6 +215,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       const expected = projection ? projection.authRevision : await current(), record = projection
         ? projection.byKey.get(`${candidate.provider}:${candidate.session}`)
         : await read(root, candidate.provider, candidate.session);
+      if (record?.cwd !== candidate.cwd) return null;
       const local = record?.run?.managed?.actionAssociation || record?.actionAssociation;
       if (!expected || projection && auth !== expected || local?.authRevision !== expected || !(candidate.actionAssociation?.canCorrect || candidate.actionAssociation?.canReadBinding)) return null;
       const binding = candidate.actionAssociation.binding;
@@ -224,7 +228,7 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
           const latest = await read(root, candidate.provider, candidate.session);
           const scoped = latest?.run?.managed?.actionAssociation || latest?.actionAssociation;
           if (!await valid(expected)) return false;
-          return (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
+          return latest?.cwd === candidate.cwd && (latest?.run?.managed?.taskId || latest?.associationTaskId) === candidate.taskId && scoped?.namespace === local.namespace && scoped?.authRevision === expected && fingerprint(scoped.binding) === fingerprint(binding);
         } };
 
     },

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

@@ -212,11 +212,20 @@ export function createOrdinaryAssociationStore({
       for (const taskId of views.keys()) if (!taskIds.has(taskId) && !inFlight.has(taskId)) views.delete(taskId);
       const pending = [];
       for (const candidate of sessions) {
-        const record = await ensure(
+        let record;
+        try {
+          record = await ensure(
             candidate,
             records.get(`${candidate.provider}:${candidate.session}`) || null,
-          ),
-          taskId = record.run?.managed?.taskId || record.associationTaskId;
+          );
+        } catch (error) {
+          // A stale workspace or unreadable local record affects only this
+          // optional association. Never rewrite its identity or stop the host.
+          candidate.actionAssociation = { status: error?.code === 'conflict' ? 'conflict' : 'unavailable',
+            binding: null, candidates: [], canCorrect: false, canReadBinding: false };
+          continue;
+        }
+        const taskId = record.run?.managed?.taskId || record.associationTaskId;
         candidate.taskId = taskId;
         candidate.binding = { ...candidate.binding, taskId };
         if (record.run?.managed) continue;

package/src/session-supervision/claude-sessions.js

@@ -5,6 +5,7 @@ import { homedir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { boundConversation, CONVERSATION_LIMITS, textContent } from './conversation-context.js';
 import { sessionTitle } from './session-titles.js';
+import { RECENT_SESSION_LIMIT, recentSessionWindow } from './discovery-window.js';
 
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const MAX_PROJECTS = 256;
@@ -147,14 +148,14 @@ async function inspectTranscript(root, projectName, fileName, observedAt, includ
   finally { await handle?.close(); }
 }
 
-async function collect({ home = homedir(), limit = 100, session = null, includeContext = false, cacheMetadata = false, includeStatistics = false, signal } = {}) {
+async function collect({ home = homedir(), limit = 100, session = null, prioritySessions = [], includeContext = false, cacheMetadata = false, includeStatistics = false, signal } = {}) {
   if (signal?.aborted) return [];
   const root = await projectsRoot(home);
   if (!root) return [];
-  const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, 200)) : 100;
+  const maximum = Number.isInteger(limit) ? Math.max(1, Math.min(limit, RECENT_SESSION_LIMIT)) : 100;
   const observedAt = Date.now();
   const result = new Map();
-  let inspected = 0;
+  const descriptors = [], priorities = new Set(prioritySessions);
   let projects;
   try { projects = await readdir(root, { withFileTypes: true }); } catch { return []; }
   for (const entry of projects.filter(item => item.isDirectory() && !item.isSymbolicLink()).slice(0, MAX_PROJECTS)) {
@@ -162,32 +163,47 @@ async function collect({ home = homedir(), limit = 100, session = null, includeC
     const project = join(root, entry.name);
     let files;
     try { files = await readdir(project, { withFileTypes: true }); } catch { continue; }
-    for (const file of files) {
-      if (signal?.aborted) return [];
-      if (inspected >= MAX_TRANSCRIPTS) break;
-      if (!file.isFile() || file.isSymbolicLink() || !UUID.test(file.name.replace(/\.jsonl$/, '')) || !file.name.endsWith('.jsonl')) continue;
-      const id = file.name.slice(0, -'.jsonl'.length);
-      if (session && id !== session) continue;
-      inspected++;
-      const candidate = await inspectTranscript(root, entry.name, file.name, observedAt, includeContext, cacheMetadata, includeStatistics);
-      if (!candidate) continue;
-      const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics ? `\0${entry.name}\0${file.name}` : ''}`;
-      if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
-    }
-    if (inspected >= MAX_TRANSCRIPTS) break;
+    const candidates = files.filter(file => file.isFile() && !file.isSymbolicLink() &&
+      file.name.endsWith('.jsonl') && UUID.test(file.name.slice(0, -'.jsonl'.length)) &&
+      (!session || file.name === `${session}.jsonl`));
+    let next = 0;
+    // Ranking uses file metadata only. Opening every transcript before slicing
+    // made a small visible catalog scan thousands of message prefixes at startup.
+    await Promise.all(Array.from({ length: Math.min(8, candidates.length) }, async () => {
+      while (next < candidates.length && !signal?.aborted) {
+        const file = candidates[next++];
+        try {
+          const info = await lstat(join(project, file.name));
+          if (info.isFile() && !info.isSymbolicLink() && info.size <= MAX_FILE_BYTES)
+            descriptors.push({ projectName: entry.name, fileName: file.name,
+              session: file.name.slice(0, -'.jsonl'.length), lastActivityAt: info.mtimeMs });
+        } catch { /* A disappearing transcript does not stop discovery. */ }
+      }
+    }));
+  }
+  if (signal?.aborted) return [];
+  const selected = session ? descriptors : recentSessionWindow(descriptors, {
+    limit: maximum, priority: item => priorities.has(item.session),
+  });
+  for (const file of selected.slice(0, MAX_TRANSCRIPTS)) {
+    if (signal?.aborted) return [];
+    const candidate = await inspectTranscript(root, file.projectName, file.fileName, observedAt, includeContext, cacheMetadata, includeStatistics);
+    if (!candidate) continue;
+    const key = `${candidate.session}\0${candidate.cwd}${includeContext || includeStatistics ? `\0${file.projectName}\0${file.fileName}` : ''}`;
+    if (!result.has(key) || candidate.lastActivityAt > result.get(key).lastActivityAt) result.set(key, candidate);
   }
   const sorted = [...result.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt || a.session.localeCompare(b.session));
-  return session ? sorted : sorted.slice(0, maximum);
+  return session ? sorted : recentSessionWindow(sorted, { limit: maximum, priority: item => priorities.has(item.session) });
 }
 
-export async function listClaudeSessions({ home, limit, signal } = {}) {
-  return collect({ home, limit, signal, cacheMetadata: true });
+export async function listClaudeSessions({ home, limit, prioritySessions, signal } = {}) {
+  return collect({ home, limit, prioritySessions, signal, cacheMetadata: true });
 }
 
 export async function readClaudeSession(session, { home } = {}) {
   const id = typeof session === 'string' ? session : session?.session;
   if (typeof id !== 'string' || !UUID.test(id)) return null;
-  const matches = await collect({ home, limit: 200, session: id });
+  const matches = await collect({ home, limit: RECENT_SESSION_LIMIT, session: id });
   const selected = typeof session === 'object' && typeof session.cwd === 'string'
     ? matches.filter(item => item.cwd === session.cwd) : matches;
   return selected.length === 1 ? selected[0] : null;

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

@@ -5,6 +5,7 @@ import { CODEX_WRITER_LOCK_MINIMUM_VERSION, compareVersions, inspectBackendExecu
 import { assessedCheckpointContract, deliveryProgressContext, understandingCheckpointContract } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
 import { boundConversation, boundProviderGoal, textContent } from './conversation-context.js';
 import { JsonDataUrlFilter } from './json-data-url-filter.js';
+import { RECENT_SESSION_LIMIT } from './discovery-window.js';
 
 const REQUEST_TIMEOUT = 15_000;
 const MAX_LINE = 256 * 1024;
@@ -187,14 +188,15 @@ export function codexThreadMetadata(thread) {
   };
 }
 
-export async function listCodexSessions({ client, maxPages = 40, pageSize = 25, maxSessions = 200, inspectState = false, prioritySessions = [], observationBudgetMs = 3000 } = {}) {
+export async function listCodexSessions({ client, maxPages = 40, pageSize = 25, maxSessions = RECENT_SESSION_LIMIT, inspectState = false, prioritySessions = [], observationBudgetMs = 3000 } = {}) {
   const sessions = [];
   const windowSize = Math.min(maxSessions, maxPages * pageSize);
   let cursor = null, listed = 0, pages = 0, batchSize = pageSize;
   while (pages < Math.max(maxPages, Math.ceil(windowSize / batchSize)) && listed < windowSize) {
     const limit = Math.min(batchSize, windowSize - listed);
     let response;
-    try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS, archived: false }); }
+    try { response = await client.request('thread/list', { cursor, limit, sourceKinds: SOURCE_KINDS,
+      archived: false, sortKey: 'updated_at', sortDirection: 'desc' }); }
     catch (error) {
       // Keep the transport's byte limit. Retry the same cursor in smaller
       // batches rather than dropping discovery for large metadata envelopes.

package/src/session-supervision/discovery-window.js

@@ -0,0 +1,15 @@
+import { TERMINAL } from '../codex-plugins/simy/hooks/delivery-loop.mjs';
+
+export const RECENT_SESSION_LIMIT = 200;
+
+// Explicit tracking and unsettled work remain visible outside recent history.
+// Completed, untracked records are history, not an unlimited extra catalog.
+export const retainedSession = record => Boolean(record?.autoContinue || record?.monitor || record?.tracked ||
+  record?.run && !TERMINAL.has(record.run.state));
+
+export function recentSessionWindow(items, { limit = RECENT_SESSION_LIMIT, priority = () => false } = {}) {
+  const recent = [...items].sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0) || a.session.localeCompare(b.session));
+  const retained = [], history = [];
+  for (const item of recent) (priority(item) ? retained : history).push(item);
+  return [...retained, ...history.slice(0, Math.max(0, limit - retained.length))];
+}

package/src/session-supervision/index.js

@@ -5,6 +5,7 @@ import { listCodexSessions, openCodexAppServer, readCodexSession, CodexAppServer
 import { listClaudeSessions, readClaudeSession } from './claude-sessions.js';
 import { originalSessionTarget } from './original-session-target.js';
 import { readCodexTitles, sessionTitle } from './session-titles.js';
+import { RECENT_SESSION_LIMIT, recentSessionWindow, retainedSession } from './discovery-window.js';
 
 function autoContinueState(record, isRunning, supported) {
   if (record?.autoContinue !== true) return { autoContinueStatus: 'off', autoContinueReason: null };
@@ -58,28 +59,34 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   const assertActive = () => { if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Conversation discovery was cancelled.'); };
   assertActive();
   const records = await listRecords(root);
+  const priorities = records.filter(retainedSession);
   let discovered = [], codexError = null, claude = [], claudeError = null;
   try { discovered = await withClient(openClient, client => listCodexSessions({ client, inspectState: true,
-    prioritySessions: records.filter(record => record.provider === 'codex' && (record.autoContinue || record.monitor || record.tracked || record.run)).map(record => record.session) }), signal); }
+    maxSessions: RECENT_SESSION_LIMIT,
+    prioritySessions: priorities.filter(record => record.provider === 'codex').map(record => record.session) }), signal); }
   catch (error) { codexError = error?.code === 'unavailable' ? 'Codex executable unavailable.' : error?.code === 'unsupported' ? 'This Codex version lacks a verified app-server writer lock; update before enrollment.' : 'Codex conversation discovery unavailable.'; }
   assertActive();
-  try { claude = await listClaude({ signal }); } catch { claudeError = 'Claude conversation discovery unavailable.'; }
+  try { claude = await listClaude({ signal, limit: RECENT_SESSION_LIMIT,
+    prioritySessions: priorities.filter(record => record.provider === 'claude').map(record => record.session) }); }
+  catch { claudeError = 'Claude conversation discovery unavailable.'; }
   assertActive();
   const byKey = new Map();
   const recordsByKey = new Map(records.map(record => [`${record.provider}:${record.session}`, record]));
   for (const item of [...discovered, ...claude]) byKey.set(`${item.provider}:${item.session}`, item);
   for (const record of records) {
     const key = `${record.provider}:${record.session}`;
-    if (!byKey.has(key) && (record.observedAt || record.admission || record.monitor || record.run)) byKey.set(key, {
+    if (!byKey.has(key) && (record.observedAt || record.admission || retainedSession(record))) byKey.set(key, {
       provider: record.provider, session: record.session, cwd: record.cwd, title: '', source: record.admission?.source || 'hook',
       lastActivityAt: record.observedAt || record.admission?.validatedAt || record.run?.updatedAt || null,
       observation: { source: record.admission?.source || `${record.provider}_hook`, observedAt: record.observedAt || record.admission?.validatedAt || null },
       availability: 'unknown', model: record.admission?.model || null,
     });
   }
-  // Historical sessions must not fan out hundreds of process-inspection
-  // subprocesses. Preserve input ordering while limiting live metadata probes.
-  const items = [...byKey.values()], projected = new Array(items.length);
+  // Select recent history before live probes, keeping explicit supervision
+  // visible even during a truncated discovery or provider outage.
+  const items = recentSessionWindow([...byKey.values()], {
+    priority: item => retainedSession(recordsByKey.get(`${item.provider}:${item.session}`)),
+  }), projected = new Array(items.length);
   const codexTitles = items.some(item => item.provider === 'codex' && !sessionTitle(item.title)) ? await listCodexTitles() : new Map();
   assertActive();
   let nextItem = 0;
@@ -136,11 +143,7 @@ export async function discoverSessions({ root, openClient = openCodexAppServer,
   }));
   assertActive();
   projected.sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
-  // Keep existing bindings visible during a truncated discovery or provider
-  // outage, even when newer unbound conversations fill the candidate window.
-  const bound = projected.filter(item => item.autoContinue || item.binding.mode !== 'unmanaged');
-  const sessions = [...bound, ...projected.filter(item => !item.autoContinue && item.binding.mode === 'unmanaged').slice(0, Math.max(0, 200 - bound.length))];
-  return { sessions, providers: { codex: { discovery: codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
+  return { sessions: projected, providers: { codex: { discovery: codexError ? 'unavailable' : 'ready', reason: codexError }, claude: { discovery: claudeError ? 'unavailable' : 'local_index', reason: claudeError } }, refreshedAt: now };
 }
 
 // Explicit execution authority: legacy monitor/tracked records stay read-only.