@awak-app/simy-cli 0.5.24 → 0.5.25

package/package.json

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

package/src/agent.js

@@ -141,6 +141,8 @@ export async function startAgent({
   webOrigin = null,
   sessionRoot,
   updateManager = null,
+  deferStartupSynchronization = false,
+  onDesktopStatusChange = null,
   dependencies = {},
   quiet = false,
 } = {}) {
@@ -188,7 +190,10 @@ export async function startAgent({
       : [],
   );
   const installMode = updateManager?.snapshot?.()?.install_mode ?? null;
-  let contractSourceCapabilities = daemonCapabilities(await readCapabilities(dependencies), daemon);
+  let contractSourceCapabilities = daemonCapabilities(
+    deferStartupSynchronization ? unverifiedCapabilities() : await readCapabilities(dependencies),
+    daemon,
+  );
   let availableCapabilities;
   let providerStatuses = { codex: { state: "unknown" }, claude: { state: "unknown" } };
   const refreshAvailableCapabilities = () => {
@@ -212,6 +217,11 @@ export async function startAgent({
   let port = requestedPort;
   let heartbeatTimer = null;
   let heartbeatInFlight = null;
+  let shuttingDown = false;
+  const notifyDesktopStatusChange = () => {
+    if (shuttingDown) return;
+    try { onDesktopStatusChange?.(); } catch { /* Desktop status polling remains available. */ }
+  };
   let durableLocalTaskWorker = null;
   let sqmLocalReviewWorker = null;
   let loginUrl = null;
@@ -226,19 +236,31 @@ export async function startAgent({
     now: dependencies.statusNowMs,
   });
 
-  const readProviderStatuses = async ({ force = false } = {}) => {
-    const [codex, claude] = await Promise.all([codexStatus({ force }), claudeStatus({ force })]);
-    const binaryStateChanged = ["codex", "claude"].some((provider) => {
-      const next = provider === "codex" ? codex : claude;
-      return providerStatuses[provider]?.version !== next.version ||
-        providerStatuses[provider]?.state !== next.state;
-    });
-    if (force || binaryStateChanged) {
-      contractSourceCapabilities = daemonCapabilities(await readCapabilities(dependencies), daemon);
-    }
-    providerStatuses = { codex, claude };
-    refreshAvailableCapabilities();
-    return providerStatuses;
+  let providerReadInFlight = null;
+  const readProviderStatuses = ({ force = false } = {}) => {
+    if (providerReadInFlight) return providerReadInFlight;
+    providerReadInFlight = (async () => {
+      const previous = providerStatuses;
+      await Promise.all(["codex", "claude"].map(async (provider) => {
+        const next = await (provider === "codex" ? codexStatus : claudeStatus)({ force });
+        // Publish each verified result independently. A slow Claude probe must
+        // not keep a completed Codex result hidden (or vice versa).
+        providerStatuses = { ...providerStatuses, [provider]: next };
+        refreshAvailableCapabilities();
+        if (previous[provider]?.version !== next.version || previous[provider]?.state !== next.state) {
+          notifyDesktopStatusChange();
+        }
+      }));
+      const binaryStateChanged = ["codex", "claude"].some((provider) =>
+        previous[provider]?.version !== providerStatuses[provider]?.version ||
+        previous[provider]?.state !== providerStatuses[provider]?.state);
+      if (!shuttingDown && (force || binaryStateChanged)) {
+        contractSourceCapabilities = daemonCapabilities(await readCapabilities(dependencies), daemon);
+        refreshAvailableCapabilities();
+      }
+      return providerStatuses;
+    })().finally(() => { providerReadInFlight = null; });
+    return providerReadInFlight;
   };
 
   const inspectReadyBackend = async (backend, options) => {
@@ -275,7 +297,7 @@ export async function startAgent({
   };
 
   const restoreRemoteRuns = async () => {
-    if (!isSessionValid(session, Date.now(), apiOrigin) || !session?.device_id) return;
+    if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin) || !session?.device_id) return;
     const snapshots = dependencies.listRemoteRuns
       ? await dependencies.listRemoteRuns({
           apiOrigin,
@@ -287,7 +309,9 @@ export async function startAgent({
           apiBaseUrl: session.api_base_url,
           token: session.token,
         });
+    let restored = false;
     for (const snapshot of snapshots) {
+      if (shuttingDown) return;
       if (!snapshot?.id || registry.has(snapshot.id)) continue;
       const repository = findRepository(repositoryInventory, snapshot.charter?.repository);
       const restoredRun = restoreRun({
@@ -297,14 +321,17 @@ export async function startAgent({
         localPath: repository?.local_path || null,
       });
       registry.create(restoredRun);
+      restored = true;
       await publishRestoredLocalCodingRun(restoredRun);
     }
+    if (restored) notifyDesktopStatusChange();
   };
 
   const heartbeat = () => {
-    if (!isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve(false);
+    if (shuttingDown || !isSessionValid(session, Date.now(), apiOrigin)) return Promise.resolve(false);
     if (heartbeatInFlight) return heartbeatInFlight;
     connectionStatus.attempt();
+    notifyDesktopStatusChange();
     let deviceHeartbeatSucceeded = false;
     const advertisedProviders = JSON.stringify(providerStatuses);
     heartbeatInFlight = Promise.resolve()
@@ -319,24 +346,36 @@ export async function startAgent({
         }),
       )
       .then(async () => {
+        if (shuttingDown) return false;
         deviceHeartbeatSucceeded = true;
         connectionStatus.success();
+        notifyDesktopStatusChange();
         // Register the device immediately; provider subprocesses must not delay
         // browser authorization. Publish verified readiness after their probe.
-        await readProviderStatuses();
-        if (JSON.stringify(providerStatuses) !== advertisedProviders) {
-          await heartbeatDevice({ apiOrigin, apiBaseUrl: session.api_base_url, token: session.token,
-            port, capabilities: refreshAvailableCapabilities(), repoInventory: repositoryInventory });
+        const publishVerifiedProviders = async () => {
+          await readProviderStatuses();
+          if (!shuttingDown && JSON.stringify(providerStatuses) !== advertisedProviders) {
+            await heartbeatDevice({ apiOrigin, apiBaseUrl: session.api_base_url, token: session.token,
+              port, capabilities: refreshAvailableCapabilities(), repoInventory: repositoryInventory });
+          }
+        };
+        if (deferStartupSynchronization) {
+          void publishVerifiedProviders().catch((error) => reportHeartbeatError(error, quiet));
+        } else {
+          await publishVerifiedProviders();
         }
+        if (shuttingDown) return false;
         const sqmResult = sqmLocalReviewWorker
           ? await sqmLocalReviewWorker.poll()
           : null;
+        if (shuttingDown) return false;
         if (!sqmResult && durableLocalTaskWorker) await durableLocalTaskWorker.poll();
         return true;
       })
       .catch((error) => {
         if (!deviceHeartbeatSucceeded) {
           const state = connectionStatus.failure(error);
+          notifyDesktopStatusChange();
           if (state === "unauthorized") {
             session = null;
             loginUrl = null;
@@ -1634,20 +1673,34 @@ export async function startAgent({
     }
   }
 
-  if (isSessionValid(session, Date.now(), apiOrigin)) {
+  const synchronizeStartup = async () => {
     try {
       await refreshAuthorizedRepositoryInventory();
+      if (shuttingDown) return;
       await heartbeat();
+      if (shuttingDown) return;
       await restoreRemoteRuns();
     } catch (error) {
       reportStartupConnectionError(error, quiet);
     }
+  };
+  if (deferStartupSynchronization) {
+    // The desktop can show restored tasks and account state while network and
+    // provider checks run. Unknown remains unknown until each probe succeeds.
+    void readProviderStatuses().catch((error) => reportStartupConnectionError(error, quiet));
+    if (isSessionValid(session, Date.now(), apiOrigin)) {
+      startHeartbeatTimer();
+      void synchronizeStartup();
+    }
+  } else if (isSessionValid(session, Date.now(), apiOrigin)) {
+    await synchronizeStartup();
     startHeartbeatTimer();
   }
 
   let shutdownPromise = null;
   const shutdown = () => {
     if (shutdownPromise) return shutdownPromise;
+    shuttingDown = true;
     shutdownPromise = (async () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
       updateManager?.stop?.();
@@ -1670,7 +1723,14 @@ export async function startAgent({
   });
   const getDesktopStatus = async () => {
     const auth = desktopAuthStatus(session, { webOrigin: apiOrigin });
-    const { codex, claude } = await readProviderStatuses();
+    if (deferStartupSynchronization && !shuttingDown) {
+      // Cached checks return immediately; expired checks refresh in the
+      // background without making the desktop frame wait for subprocesses.
+      void readProviderStatuses().catch((error) => reportStartupConnectionError(error, quiet));
+    }
+    const { codex, claude } = deferStartupSynchronization
+      ? providerStatuses
+      : await readProviderStatuses();
     return {
       schemaVersion: 1,
       sampledAt: new Date().toISOString(),
@@ -1995,6 +2055,26 @@ async function capabilities() {
     inspectDesktopExecutor("codex"),
     inspectDesktopExecutor("claude"),
   ]);
+  return capabilitiesFromInspections(codex, claude);
+}
+
+function unverifiedCapabilities() {
+  const unknown = (backend) => ({
+    backend,
+    execution_target: DESKTOP_EXECUTION_TARGET,
+    execution_label: DESKTOP_EXECUTION_LABEL,
+    provider_label: BACKEND_VERSION_POLICIES[backend].label,
+    status: "checking",
+    available: false,
+    compatible: false,
+    installed_version: null,
+    minimum_version: BACKEND_VERSION_POLICIES[backend].minimumVersion,
+    update_command: BACKEND_VERSION_POLICIES[backend].updateCommand,
+  });
+  return capabilitiesFromInspections(unknown("codex"), unknown("claude"));
+}
+
+function capabilitiesFromInspections(codex, claude) {
   return {
     backends: { codex: codex.compatible, claude: claude.compatible },
     backend_versions: {

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

package/src/desktop-host.js

@@ -78,6 +78,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
     });
     agent = await (dependencies.startAgent || startAgent)({
       daemon: true, webOrigin, sessionRoot: root, quiet: true, updateManager: updater,
+      deferStartupSynchronization: true,
+      onDesktopStatusChange: () => {
+        // Let an in-progress frame finish before publishing its new snapshot.
+        setImmediate(() => { void publish().catch(() => {}); });
+      },
     });
     stopWorkflows = (dependencies.startWorkflowUpdates || startWorkflowUpdates)({ enabled: env.SIMY_AUTO_UPDATE !== "0" });
     updater.on?.("change", () => { void publish().catch(() => {}); });

package/src/desktop-status.js

@@ -93,14 +93,18 @@ export function desktopTaskDetail(registries, key) {
   if (!task) return null;
   const attempt = task.snapshot?.attempts?.at(-1);
   const request = task.request?.requirement || task.display_instruction || task.instruction || task.snapshot?.charter?.requirement;
+  const purpose = purposePresentation(request);
   const result = typeof task.result === "string" ? task.result : task.result?.summary || attempt?.summary;
+  const report = reportPresentation(task.result) || reportPresentation(attempt?.raw_output?.agent_report, true) || reportPresentation(result);
   const links = [];
   const pr = safeDesktopLink(attempt?.pr_url);
   if (pr) links.push({ label: "Pull request", url: pr });
   return {
     key,
-    instruction: desktopContent(request),
-    result: desktopContent(result),
+    instruction: desktopContent(purpose?.purpose || request),
+    ...(purpose ? { purpose, technicalInstruction: desktopContent(request) } : {}),
+    result: desktopContent(report?.summary || result),
+    ...(report ? { report, ...(typeof result === "string" && result.trimStart().startsWith("{") ? { technicalResult: desktopContent(result) } : {}) } : {}),
     error: desktopContent(task.error, 1000),
     truncated: [request, result].some((value) => typeof value === "string" && value.length > 16000),
     links,
@@ -224,26 +228,82 @@ function taskStatusItem(task, registryIndex) {
     ),
     48,
   );
+  const request = task?.request?.requirement || task?.display_instruction || task?.instruction ||
+    task?.snapshot?.charter?.requirement;
+  const label = purposePresentation(request)?.purpose || request || task?.id || "Task";
   return {
     key: `${registryIndex}:${bounded(task?.id || "", 240)}`,
     id: bounded(String(task?.id || `unknown-${registryIndex}`), MAX_LABEL_LENGTH),
-    label: bounded(
-      String(
-        task?.request?.requirement ||
-          task?.display_instruction ||
-          task?.instruction ||
-          task?.snapshot?.charter?.requirement ||
-          task?.id ||
-          "Task",
-      ),
-      MAX_LABEL_LENGTH,
-    ),
+    label: bounded(String(label), MAX_LABEL_LENGTH),
     state,
     updatedAt:
       Date.parse(task?.updated_at || task?.snapshot?.updated_at || task?.startedAt || 0) || 0,
   };
 }
 
+// The Purpose-driven executor embeds a user-facing charter inside a generated
+// instruction. Project only known charter fields; keep the envelope available
+// on selection so no original context is lost or reinterpreted as progress.
+function purposePresentation(request) {
+  if (typeof request !== "string" || request.length > 262_144 ||
+      !(request.includes("Purpose Charter and constraints (authoritative context):") ||
+        request.includes("Purpose Charter, hypotheses, verification order, and completion criteria (authoritative context):")) ||
+      !request.includes("You are the executor, not the conductor.")) return null;
+  const marker = "\nPurpose Charter:\n";
+  const start = request.indexOf(marker);
+  if (start < 0) return null;
+  const jsonStart = request.indexOf("{", start + marker.length);
+  if (jsonStart < 0) return null;
+  let depth = 0, quoted = false, escaped = false, end = -1;
+  for (let i = jsonStart; i < request.length; i += 1) {
+    const char = request[i];
+    if (escaped) { escaped = false; continue; }
+    if (quoted && char === "\\") { escaped = true; continue; }
+    if (char === '"') { quoted = !quoted; continue; }
+    if (quoted) continue;
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) { end = i + 1; break; }
+    }
+  }
+  if (end < 0) return null;
+  try {
+    const charter = JSON.parse(request.slice(jsonStart, end));
+    const clean = (value, max = 2000) => typeof value === "string" ? desktopContent(value, max).trim() : "";
+    const purpose = clean(charter.original_request || charter.requirement || charter.purpose);
+    if (!purpose) return null;
+    return {
+      purpose,
+      persona: clean(charter.persona),
+      expectedValue: clean(charter.expected_value),
+      successCriteria: Array.isArray(charter.success_criteria)
+        ? charter.success_criteria.filter((value) => typeof value === "string").slice(0, 20).map((value) => clean(value, 1000)).filter(Boolean)
+        : [],
+    };
+  } catch { return null; }
+}
+
+function reportPresentation(result, allowSchemaLess = false) {
+  if (typeof result !== "string" && (typeof result !== "object" || result === null)) return null;
+  try {
+    const value = typeof result === "string"
+      ? result.length <= 65_536 && result.trimStart().startsWith("{") ? JSON.parse(result) : null
+      : result;
+    if ((value?.schema_version !== "agent_report.v1" && !(allowSchemaLess && !value?.schema_version)) || typeof value.summary !== "string") return null;
+    const list = (field) => Array.isArray(value[field])
+      ? value[field].filter((item) => typeof item === "string").slice(0, 20).map((item) => desktopContent(item, 1000))
+      : [];
+    return {
+      summary: desktopContent(value.summary),
+      testsRun: list("tests_run"),
+      evidenceRefs: list("evidence_refs"),
+      unresolvedItems: list("unresolved_items"),
+      risks: list("risks"),
+    };
+  } catch { return null; }
+}
+
 function sessionUserLabel(session) {
   if (!session) return null;
   for (const key of ["user_label", "display_name", "email", "account_id", "auth_user_id"]) {