@awak-app/simy-cli 0.7.47 → 0.7.49

package/package.json

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

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.47";
+export const CLI_VERSION = "0.7.49";
 export const CLI_API_CONTRACT_VERSION = 10;
 
 export function narrativeImageCapabilityMetadata() {

package/src/delivery-hooks/supervisor.js

@@ -691,6 +691,23 @@ export function createManagedSupervisor(options) {
       // Continue actual task work and its result checks. Starting an unrelated
       // periodic audit here could acquire a lease that prevents that work.
       if (!running) running = (async () => {
+        // Share cancellation discovery within this offered batch, never its
+        // authority: reconciliation still reads each current record. Long-lived
+        // queued jobs refresh at the desktop's 3s maintenance cadence; new ticks
+        // also replace their queued observations. Failed reads remain retryable.
+        let cancellationCandidates, cancellationReadAt;
+        const readCancellationRecords = () => {
+          const age = Date.now() - cancellationReadAt;
+          if (!cancellationCandidates || !(age >= 0 && age < 3000)) {
+            cancellationReadAt = Date.now();
+            const pending = Promise.resolve()
+              .then(() => options.readCancellationRecords ? options.readCancellationRecords() : listRecords(options.root))
+              .then(records => records.filter(record => record.run?.managed?.nativeHandoff));
+            cancellationCandidates = pending;
+            void pending.catch(() => { if (cancellationCandidates === pending) cancellationCandidates = null; });
+          }
+          return cancellationCandidates;
+        };
         for (const record of await readCandidates()) {
           if (closed || await options.shouldYield?.()) break;
           if (!record.run?.managed) continue;
@@ -707,7 +724,7 @@ export function createManagedSupervisor(options) {
               return rows.filter(row => row?.provider === record.provider && row.session === record.session &&
                 row.run?.id === record.run.id && row.run?.managed?.taskId === record.run.managed.taskId);
             };
-            await tickManagedTasks({ ...options, readRecords, signal: controller.signal });
+            await tickManagedTasks({ ...options, readRecords, readCancellationRecords, signal: controller.signal });
           });
         }
       })().finally(() => { running = null; });

package/src/desktop-host.js

@@ -1053,7 +1053,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
       setImmediate(() => { void publish().catch(() => {}); });
     } },
   });
-  // Batch burst notifications and maintenance completions into one frame. The
+  // Batch burst notifications and heartbeat/status requests into one frame. The
   // short window leaves commands responsive and the regular heartbeat intact.
   const publish = () => {
     if (closed || relay || !agent) return Promise.resolve();
@@ -1544,7 +1544,11 @@ export async function startDesktopHost({ input = process.stdin, output = process
     const maintenance = new Map();
     const tick = worker => {
       if (closed || relay || !coordinator.acceptsNewWork() || maintenance.has(worker)) return;
-      const pending = Promise.resolve().then(() => worker.tick()).then(() => { if (!closed && !relay) return publish(); }).catch(() => {}).finally(() => maintenance.delete(worker));
+      // The existing heartbeat publishes completed background maintenance.
+      // Completion itself does not prove a visible change; after the short
+      // batching window it otherwise reprojects/repaints the entire history.
+      // Explicit commands and actual change notifications keep their live path.
+      const pending = Promise.resolve().then(() => worker.tick()).catch(() => {}).finally(() => maintenance.delete(worker));
       maintenance.set(worker, pending);
     };
     tick(actionAssociations);

package/src/update-detachment/runtime.js

@@ -36,6 +36,14 @@ export async function worktreeEvidence(worktree) {
 }
 const stopped = new Set(['stopped','paused','paused_by_user','cancelled']);
 const terminal = new Set(['completed','reported_done','failed','succeeded']);
+const terminalLocalTasks = new Set(['succeeded','failed','stopped']);
+function hasPendingExecution(task, localTask = false) {
+  // Coding runs use operation for an async handle. Local Tasks persist their
+  // operation kind (for example "read") even after completion and restoration.
+  const operation = localTask ? task.operation != null && typeof task.operation !== 'string' : task.operation;
+  return Boolean(task.child || operation || task.operation_promise || task.pendingLedgerUpdate || task.ledgerUpdateRunning ||
+    (localTask ? !terminalLocalTasks.has(task.status) : ['queued','running','dispatching','coding'].includes(task.status)));
+}
 const taskState = run => stopped.has(run.state) ? run.state : run.managed?.pendingApproval ? 'approval_wait' : ['blocked','waiting_human','recovery_required'].includes(run.state) ? 'needs_user' : 'active';
 const originalTaskId = record => record.run.managed?.taskId || record.run.id;
 const authority = record => digest([record.run?.id,record.run?.state,record.run?.managed,record.run?.deadline,record.run?.continuations,record.run?.failures,record.autoContinue,record.process,record.cwd,record.run?.executionCwd]);
@@ -167,7 +175,8 @@ export function createUpdateRuntime({ root, origin, readContext, listRecords, ob
     if(startingGate.connection!=='detaching')return {safe:false,liveExecutions:0,pendingWrites:0,unsettledPermissions:0};
     retainer?.assertSupported([]);
     const c=context(), execution=[...(c.runs||[]),...(c.localTasks||[])];
-    const unowned=execution.filter(run=>run.child || run.operation || run.pendingLedgerUpdate || run.ledgerUpdateRunning || ['queued','running','dispatching','coding'].includes(run.status));
+    const unowned=[...(c.runs||[]).filter(run=>hasPendingExecution(run)),
+      ...(c.localTasks||[]).filter(task=>hasPendingExecution(task,true))];
     const workers=[];
     for(const task of c.directTasks || []) {
       if(!['queued','running','stopping'].includes(task.status)) continue;