@awak-app/simy-cli 0.7.32 → 0.7.34

package/README.md

@@ -969,9 +969,20 @@ diagrams. This is a design proposal, not a shipped completion guarantee.
 Publishing is handled by GitHub Actions in `.github/workflows/publish.yml`.
 
 - Every push tag matching `v*.*.*` runs checks and publishes to npm.
-- Manual workflow runs perform the same checks; set `publish=true` to publish.
-- The repository must define an `NPM_TOKEN` secret with publish access to
-  `@awak-app/simy-cli`.
+- Manual workflow runs perform the same checks and verify the npm OIDC exchange.
+  Leave `publish=false` for a dry-run; set `publish=true` to publish.
+- npm trusted publishing must allow direct `npm publish` for GitHub organization
+  `SpecialistDoctors-Inc`, repository `simy-cli`, workflow filename `publish.yml`,
+  with no environment restriction (this job does not use a GitHub environment).
+  Publishing uses GitHub-hosted runners, Node 22 and npm 11.21.0.
+- The publisher verifies GitHub OIDC issuance and npm token exchange separately,
+  without logging or persisting credentials. It never falls back to `NPM_TOKEN`;
+  local npm login is not required for CI publishing.
+- A registry outage can also cause an OIDC exchange failure. Check npm service
+  status and the failing preflight stage before changing account settings.
+  Rerunning a tag uses that tag's workflow; it does not pick up later fixes.
+  Retry only the npm job for an already released native version, and check the
+  current npm `latest` first so an older release cannot replace a newer one.
 - The package check inspects the final npm tarball contents and fails if any
   source map file would be published.
 
@@ -1518,3 +1529,11 @@ that operation continues to block writes. Observing the result settles local
 occupancy without accepting the task. Long-running tasks transmit current
 recovery context and recent work; the full history remains in durable state
 and can be inspected through `delivery status`.
+
+### Reusable Auto Continue evaluation inputs
+
+For the 20 versioned conversation regression cases, immutable stopping-protocol
+plans, and pinned SWE-bench Pro public-task preparation, see
+[the evaluation guide](scripts/auto-continue-eval/README.md). Run
+`npm run eval:auto-continue -- help` from a source checkout. This tooling prepares
+inputs; it does not launch models or establish continuation effectiveness.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awak-app/simy-cli",
-  "version": "0.7.32",
+  "version": "0.7.34",
   "description": "Local SIMY executor for non-coding Local Tasks and Agentic Loop runs.",
   "type": "module",
   "bin": {
@@ -54,7 +54,8 @@
     "test:e2e:claude-plugin": "node ./scripts/claude-plugin-runtime-e2e.js",
     "test:e2e:codex-plugin": "node ./scripts/codex-plugin-runtime-e2e.js",
     "test:e2e:flexible-delivery": "node --test --test-name-pattern=\"flexible prototype\" test/purpose-search.test.js",
-    "test:e2e:sqm-faults": "node ./scripts/sqm-complete-loop-e2e.js"
+    "test:e2e:sqm-faults": "node ./scripts/sqm-complete-loop-e2e.js",
+    "eval:auto-continue": "node ./scripts/auto-continue-eval.js"
   },
   "engines": {
     "node": ">=20"

package/src/auto-update.js

@@ -16,6 +16,9 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
 import { daemonRestartCommand } from "./web-origin.js";
+import { updateConnectionEnvironment } from './update-connection.js';
+import { connectionScope, assertConnectionScope } from './connection-diagnostics.js';
+import { readSession } from './session-store.js';
 import { openExternalUrl } from "./browser.js";
 import {
   installMacosInstallerRelease,
@@ -1006,6 +1009,7 @@ export async function restartDaemonProcess({
   env = process.env,
 } = {}) {
   const handoffDirectory = path.join(stateRoot, "updates", "handoff");
+  const expectedScope = expectedWebOrigin ? connectionScope(await readSession(expectedWebOrigin, stateRoot), expectedWebOrigin) : null;
   await mkdir(handoffDirectory, { recursive: true, mode: 0o700 });
   const nonce = randomBytes(24).toString("hex");
   const handoffPath = path.join(handoffDirectory, `${process.pid}-${nonce}.json`);
@@ -1013,7 +1017,7 @@ export async function restartDaemonProcess({
     detached: true,
     stdio: "ignore",
     env: {
-      ...env,
+      ...(expectedWebOrigin ? updateConnectionEnvironment({ env, root: stateRoot, webOrigin: expectedWebOrigin }) : { ...env, SIMY_HOME: path.resolve(stateRoot) }),
       SIMY_DAEMON_CHILD: "1",
       SIMY_UPDATE_HANDOFF_FILE: handoffPath,
       SIMY_UPDATE_HANDOFF_NONCE: nonce,
@@ -1040,6 +1044,10 @@ export async function restartDaemonProcess({
     if (expectedInstallMode && handoff.install_mode !== expectedInstallMode) {
       throw new Error("Restarted SIMY reported a different installation channel.");
     }
+    if (expectedScope?.account_id || expectedScope?.organization_id || expectedScope?.device_id) {
+      assertConnectionScope(expectedScope, handoff.scope);
+      assertConnectionScope(expectedScope, connectionScope(await readSession(expectedWebOrigin, stateRoot), expectedWebOrigin));
+    }
     return handoff;
   } catch (error) {
     await terminateCandidate(child);
@@ -1073,6 +1081,7 @@ export async function writeUpdateHandoffFromEnvironment({
       port,
       pid: process.pid,
       web_origin: webOrigin,
+      scope: webOrigin ? connectionScope(await readSession(webOrigin, stateRoot), webOrigin) : null,
       install_mode: installMode,
       ready_at: new Date().toISOString(),
     })}\n`,

package/src/cli-contract.js

@@ -14,7 +14,7 @@ import {
 } from "./durable-local-task-steps-contract.js";
 import { buildExecutionCapabilityContract } from "./execution-capability-contract.js";
 
-export const CLI_VERSION = "0.7.32";
+export const CLI_VERSION = "0.7.34";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/cli-observability.js

@@ -7,7 +7,7 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { webApiHeaders, webApiUrl } from './web-api.js';
 // Keep this leaf module package-safe: hooks load it before the full CLI contract.
-const CLI_VERSION = '0.7.32';
+const CLI_VERSION = '0.7.34';
 
 const STORE = 'cli-observability-state.json';
 const LEGACY_CONFIG = 'cli-observability.json';

package/src/codex-plugins/simy/hooks/delivery-loop.mjs

@@ -340,7 +340,8 @@ export async function readRecord(root = rootDirectory(), provider, session) {
   } catch { return null; } // Match listRecords' treatment of unreadable records.
 }
 const RECORD_NAME = /^[a-f0-9]{64}\.json$/;
-const RECORD_CACHE_LIMIT = 500;
+const RECORD_CACHE_LIMIT = 10_000;
+const RECORD_CACHE_BYTES = 32 * 1024 * 1024;
 const READ_CONCURRENCY = 8;
 async function recordNames(root) {
   try { return (await readdir(root)).filter(name => RECORD_NAME.test(name)).sort(); }
@@ -367,13 +368,16 @@ export async function listRecords(root = rootDirectory()) {
 // A shared candidate/display index, never mutation authority. Every list checks
 // metadata so external hooks, removals and direct writes invalidate cached JSON.
 // Fresh execution reads and updateRecord locks remain independent of this index.
-export function createRecordReader(root = rootDirectory()) {
+export function createRecordReader(root = rootDirectory(), { cacheEntries = RECORD_CACHE_LIMIT, cacheBytes = RECORD_CACHE_BYTES } = {}) {
+  if (!Number.isSafeInteger(cacheEntries) || cacheEntries < 1 || cacheEntries > RECORD_CACHE_LIMIT ||
+      !Number.isSafeInteger(cacheBytes) || cacheBytes < 1 || cacheBytes > RECORD_CACHE_BYTES) throw new Error('Invalid record cache limits.');
   const cache = new Map();
-  let inFlight = null, closed = false;
+  let inFlight = null, closed = false, retainedBytes = 0;
+  const discard = name => { retainedBytes -= cache.get(name)?.bytes || 0; cache.delete(name); };
   const fingerprint = info => [info.dev, info.ino, info.size, info.mtimeNs, info.ctimeNs].join(':');
   const scan = async () => {
-    const names = await recordNames(root), live = new Set(names.slice(0, RECORD_CACHE_LIMIT));
-    for (const name of cache.keys()) if (!live.has(name)) cache.delete(name);
+    const names = await recordNames(root), live = new Set(names.slice(0, cacheEntries));
+    for (const name of cache.keys()) if (!live.has(name)) discard(name);
     return mapRecordNames(names, async name => {
       const path = join(root, name);
       try {
@@ -384,10 +388,14 @@ export function createRecordReader(root = rootDirectory()) {
         // Do not retain a value when a write races the read; the next list must
         // inspect it again. This also prevents malformed transient JSON sticking.
         const after = await stat(path, { bigint: true });
-        if (live.has(name) && fingerprint(after) === key) cache.set(name, { key, record });
-        else cache.delete(name);
+        discard(name);
+        const bytes = Number(after.size);
+        if (live.has(name) && bytes <= cacheBytes && fingerprint(after) === key) {
+          while (retainedBytes + bytes > cacheBytes && cache.size) discard(cache.keys().next().value);
+          cache.set(name, { key, record, bytes }); retainedBytes += bytes;
+        }
         return record;
-      } catch { cache.delete(name); return null; }
+      } catch { discard(name); return null; }
     });
   };
   return {
@@ -398,7 +406,7 @@ export function createRecordReader(root = rootDirectory()) {
       // cached records or a simultaneous caller's view.
       return currentProviderConsent(root, structuredClone(await inFlight));
     },
-    async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); },
+    async close() { closed = true; await inFlight?.catch(() => {}); cache.clear(); retainedBytes = 0; },
   };
 }
 function positive(value, fallback, max) {
@@ -1115,7 +1123,7 @@ export async function enablePurposeDelivery({ root = rootDirectory(), provider,
     if (managedBudgetReason(run, now)) throw new Error('Original budget exhausted; automatic continuation cannot reset it.');
     if (!run.managed) {
       const plan = purposeDiagnosisPlan({ approvalScopes: ['task'] }, 'Read the original conversation, reconstruct its purpose and completion conditions, then choose necessary work.');
-      run.managed = managedSpec({ acceptanceCriteria: [], contextBootstrap: true, autonomyPolicy: 'autonomous', approvalScopes: ['task'], approvalPolicy: 'wait',
+      run.managed = managedSpec({ acceptanceCriteria: [], contextBootstrap: true, autonomyPolicy: 'balanced', approvalScopes: ['task'], approvalPolicy: 'wait',
         initialPlan: plan, initialAction: plan.alternatives[0].action, autoRecovery: true, resumeChannel: 'codex_app_server', resumeModel: admission.model, purpose },
         session, provider, record.process, admission, now);
       run.managed.purpose.previousCheckpoint = run.checkpoint;
@@ -2089,7 +2097,9 @@ export function deliveryStopBlocksResume(run, now = Date.now()) {
 }
 // Stopped remains terminal for hooks, polling and automatic recovery. Only the
 // explicit control action may reopen an enrolled app-server task for diagnosis.
-export function canExplicitlyResumeStopped(run) {
+export function canExplicitlyResumeStopped(run, { standard = false } = {}) {
+  if (standard && run?.state === 'stopped' && !run.managed)
+    return canUpgradeDelivery({ ...run, state: 'active' }) && (run.failures || 0) < run.maxFailures;
   return run?.state === 'stopped' && run.managed?.resumeChannel === 'codex_app_server' &&
     Boolean(run.managed.autonomyPolicy && run.managed.approvalScopes?.length) &&
     !run.managed.resumeLease && !run.managed.liveWorkspaceLease;
@@ -2977,8 +2987,30 @@ export async function controlDelivery({ root = rootDirectory(), provider, sessio
       run.providerRequest = null;
       const marker = readState(stopMarkerPath(root, provider, session));
       if (marker?.runId === run.id) run.handledStopMarkerId = marker.id;
-      const wasStopped = canExplicitlyResumeStopped(run);
+      const wasStopped = canExplicitlyResumeStopped(run, { standard: provider === 'codex' });
       const wasVerifying = canResumePendingVerification(run);
+      if (wasStopped && !run.managed) {
+        const link = await providerLinkState(root, provider);
+        if (expectedRunId !== run.id || expectedRevision !== deliveryDecisionRevision(run) ||
+            !link.connected || resumeObservation?.providerEpoch !== link.epoch ||
+            resumeObservation?.session !== session || resumeObservation.cwd !== record.cwd ||
+            resumeObservation.source !== 'codex_app_server' || !text(resumeObservation.model, 200) ||
+            !resumeObservation.purpose?.ruleDigest || deliveryStopBlocksResume(run, now))
+          throw new Error('Explicit resume requires the exact stopped run and current original provider observation.');
+        record.admission = { source: 'codex_app_server', provider, session, cwd: record.cwd,
+          model: resumeObservation.model, validatedAt: now,
+          ...(resumeObservation.nativeSandbox && resumeObservation.nativeSandboxSource?.type === 'sdk_rollout_turn_context' &&
+              resumeObservation.nativeSandboxSource.session === session && resumeObservation.nativeSandboxSource.cwd === record.cwd
+            ? { nativeSandbox: structuredClone(resumeObservation.nativeSandbox), nativeSandboxSource: structuredClone(resumeObservation.nativeSandboxSource) } : {}) };
+        if (link.consentEpoch) record.providerConsentEpoch = link.consentEpoch;
+        const plan = purposeDiagnosisPlan({ approvalScopes: ['task'] },
+          'Read the original conversation and latest corrections, reconcile prior effects, and reconstruct remaining authorized work. Do not replay prior actions.');
+        run.managed = managedSpec({ acceptanceCriteria: [], contextBootstrap: true, autonomyPolicy: 'balanced',
+          approvalScopes: ['task'], approvalPolicy: 'wait', initialPlan: plan, initialAction: plan.alternatives[0].action,
+          autoRecovery: true, resumeChannel: 'codex_app_server', resumeModel: resumeObservation.model,
+          purpose: resumeObservation.purpose }, session, provider, record.process, record.admission, now);
+        run.managed.purpose.previousCheckpoint = run.checkpoint;
+      }
       if (run.managed?.dependencyWait) throw new Error('Confirm the exact external dependency condition before resuming.');
       if (run.managed?.phase === 'needs_clarification') throw new Error('Answer the current session question before resuming.');
       if (!['blocked', 'recovery_required', 'paused'].includes(run.state) && !wasStopped && !wasVerifying) throw new Error('Only a blocked, paused, recoverable, unowned pending-verification task, or stopped managed app-server loop can resume.');

package/src/codex-plugins/simy/hooks/purpose-workspace.mjs

@@ -5,8 +5,15 @@ import { resolve, relative, isAbsolute, join } from 'node:path';
 
 // Completion reviews bind to the actual local state. No resets, stashes, writes,
 // shell commands from a worker, or special verifier registration are needed.
-export async function workspaceIdentity(cwd, stateRoot, inventory, { signal, excludedPaths = [], inventoryLimit = 256 } = {}) {
+export async function workspaceIdentity(cwd, stateRoot, inventory, { signal, excludedPaths = [], inventoryLimit = 256,
+  maxEntries = Infinity, maxBytes = Infinity, deadline = Infinity } = {}) {
   signal?.throwIfAborted();
+  let entries = 0, bytes = 0;
+  const checkBudget = () => {
+    signal?.throwIfAborted();
+    if (entries > maxEntries || bytes > maxBytes || Date.now() >= deadline)
+      throw new Error('Optional workspace inventory exceeded its preparation budget; relevant files remain available for direct inspection.');
+  };
   const hash = createHash('sha256');
   const paths = [];
   const capture = entry => {
@@ -20,12 +27,13 @@ export async function workspaceIdentity(cwd, stateRoot, inventory, { signal, exc
     const info = await lstat(path); versions.set(path, info); return info;
   };
   const walk = async (directory, depth = 0) => {
-    signal?.throwIfAborted();
+    checkBudget();
     if (depth > 30) throw new Error('Workspace review inventory exceeds its bound.');
     await remember(directory);
     for await (const entry of await opendir(directory)) {
       signal?.throwIfAborted();
       if (['.git', 'node_modules', '.npm-cache'].includes(entry.name)) continue;
+      entries++; checkBudget();
       const path = join(directory, entry.name);
       if (stateRoot && resolve(path) === resolve(stateRoot)) continue;
       if (entry.isDirectory()) await walk(path, depth + 1);
@@ -36,7 +44,7 @@ export async function workspaceIdentity(cwd, stateRoot, inventory, { signal, exc
 
   const buffer = Buffer.allocUnsafe(1024 * 1024);
   for (const path of paths) {
-    signal?.throwIfAborted();
+    checkBudget();
     const full = resolve(cwd, path), rel = relative(cwd, full);
     if (rel.startsWith('..') || isAbsolute(rel)) throw new Error('Invalid workspace review path.');
     if (stateRoot && (full === resolve(stateRoot) || full.startsWith(resolve(stateRoot) + '/'))) continue;
@@ -57,6 +65,7 @@ export async function workspaceIdentity(cwd, stateRoot, inventory, { signal, exc
       continue;
     }
     if (!info.isFile()) { const identity=`nonregular:${info.mode}:${info.mtimeMs}`;hash.update(identity);capture({path,mode:info.mode,type:'nonregular',digest:createHash('sha256').update(identity).digest('hex')});continue; }
+    bytes += info.size; checkBudget();
     const actual = await realpath(full), actualRel = relative(cwd, actual);
     if (actualRel.startsWith('..') || isAbsolute(actualRel)) throw new Error('Workspace changed to an external link during review.');
     // Stream large artifacts with fixed memory. Verify the opened descriptor
@@ -69,7 +78,7 @@ export async function workspaceIdentity(cwd, stateRoot, inventory, { signal, exc
       hash.update(String(info.mode));
       let position = 0;
       while (position < before.size) {
-        signal?.throwIfAborted();
+        checkBudget();
         const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, before.size - position), position);
         if (!bytesRead) throw new Error('Workspace artifact was truncated during hashing.');
         const chunk = buffer.subarray(0, bytesRead);

package/src/delivery-hooks/desktop.js

@@ -106,7 +106,7 @@ export async function deliveryHookStatus({ root = rootDirectory(), now = Date.no
       canPause: Boolean(r.run.managed) && (['active', 'auto_resuming'].includes(r.run.state) ||
         r.run.state === 'recovery_required' && ['session_supervision', 'approved_action'].includes(r.run.recoveryCause) &&
         r.run.managed.resumeChannel === 'codex_app_server' && r.run.managed.autoRecovery),
-      canResume: (['blocked', 'recovery_required', 'paused'].includes(r.run.state) || canExplicitlyResumeStopped(r.run) || canResumePendingVerification(r.run)) && r.run.managed?.phase !== 'needs_clarification' &&
+      canResume: (['blocked', 'recovery_required', 'paused'].includes(r.run.state) || canExplicitlyResumeStopped(r.run, { standard: r.provider === 'codex' }) || canResumePendingVerification(r.run)) && r.run.managed?.phase !== 'needs_clarification' &&
         !r.run.managed?.pendingApproval && !r.run.managed?.controllerDecisionWait && !r.run.managed?.dependencyWait && !['pending', 'pending_received', 'transferred'].includes(r.run.managed?.handoff?.status) &&
         !deliveryStopBlocksResume(r.run, now),
       canApprove: r.run.state === 'blocked' && Boolean(r.run.managed?.pendingApproval) && !r.run.managed.pendingApproval.denied,

package/src/desktop-access.js

@@ -9,7 +9,7 @@ export function validDesktopAccessPath(path, slug) {
 export const desktopAccessReady = value => value?.state === 'ready';
 const recoveryActions = new Set(['refresh', 'reconnect', 'login', 'authorization_open', 'authorization_copy', 'organization_select', 'organization_cancel', 'organizations_refresh',
   'check_update', 'auto_update_set_enabled', 'update', 'prepare_update_restart', 'quit', 'task_stop', 'delivery_stop', 'delivery_pause', 'delivery_reject',
-  'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members']);
+  'provider_disconnect', 'desktop_access_refresh', 'desktop_access_settings', 'desktop_access_members', 'desktop_sqm_settings']);
 export function desktopActionAllowed(access, command) {
   return desktopAccessReady(access) || recoveryActions.has(command?.action) ||
     command?.action === 'session_set_auto_continue' && command.enabled === false ||

package/src/desktop-frame-writer.js

@@ -0,0 +1,29 @@
+// Status snapshots are replaceable; command receipts and stop notifications are
+// not. Never enqueue periodic snapshots behind a native reader that has paused.
+// Control frames retain the stream's FIFO order and never wait for GUI drain.
+export function createDesktopFrameWriter(output) {
+  let blocked = false, pendingStatus = null, statusClosed = false;
+  const drain = () => {
+    blocked = false;
+    const frame = pendingStatus;
+    pendingStatus = null;
+    if (!statusClosed && frame !== null) write(frame, true);
+  };
+  const write = (frame, isStatus = false) => {
+    if (isStatus && statusClosed) return;
+    if (isStatus && blocked) { pendingStatus = frame; return; }
+    // A control frame must not be followed by a snapshot captured before it.
+    // The next authorized projection will publish fresh state.
+    if (!isStatus) pendingStatus = null;
+    const accepted = output.write(frame);
+    if (accepted === false && !blocked && !statusClosed) {
+      blocked = true;
+      output.once('drain', drain);
+    }
+  };
+  return { write, close() {
+    statusClosed = true;
+    pendingStatus = null;
+    output.removeListener('drain', drain);
+  } };
+}