@awak-app/simy-cli 0.5.79 → 0.5.81

package/README.md

@@ -181,6 +181,13 @@ app-server session and checks writer ownership before each continuation. Claude
 can continue through a verified live SIMY hook in its original process; sessions
 without that hook support monitoring only, and cold takeover remains unavailable. See [session supervision](docs/session-supervision.md).
 
+Provider discovery skips outdated or unversioned executables while looking for a
+compatible installation. Codex session supervision requires `0.158.0` or newer,
+independently of the lower general execution minimum. On macOS, discovery also
+checks the bundled CLI in ChatGPT and Codex apps in system and user Applications.
+Claude discovery likewise falls back to a compatible native or Desktop bundle
+when an older PATH installation cannot meet its version requirement.
+
 The plugin also provides an opt-in, hook-based Delivery Loop in the user's existing
 Codex or Claude Code conversation. Install the plugin, review and enable SIMY hooks
 with `/hooks`, then request `/simy:delivery-loop` for the task. Installing or updating

package/package.json

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

package/src/backend-executable.js

@@ -4,8 +4,7 @@ import { readdir } from "node:fs/promises";
 import { readdirSync, statSync } from "node:fs";
 import path from "node:path";
 
-const MACOS_CODEX_BINARY = "/Applications/ChatGPT.app/Contents/Resources/codex";
-const MACOS_CODEX_BUNDLED_BINARY = "/Applications/ChatGPT.app/Contents/Resources/codex-cli/bin/codex";
+export const CODEX_WRITER_LOCK_MINIMUM_VERSION = "0.158.0";
 
 export const BACKEND_VERSION_POLICIES = Object.freeze({
   codex: Object.freeze({
@@ -27,50 +26,45 @@ export async function resolveBackendExecutable(backend, options = {}) {
 
 export async function inspectBackendExecutable(
   backend,
-  { spawnImpl = spawn, candidates, timeoutMs = 5_000, signal, discoveryOptions = {} } = {},
+  { spawnImpl = spawn, candidates, timeoutMs = 5_000, signal, discoveryOptions = {}, minimumVersion } = {},
 ) {
   const assertActive = () => { if (signal?.aborted) throw Object.assign(new Error('Backend inspection was cancelled.'), { code: 'cancelled' }); };
   assertActive();
   const policy = versionPolicy(backend);
+  const requiredVersion = minimumVersion || policy.minimumVersion;
   candidates ??= [...backendCandidates(backend, discoveryOptions), ...await bundledClaudeCandidates(backend, discoveryOptions)];
+  let fallback = null;
   for (const candidate of [...new Set(candidates.filter(Boolean))]) {
     assertActive();
     const probe = await probeExecutable(candidate, { spawnImpl, timeoutMs, signal });
     assertActive();
     if (!probe.available) continue;
     const installedVersion = parseBackendVersion(probe.output);
-    if (!installedVersion) {
-      return {
-        backend,
-        executable: candidate,
-        available: true,
-        compatible: false,
-        status: "unknown_version",
-        installed_version: null,
-        minimum_version: policy.minimumVersion,
-        update_command: policy.updateCommand,
-      };
-    }
-    const compatible = compareVersions(installedVersion, policy.minimumVersion) >= 0;
-    return {
+    const compatible = Boolean(installedVersion) && compareVersions(installedVersion, requiredVersion) >= 0;
+    const inspection = {
       backend,
       executable: candidate,
       available: true,
       compatible,
-      status: compatible ? "compatible" : "outdated",
+      status: compatible ? "compatible" : installedVersion ? "outdated" : "unknown_version",
       installed_version: installedVersion,
-      minimum_version: policy.minimumVersion,
+      minimum_version: requiredVersion,
       update_command: policy.updateCommand,
     };
+    // An executable that starts may still be too old for the requested feature.
+    // Preserve candidate priority among compatible installs, and retain the
+    // first runnable failure for actionable diagnostics if none qualifies.
+    if (compatible) return inspection;
+    fallback ??= inspection;
   }
-  return {
+  return fallback || {
     backend,
     executable: null,
     available: false,
     compatible: false,
     status: "missing",
     installed_version: null,
-    minimum_version: policy.minimumVersion,
+    minimum_version: requiredVersion,
     update_command: policy.updateCommand,
   };
 }
@@ -94,7 +88,13 @@ export function backendCandidates(backend, {
   return [
     environment.SIMY_CODEX_BIN,
     "codex",
-    ...(platform === "darwin" ? [MACOS_CODEX_BUNDLED_BINARY, MACOS_CODEX_BINARY] : []),
+    ...(platform === "darwin" ? ["/Applications", path.posix.join(home, "Applications")].flatMap(directory =>
+      ["ChatGPT.app", "Codex.app"].flatMap(app => {
+        const resources = path.posix.join(directory, app, "Contents", "Resources");
+        return [path.posix.join(resources, "codex-cli", "bin", "codex"),
+          path.posix.join(resources, "codex-cli", "CodexCLI.app", "Contents", "MacOS", "codex"),
+          path.posix.join(resources, "codex")];
+      })) : []),
   ];
 }
 

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

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

@@ -1,7 +1,7 @@
 import { associationContract } from '../codex-plugins/simy/hooks/action-association.mjs';
 import { spawn } from 'node:child_process';
 import { realpath } from 'node:fs/promises';
-import { inspectBackendExecutable } from '../backend-executable.js';
+import { CODEX_WRITER_LOCK_MINIMUM_VERSION, compareVersions, inspectBackendExecutable } from '../backend-executable.js';
 import { assessedCheckpointContract, deliveryBudgetState, 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';
@@ -149,13 +149,13 @@ export class CodexAppServerClient {
 export function supportsCodexWriterLock(version) {
   const match = String(version || '').match(/^(\d+)\.(\d+)\.(\d+)/);
   if (!match) return false;
-  const parts = match.slice(1).map(Number);
-  return parts[0] > 0 || parts[1] > 158 || parts[1] === 158 && parts[2] >= 0;
+  return compareVersions(version, CODEX_WRITER_LOCK_MINIMUM_VERSION) >= 0;
 }
 
 export async function openCodexAppServer({ inspectExecutable = inspectBackendExecutable, spawnImpl = spawn, signal, maxLineBytes, omitInlineAttachments = false, cancelOnAbort = false } = {}) {
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');
-  const inspection = await inspectExecutable('codex', cancelOnAbort ? { signal } : undefined);
+  const inspection = await inspectExecutable('codex', { minimumVersion: CODEX_WRITER_LOCK_MINIMUM_VERSION,
+    ...(cancelOnAbort ? { signal } : {}) });
   if (!inspection?.available || !inspection.executable) throw new CodexAppServerError('unavailable', 'Codex executable is unavailable.');
   if (!supportsCodexWriterLock(inspection.installed_version)) throw new CodexAppServerError('unsupported', 'Codex version does not have a verified app-server writer lock.');
   if (signal?.aborted) throw new CodexAppServerError('cancelled', 'Codex app-server was cancelled.');