@awak-app/simy-cli 0.6.5 → 0.6.7

package/README.md

@@ -218,8 +218,13 @@ Codex or Claude Code conversation. Install the plugin, review and enable SIMY ho
 with `/hooks`, then request `/simy:delivery-loop` for the task. Installing or updating
 the plugin never approves hook trust. SIMY's Connection & settings panel links to
 Codex settings and the Claude setup guide and shows observed hook activity and
-blocked/recovery states. The legacy `agentic-delivery-loop` skill remains retired;
-the Web/CLI executor is unchanged. See [hook delivery behavior and limits](docs/delivery-hooks.md).
+blocked/recovery states.
+The Connection tab also checks each provider's actual SIMY plugin inventory and
+shows installed/enabled, installed/disabled, missing, or unavailable separately
+from app sign-in. Claude enablement is checked from the home folder; project
+settings can differ, and project-scoped installations are labeled explicitly.
+The legacy `agentic-delivery-loop` skill remains retired; the Web/CLI executor is
+unchanged. See [hook delivery behavior and limits](docs/delivery-hooks.md).
 `--no-auto-update` or `SIMY_AUTO_UPDATE=0` disables these background updates too;
 `--no-workflow-prompt` only suppresses the initial installation prompt.
 

package/package.json

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

package/src/desktop-host.js

@@ -1,5 +1,6 @@
 import { readCodexStatistics, unavailableStatistics } from './session-supervision/statistics.js';
 import { readClaudeStatistics } from './session-supervision/claude-sessions.js';
+import { inspectProviderPlugins, unavailablePluginStatus } from './sqm/provider-plugin-status.js';
 import { openCodexAppServer } from './session-supervision/codex-app-server.js';
 import { conversationSqmChecks } from './session-supervision/sqm-presentation.js';
 import { stopOwnedDesktopHost } from "./desktop-force-quit.js";
@@ -196,12 +197,27 @@ export async function startDesktopHost({ input = process.stdin, output = process
     onChange: () => { if (!closed && !relay) refreshSessions(true); },
   });
   let pluginSetup = { state: "unknown" };
+  let providerPlugins = { codex: { state: 'checking' }, claude: { state: 'checking' } };
+  let pluginInspection = null, lastPluginInspectionAt = -Infinity;
+  let pluginInspectionAbort = new AbortController();
+  const refreshProviderPlugins = () => {
+    if (closed || relay) return Promise.resolve();
+    if (pluginInspection) return pluginInspection;
+    if (pluginInspectionAbort.signal.aborted) pluginInspectionAbort = new AbortController();
+    lastPluginInspectionAt = Date.now();
+    pluginInspection = Promise.resolve().then(() => (dependencies.inspectProviderPlugins || inspectProviderPlugins)({ signal: pluginInspectionAbort.signal }))
+      .then(value => { providerPlugins = value; })
+      .catch(() => { providerPlugins = { codex: unavailablePluginStatus(), claude: unavailablePluginStatus() }; })
+      .finally(() => { pluginInspection = null; if (!closed && !relay) void publish().catch(() => {}); });
+    return pluginInspection;
+  };
   const inspectPlugins = dependencies.inspectPlugins || inspectSqmAgentSkill;
   const refreshPlugins = async () => {
     try {
       const status = await inspectPlugins();
       pluginSetup = { state: status.installed ? "ready" : "missing", refreshPending: status.installed && pluginSetup.refreshPending === true };
     } catch { pluginSetup = { state: "error" }; }
+    void refreshProviderPlugins();
   };
   const packageInfo = dependencies.packageInfo || await readCliPackageInfo();
   diagnostics.write(`desktop starting version=${packageInfo.version} pid=${process.pid} role=${candidate ? "update-candidate" : "supervisor"}`);
@@ -224,6 +240,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     }
     return scheduledPublish.promise;
   };
+  let lastDeadlineFailureAt = -Infinity;
   const projectStatus = () => {
     if (closed || relay || !agent) return Promise.resolve();
     if (publishing) { publishAgain = true; return publishing; }
@@ -233,6 +250,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       status.access = currentAccess;
       const requestedScope = accessScope(currentAccess);
       status.pluginSetup = { ...pluginSetup };
+      status.providerPlugins = structuredClone(providerPlugins);
       if (!desktopAccessReady(currentAccess)) {
         for (const item of sessionStatus.sessions) automaticContinuation?.revoke(item.provider, item.session);
         if (currentAccess.state !== 'checking') await analysisManager.update([]);
@@ -258,9 +276,18 @@ export async function startDesktopHost({ input = process.stdin, output = process
       for (const session of sessions) {
         session.statistics = statisticsCache.get(`${session.provider}:${session.session}`) || unavailableStatistics();
         session.sqmActivity = conversationSqmChecks(session, [...(status.sqmChecks?.items || []), ...(status.sqmTasks?.items || [])]);
-        const context = await actionAssociations.deadlineContext?.(session, projection);
-        if (context) session.actionDeadline = await deadlines.reconcile(context, { displayOnly: true });
-        else session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
+        session.actionDeadline = { status: 'unavailable', online: false, reminder: null };
+        try {
+          const context = await actionAssociations.deadlineContext?.(session, projection);
+          if (context) session.actionDeadline = await deadlines.reconcile(context, { displayOnly: true });
+        } catch {
+          // Optional per-conversation metadata must not stop catalog/connection
+          // heartbeats. Keep the fallback and bound diagnostics across refreshes.
+          if (Date.now() - lastDeadlineFailureAt >= 30_000) {
+            lastDeadlineFailureAt = Date.now();
+            diagnostics.write('conversation deadline unavailable; desktop status retained');
+          }
+        }
         const run = runsBySession.get(`${session.provider}:${session.session}`);
         if (run) run.actionDeadline = session.actionDeadline;
       }
@@ -274,12 +301,14 @@ export async function startDesktopHost({ input = process.stdin, output = process
   };
   const stopAgent = async () => {
     clearInterval(timer);
+    pluginInspectionAbort.abort();
     discoveryStopped = true;
     encodedStatus = null; lastStatus = null;
     if (scheduledPublish) { clearTimeout(scheduledPublish.timer); scheduledPublish.resolve(); scheduledPublish = null; }
     // Start every cancellation before draining discovery/network work. A hung
     // reader must never postpone cancellation of an owned Provider process.
     const results = await Promise.allSettled([stopDiscovery({ drain: true }), publishing,
+      pluginInspection,
       actionAssociations.close(), automaticContinuation?.close(), analysisManager?.close(),
       managedSupervisor.close(), recordReader.close(), stopWorkflows(),
       agent ? createAgentShutdown(agent)() : undefined]);
@@ -406,6 +435,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
     tick(actionAssociations);
     tick(managedSupervisor);
     timer = setInterval(() => {
+      if (Date.now() - lastPluginInspectionAt >= 30_000) void refreshProviderPlugins();
       if (desktopAccessReady(currentAccess)) {
         tick(actionAssociations);
         tick(managedSupervisor);

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

@@ -75,6 +75,11 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       const local = latest?.run?.managed?.actionAssociation;
       if (latest?.run?.managed?.taskId !== record.run.managed.taskId) return latest;
       latest.run.managed.actionAssociation = { ...local, authRevision: expected };
+      // Successful empty responses restore availability without erasing matches
+      // or pending work that still belongs to this authenticated scope.
+      if (local?.status === 'unavailable' && !local.binding && !local.job && !local.outbox) {
+        latest.run.managed.actionAssociation.status = 'waiting_boundary';
+      }
       if (!local?.job) delete latest.run.managed.actionAssociation.invalidated;
       return latest;
     });
@@ -218,6 +223,11 @@ export function createActionAssociationHost({ root, sessionRoot, webOrigin, api
       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;
+      // Correction can be available before the first scoped binding exists.
+      // Such a conversation cannot yet address a durable deadline record.
+      if (typeof local.namespace !== 'string' || !local.namespace.trim() ||
+        typeof candidate.taskId !== 'string' || !candidate.taskId.trim() ||
+        (record.run?.managed?.taskId || record.associationTaskId) !== candidate.taskId) return null;
       const binding = candidate.actionAssociation.binding;
       const fingerprint = value => JSON.stringify([value?.revision, value?.action?.id, value?.action?.revision, value?.action?.dueAt, value?.action?.timeZone, value?.action?.status]);
       return { namespace: local.namespace, provider: candidate.provider, session: candidate.session, taskId: candidate.taskId, binding,

package/src/sqm/provider-command.js

@@ -2,9 +2,9 @@ import spawn from "cross-spawn";
 
 // cross-spawn resolves npm .cmd shims on Windows without interpolating command
 // text. Keep updater commands bounded and preserve execFile-like test injection.
-export function runProviderCommand(command, args, { env, timeout = 10_000, maxBuffer = 1024 * 1024 } = {}) {
+export function runProviderCommand(command, args, { env, cwd, timeout = 10_000, maxBuffer = 1024 * 1024, signal } = {}) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { env, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn(command, args, { env, cwd, signal, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     let settled = false;

package/src/sqm/provider-plugin-status.js

@@ -0,0 +1,52 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveBackendExecutable } from '../backend-executable.js';
+import { runProviderCommand } from './provider-command.js';
+import { CLAUDE_PLUGIN_SELECTOR } from './claude-plugin.js';
+
+export const unavailablePluginStatus = () => ({ state: 'unknown', installed: null, enabled: null });
+
+// Provider inventories describe the actual installation and enablement. Managed
+// source files and previously observed hooks cannot establish either state.
+// Inspect from home so a launch directory cannot silently change Claude's merged
+// enablement; expose that context because individual project overrides can differ.
+export async function inspectProviderPlugins({ home = homedir(),
+  codexHome = process.env.CODEX_HOME || join(home, '.codex'),
+  claudeHome = process.env.CLAUDE_CONFIG_DIR || join(home, '.claude'),
+  resolveExecutable = resolveBackendExecutable, run = runProviderCommand,
+  timeoutMs = 5_000, signal,
+} = {}) {
+  const inspect = async provider => {
+    try {
+      if (signal?.aborted) return unavailablePluginStatus();
+      const executable = await resolveExecutable(provider, { signal, timeoutMs });
+      if (!executable || signal?.aborted) return unavailablePluginStatus();
+      const { stdout } = await run(executable, ['plugin', 'list', '--json'], {
+        timeout: timeoutMs, maxBuffer: 1024 * 1024, signal, cwd: home,
+        env: { ...process.env, HOME: home,
+          ...(provider === 'codex' ? { CODEX_HOME: codexHome } : { CLAUDE_CONFIG_DIR: claudeHome }) },
+      });
+      const payload = JSON.parse(stdout);
+      const entries = provider === 'codex' ? payload?.installed : payload;
+      if (!Array.isArray(entries)) return unavailablePluginStatus();
+      const matches = entries.filter(entry => provider === 'codex'
+        ? typeof entry?.pluginId === 'string' && /^simy@[A-Za-z0-9_-]+$/.test(entry.pluginId)
+        : entry?.id === CLAUDE_PLUGIN_SELECTOR);
+      // Prefer the account installation; report a project-only install explicitly
+      // rather than silently treating it as an installation for every project.
+      const scopes = ['user', 'managed', 'project', 'local'];
+      if (provider === 'claude') matches.sort((a, b) => {
+        const rank = value => scopes.includes(value) ? scopes.indexOf(value) : scopes.length;
+        return rank(a.scope) - rank(b.scope);
+      });
+      const entry = matches[0];
+      if (!entry || provider === 'codex' && entry.installed === false) return { state: 'missing', installed: false, enabled: false };
+      if (typeof entry.enabled !== 'boolean' || provider === 'codex' && entry.installed !== true ||
+        provider === 'claude' && !scopes.includes(entry.scope)) return unavailablePluginStatus();
+      return { state: entry.enabled ? 'enabled' : 'disabled', installed: true, enabled: entry.enabled,
+        ...(provider === 'claude' ? { scope: entry.scope, enablementContext: 'home' } : {}) };
+    } catch { return unavailablePluginStatus(); }
+  };
+  const [codex, claude] = await Promise.all([inspect('codex'), inspect('claude')]);
+  return { codex, claude };
+}