@awak-app/simy-cli 0.5.77 → 0.5.78

package/README.md

@@ -113,8 +113,11 @@ interrupting active tasks. The normal `simy` command remains available.
 Signed patch/minor updates wait for idle and verify the new runtime before
 handoff; failed startup restores the previous installed version. After a runtime
 update, choose **Restart to update** to load the updated native interface. This
-action is available only when tasks are idle; the service checks again before
-quitting. The window reports App and runtime versions separately while they
+action asks to stop running tasks before restarting. **Stop task…** in a task
+detail asks for confirmation and terminates its local Provider process, keeping
+existing output and history. An explicit update can likewise stop active work
+after confirmation; automatic updates still wait for idle. **⌘Q** exits SIMY and
+its background services directly, including when work is running. The window reports App and runtime versions separately while they
 differ, and normal app launches select the newer installed interface.
 
 Older installers that predate native app relaunch support need a one-time

package/package.json

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

package/src/agent.js

@@ -75,6 +75,7 @@ import {
   createConnectionStatusTracker,
   desktopAuthStatus,
   desktopTaskStatus,
+  canStopDesktopTask,
   desktopTaskDetail,
 } from "./desktop-status.js";
 import { recoveryContractForPreflight } from "./orchestrator/recovery.js";
@@ -108,6 +109,7 @@ import {
   directTaskSnapshot,
   DirectTaskRegistry,
   startDirectTask,
+  stopDirectTask,
 } from "./direct-executor.js";
 import {
   classifyExecutionRequirement,
@@ -291,6 +293,7 @@ export async function startAgent({
   let codingRunMonitorTimer = null;
   let codingRunMonitorInFlight = null;
   let shuttingDown = false;
+  let desktopWorkSuspended = false;
   const notifyDesktopStatusChange = () => {
     if (shuttingDown) return;
     try { onDesktopStatusChange?.(); } catch { /* Desktop status polling remains available. */ }
@@ -312,10 +315,12 @@ export async function startAgent({
     session?.account_id ?? null, session?.organization_id ?? null, session?.device_id ?? null, session?.token ?? null,
     pendingOrganization?.id ?? null, isSessionValid(session, Date.now(), apiOrigin),
   ])).digest('hex');
-  const desktopWorkAllowed = () => !enforceDesktopAccess || desktopAccessReady(desktopAccess.snapshot());
+  const desktopWorkAllowed = () => !desktopWorkSuspended && (!enforceDesktopAccess || desktopAccessReady(desktopAccess.snapshot()));
   const authorizeDesktopWork = async expectedScope => {
+    if (desktopWorkSuspended || shuttingDown) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
     if (enforceDesktopAccess) {
       requireDesktopAccess(await desktopAccess.refresh());
+      if (desktopWorkSuspended || shuttingDown) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
       const scope = desktopScopeRevision();
       if (expectedScope !== undefined && expectedScope !== scope) throw Object.assign(new Error("Desktop account or organization changed."), { code: "desktop_access_required" });
       return scope;
@@ -2429,6 +2434,31 @@ export async function startAgent({
     startHeartbeatTimer();
   }
 
+  const stopDesktopTask = async key => {
+    if (typeof key !== "string" || key.length > 256) throw new Error("Select a running task.");
+    if (key.startsWith("sqm:")) {
+      if (!sqmLocalReviewWorker) throw new Error("This SQM task is no longer running.");
+      return sqmLocalReviewWorker.stop(key);
+    }
+    const match = /^(0|1|2):(.+)$/.exec(key);
+    if (!match) throw new Error("Select a running task.");
+    const index = Number(match[1]);
+    const task = [registry, directRegistry, localTaskRegistry][index].get(match[2]);
+    if (!task) throw new Error("This task is no longer available.");
+    if (!canStopDesktopTask(task, index)) return;
+    await [stopLocalCodingRun, stopDirectTask, stopLocalTask][index](task);
+    notifyDesktopStatusChange();
+  };
+  const stopDesktopTasks = async () => {
+    desktopWorkSuspended = true;
+    const stops = [sqmLocalReviewWorker?.close?.(), durableLocalTaskWorker?.close?.(),
+      ...[registry, directRegistry, localTaskRegistry].flatMap((source, index) => source.list()
+        .filter(task => canStopDesktopTask(task, index))
+        .map(task => [stopLocalCodingRun, stopDirectTask, stopLocalTask][index](task)))];
+    const results = await Promise.allSettled(stops);
+    const failure = results.find(result => result.status === "rejected");
+    if (failure) throw failure.reason;
+  };
   let shutdownPromise = null;
   const shutdown = () => {
     if (shutdownPromise) return shutdownPromise;
@@ -2437,12 +2467,9 @@ export async function startAgent({
     shutdownPromise = (async () => {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
       if (codingRunMonitorTimer) clearInterval(codingRunMonitorTimer);
-      if (codingRunMonitorInFlight) await codingRunMonitorInFlight;
       updateManager?.stop?.();
-      await codexWorkPatternSync?.close?.();
-      await codexWorkPatternSyncInFlight;
-      await sqmLocalReviewWorker?.close?.();
-      await durableLocalTaskWorker?.close?.();
+      await Promise.all([stopDesktopTasks(), codexWorkPatternSync?.close?.(),
+        codexWorkPatternSyncInFlight, codingRunMonitorInFlight]);
       try {
         await (dependencies.removeConnectionDiscovery || removeConnectionDiscovery)(
           connectionDiscovery,
@@ -2577,6 +2604,8 @@ export async function startAgent({
       return { code: ticket.code, expiresAt: ticket.expiresAt, userId: ticket.userId, orgSlug: ticket.orgSlug };
     },
     getDesktopStatus,
+    stopDesktopTask,
+    stopDesktopTasks,
     getDesktopTask: async (key) => {
       if (key?.startsWith("sqm:") || key?.startsWith("sqm-check:")) {
         const scope = currentHistoryScope();

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

package/src/desktop-access.js

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

package/src/desktop-force-quit.js

@@ -0,0 +1,81 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readFile } from 'node:fs/promises';
+import { windowsUserProcesses } from './windows-processes.js';
+import { homedir } from 'node:os';
+import { parseLegacyAgentArguments } from './desktop-process-lock.js';
+import { dirname, join } from 'node:path';
+const run = promisify(execFile);
+
+// Fallback for an unresponsive host. The requesting native app must still own
+// the exact host; snapshot/start-time checks exclude PID reuse and unrelated apps.
+export async function stopOwnedDesktopHost(pid, { parentPid = process.ppid,
+  snapshot = processSnapshot, kill = process.kill.bind(process), includeRoot = true } = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 1) throw new Error('Invalid host');
+  const rows = await snapshot();
+  const host = rows.find(row => row.pid === pid);
+  if (!host) return;
+  if (host.eligible === false || host.ppid !== parentPid || !await isHostCommand(host.command)) throw new Error('Host ownership changed');
+  await stopProcessTree(host, rows, { snapshot, kill, includeRoot });
+}
+async function stopProcessTree(host, rows, { snapshot, kill, includeRoot = true }) {
+  const pid = host.pid;
+  const owned = new Set([pid]);
+  const depths = new Map([[pid, 0]]);
+  for (let changed = true; changed;) {
+    changed = false;
+    for (const row of rows) if (owned.has(row.ppid) && !owned.has(row.pid)) { owned.add(row.pid); depths.set(row.pid, depths.get(row.ppid) + 1); changed = true; }
+  }
+  // Descendants first, while the root still anchors ownership.
+  for (const row of rows.filter(row => owned.has(row.pid) && (includeRoot || row.pid !== pid)).sort((a,b) => depths.get(b.pid) - depths.get(a.pid))) {
+    const live = (await snapshot()).find(item => item.pid === row.pid);
+    if (!live || live.startedAt !== row.startedAt || live.ppid !== row.ppid || live.command !== row.command) continue;
+    try { kill(row.pid, 'SIGKILL'); } catch (error) { if (error.code !== 'ESRCH') throw error; }
+  }
+}
+async function isHostCommand(command) {
+  const match = String(command).replaceAll("\\", "/").match(/\s"?((?:\/|[A-Za-z]:\/).*?\/src\/desktop-host\.js)"?(?:\s|$)/);
+  if (!match) return false;
+  try { return JSON.parse(await readFile(join(dirname(dirname(match[1])), 'package.json'), 'utf8')).name === '@awak-app/simy-cli'; }
+  catch { return false; }
+}
+async function processSnapshot() {
+  if (process.platform === 'win32') {
+    const userPids = new Set((await windowsUserProcesses()).map(row => row.pid));
+    const { stdout } = await run(join(process.env.SystemRoot || 'C:\\Windows', 'System32/WindowsPowerShell/v1.0/powershell.exe'),
+      ['-NoProfile','-NonInteractive','-Command', 'Get-CimInstance Win32_Process | Where-Object { $_.CreationDate } | Select-Object @{n="pid";e={$_.ProcessId}},@{n="ppid";e={$_.ParentProcessId}},@{n="startedAt";e={$_.CreationDate.ToUniversalTime().ToString("o")}},@{n="command";e={$_.CommandLine}} | ConvertTo-Json -Compress'],
+      {timeout:15000,windowsHide:true,maxBuffer:4*1024*1024});
+    const parsed = JSON.parse(stdout || '[]');
+    return (Array.isArray(parsed) ? parsed : [parsed]).map(row => ({...row, eligible:userPids.has(row.pid)}));
+  }
+
+  const { stdout } = await run('/bin/ps', ['-ww', '-axo', 'pid=,ppid=,uid=,lstart=,command='], { timeout: 3000, maxBuffer: 4*1024*1024 });
+  return stdout.split('\n').flatMap(line => {
+    const m = line.match(/^\s*(\d+)\s+(\d+)\s+(\d+)\s+((?:\S+\s+){4}\S+)\s+(.+)$/);
+    return m && Number(m[3]) === process.getuid() ? [{ pid:Number(m[1]), ppid:Number(m[2]), startedAt:m[4], command:m[5] }] : [];
+  });
+}
+
+export async function stopSimyServices({ snapshot = processSnapshot, kill = process.kill.bind(process), currentPid = process.pid, home = process.env.SIMY_HOME } = {}) {
+  const rows = await snapshot();
+  // Custom SIMY_HOME is an isolated installation/test scope, never global quit.
+  let scopedOwner = null;
+  if (home && home !== join(homedir(), '.simy')) {
+    try { scopedOwner = JSON.parse(await readFile(join(home, 'desktop-app.lock/owner.json'), 'utf8')); }
+    catch { return; }
+  }
+  for (const row of rows) {
+    if (row.pid === currentPid || row.eligible === false || scopedOwner && (row.pid !== scopedOwner.pid || row.startedAt.replace(/\s+/g, " ") !== String(scopedOwner.startedAt).replace(/\s+/g, " "))) continue;
+    const host = await isHostCommand(row.command);
+    const legacy = parseLegacyAgentArguments(row.command);
+    let daemon = false;
+    if (legacy) {
+      try { daemon = JSON.parse(await readFile(join(dirname(dirname(legacy.entryPath)), 'package.json'), 'utf8')).name === '@awak-app/simy-cli'; } catch { }
+    }
+    if (host || daemon) await stopProcessTree(row, rows, { snapshot, kill });
+  }
+}
+if (process.argv[1]?.replaceAll('\\', '/')?.endsWith('/desktop-force-quit.js')) {
+  const stop = process.argv[2] === '--all-services' ? stopSimyServices() : stopOwnedDesktopHost(Number(process.argv[2]));
+  stop.then(() => process.exit(0)).catch(() => process.exit(1));
+}

package/src/desktop-host.js

@@ -1,3 +1,4 @@
+import { stopOwnedDesktopHost } from "./desktop-force-quit.js";
 import { desktopAccessReady, desktopActionAllowed, requireDesktopAccess, validDesktopAccessPath } from './desktop-access.js';
 import { createActionDeadlineService } from './session-supervision/action-deadline.js';
 import { deliveryHookStatus, openHookSetup } from "./delivery-hooks/desktop.js";
@@ -55,11 +56,11 @@ function desktopActionError(action, error) {
   if (["sqm_set_enabled", "sqm_set_engine_fallback", "sqm_retry_environment"].includes(action)) {
     return "Could not save SQM settings. Check your SIMY connection and try again.";
   }
-  return "Action could not finish. Refresh the status and try again; active tasks must finish before quitting.";
+  return "Action could not finish. Refresh the status and try again.";
 }
 
 export async function startDesktopHost({ input = process.stdin, output = process.stdout, env = process.env,
-  dependencies = {}, exit = (code) => { process.exitCode = code; } } = {}) {
+  dependencies = {}, exit = (code) => process.exit(code) } = {}) {
   const emit = (event) => output.write(`${JSON.stringify(event)}\n`);
   // A heartbeat remains a complete native frame. Only its observation time is
   // volatile; reuse the encoded body after comparing freshly authorized data.
@@ -103,9 +104,12 @@ export async function startDesktopHost({ input = process.stdin, output = process
     return currentAccess;
   };
   const accessSnapshot = async () => setAccessSnapshot((await agent?.getDesktopStatus?.())?.access);
+  let stoppingForUpdate = false;
   const authorizeWork = async expectedScope => {
+    if (closed || stoppingForUpdate) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
     if (agent?.requireDesktopAccess) await agent.requireDesktopAccess();
     const access = await accessSnapshot();
+    if (closed || stoppingForUpdate) throw new Error("SIMY is stopping. Reopen SIMY before starting new work.");
     requireDesktopAccess(access);
     const scope = accessScope(access);
     if (expectedScope !== undefined && expectedScope !== scope) throw Object.assign(new Error("Desktop account or organization changed."), { code: "desktop_access_required" });
@@ -259,17 +263,16 @@ export async function startDesktopHost({ input = process.stdin, output = process
   const stopAgent = async () => {
     clearInterval(timer);
     discoveryStopped = true;
-    await stopDiscovery({ drain: true });
     encodedStatus = null; lastStatus = null;
     if (scheduledPublish) { clearTimeout(scheduledPublish.timer); scheduledPublish.resolve(); scheduledPublish = null; }
-    await publishing?.catch(() => {});
-    await actionAssociations.close();
-    await automaticContinuation?.close();
-    await analysisManager?.close();
-    await managedSupervisor.close();
-    await recordReader.close();
-    await stopWorkflows();
-    if (agent) await createAgentShutdown(agent)();
+    // 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,
+      actionAssociations.close(), automaticContinuation?.close(), analysisManager?.close(),
+      managedSupervisor.close(), recordReader.close(), stopWorkflows(),
+      agent ? createAgentShutdown(agent)() : undefined]);
+    const failure = results.find(result => result.status === "rejected");
+    if (failure) throw failure.reason;
   };
   const close = () => shuttingDown ||= (async () => {
     closed = true;
@@ -411,6 +414,7 @@ export async function startDesktopHost({ input = process.stdin, output = process
   // Saving/revoking opt-in must not queue behind provider or remote work.
   let preferenceQueue = Promise.resolve();
   let activeQueuedAction = null;
+  let controlQueue = Promise.resolve();
   commands = createInterface({ input, crlfDelay: Infinity });
   commands.on("line", (line) => {
     if (closed) return;
@@ -425,6 +429,29 @@ export async function startDesktopHost({ input = process.stdin, output = process
       if (closed) return;
       try {
         const action = command.action;
+        if (action === "quit") {
+          if (command.force !== true) {
+            const status = await agent.getDesktopStatus();
+            if ((status.tasks?.activeCount || 0) + (status.sqmTasks?.activeCount || 0) > 0) throw new Error("Tasks are still running. Confirm before quitting.");
+          }
+          // Cancel first, then acknowledge. The native app waits for the host
+          // exit; this deadline also covers a stuck remote flush/discovery.
+          const deadline = setTimeout(async () => {
+            emit({ type: "result", id: command.id, ok: true });
+            try { await (dependencies.stopOwnedHost || stopOwnedDesktopHost)(process.pid, { parentPid: process.ppid, includeRoot: false }); }
+            catch { /* Native ownership-checked fallback remains available. */ }
+            finally { exit(0); }
+          }, dependencies.quitTimeoutMs ?? 8000);
+          try { await close(); emit({ type: "result", id: command.id, ok: true }); }
+          finally { clearTimeout(deadline); exit(0); }
+          return;
+        }
+        if (action === "task_stop") {
+          if (command.force !== true) throw new Error("Confirm before stopping this task.");
+          await agent.stopDesktopTask(command.taskKey);
+          emit({ type: "result", id: command.id, ok: true });
+          void publish(); return;
+        }
         const access = await accessSnapshot();
         const commandScope = accessScope(access);
         if (!desktopActionAllowed(access, command)) throw Object.assign(new Error('Desktop access is required.'), { code: 'desktop_access_required' });
@@ -487,8 +514,17 @@ export async function startDesktopHost({ input = process.stdin, output = process
           }
         } else if (action === "check_update") await updater.checkNow();
         else if (action === "update") {
+          if (command.force === true) {
+            stoppingForUpdate = true; discoveryStopped = true;
+            void stopDiscovery();
+            // Abort dispatch immediately; existing Delivery Loop records retain
+            // their cancelled checkpoint so another host cannot silently resume.
+            await Promise.all([agent.stopDesktopTasks(), managedSupervisor.close(),
+              automaticContinuation?.close(), analysisManager?.close()]);
+          }
           if (updater.snapshot().state === "waiting_for_idle") await updater.maybeApply();
           else await updater.performAction();
+          if (command.force === true && ["failed", "error"].includes(updater.snapshot().state)) throw new Error("Update failed after stopping tasks.");
         } else if (action === "codex_login" || action === "claude_login") {
           const provider = action === "claude_login" ? "claude" : "codex";
           const login = dependencies[`${provider}Login`];
@@ -588,24 +624,23 @@ export async function startDesktopHost({ input = process.stdin, output = process
             session: command.session, taskId: command.taskId, questionId: command.questionId, answer: command.answer });
           await refreshSessions(true);
         }
-        else if (action === "quit") {
-          const status = await agent.getDesktopStatus();
-          if ((status.tasks.activeCount + (status.sqmTasks?.activeCount || 0)) > 0 && command.force !== true) throw new Error("Tasks are still running. Confirm before quitting.");
-          emit({ type: "result", id: command.id, ok: true });
-          await close(); exit(0); return;
-        } else throw new Error("Unsupported desktop action.");
+        else throw new Error("Unsupported desktop action.");
         emit({ type: "result", id: command.id, ok: true });
         await publish();
       } catch (error) {
-        emit({ type: "result", id: command.id, ok: false, message: desktopActionError(command.action, error) });
+        emit({ type: "result", id: command.id, ok: false, message: command.action === "update" && stoppingForUpdate ? "Could not finish the update after stopping tasks. Reopen SIMY and retry the update." : desktopActionError(command.action, error) });
       }
     };
-    if (["login", "organization_select", "organization_cancel", "authorization_open"].includes(command.action)) {
+    if (command.action === "quit") {
+      void execute();
+    } else if (["login", "organization_select", "organization_cancel", "authorization_open"].includes(command.action)) {
       authorizationQueue = authorizationQueue.then(execute).catch(() => {});
     } else if (command.action === "my_ai_session") {
       myAiSessionQueue = myAiSessionQueue.then(execute).catch(() => {});
     } else if (command.action === "session_set_auto_continue") {
       preferenceQueue = preferenceQueue.then(execute).catch(() => {});
+    } else if (["task_stop", "delivery_stop"].includes(command.action) || command.action === "update" && command.force === true) {
+      controlQueue = controlQueue.then(execute).catch(() => {});
     } else {
       queue = queue.then(async () => {
         activeQueuedAction = command.action;

package/src/desktop-status.js

@@ -217,6 +217,11 @@ export function isUnauthorizedError(error) {
   );
 }
 
+export function canStopDesktopTask(task, registryIndex) {
+  const state = task?.status || task?.snapshot?.state || task?.state || task?.control_state || task?.controlState || "unknown";
+  return registryIndex === 0 ? !INACTIVE_STATES.has(state) : ["queued", "running", "stopping"].includes(state);
+}
+
 function taskStatusItem(task, registryIndex) {
   const state = bounded(
     String(
@@ -237,6 +242,7 @@ function taskStatusItem(task, registryIndex) {
     id: bounded(String(task?.id || `unknown-${registryIndex}`), MAX_LABEL_LENGTH),
     label: bounded(String(label), MAX_LABEL_LENGTH),
     state,
+    canStop: canStopDesktopTask(task, registryIndex),
     updatedAt:
       Date.parse(task?.updated_at || task?.snapshot?.updated_at || task?.startedAt || 0) || 0,
   };

package/src/direct-executor.js

@@ -1,3 +1,4 @@
+import { signalExecutorProcess } from "./runner.js";
 import { randomUUID } from "node:crypto";
 
 import { resolveDesktopExecutorCommand } from "./desktop-executor.js";
@@ -68,6 +69,7 @@ export async function startDirectTask(
     permissionMode: task.permission_mode,
     environment,
   });
+  if (task.stop_requested || task.status !== "queued") return task;
   task.status = "running";
   task.invocation_count = 1;
   task.updated_at = new Date().toISOString();
@@ -120,8 +122,8 @@ export async function startDirectTask(
       error ||= terminalError;
       task.child = null;
       task.token_usage = { records: tokenRecords };
-      task.status = error || exitCode !== 0 ? "failed" : "succeeded";
-      task.error = error || (exitCode !== 0 ? `Provider exited with code ${exitCode}.` : null);
+      task.status = task.stop_requested ? "stopped" : error || exitCode !== 0 ? "failed" : "succeeded";
+      task.error = task.stop_requested ? null : error || (exitCode !== 0 ? `Provider exited with code ${exitCode}.` : null);
       task.result = task.output.at(-1) || rawStdout.join("").trim() || null;
       task.updated_at = new Date().toISOString();
       resolve(task);
@@ -149,3 +151,27 @@ export function directTaskSnapshot(task) {
     updated_at: task.updated_at,
   };
 }
+
+// Only the child captured by this task may be signalled, including its owned tools.
+export function stopDirectTask(task) {
+  if (!task) return Promise.resolve(task);
+  return task.stopPromise ||= stopOwnedDirectTask(task);
+}
+async function stopOwnedDirectTask(task) {
+  if (!task || !["queued", "running", "stopping"].includes(task.status)) return task;
+  task.stop_requested = true;
+  task.status = "stopping";
+  const child = task.child;
+  if (!child) { task.status = "stopped"; task.updated_at = new Date().toISOString(); return task; }
+  for (const signal of ["SIGINT", "SIGTERM", "SIGKILL"]) {
+    if (task.child !== child) return task;
+    await new Promise(resolve => {
+      const done = () => { clearTimeout(timer); child.off("close", done); resolve(); };
+      const timer = setTimeout(done, signal === "SIGKILL" ? 750 : 1500);
+      child.once("close", done);
+      signalExecutorProcess(child, signal);
+    });
+  }
+  if (task.child === child) throw new Error("The local task did not stop. Try quitting SIMY.");
+  return task;
+}

package/src/durable-local-task-worker.js

@@ -1415,6 +1415,7 @@ export function createDurableLocalTaskWorker({
               workerId,
               leaseSeconds,
             });
+            if (closed) { releaseWork(); return false; }
             const parentClaim = normalizeDurableLocalTaskExecutionClaimV2(
               parentEnvelope,
               { workerId, leaseSeconds },
@@ -1470,6 +1471,7 @@ export function createDurableLocalTaskWorker({
             leaseSeconds,
             turnId: requestedTurnId,
           });
+          if (closed) { releaseWork(); return false; }
           if (!claim) {
             if (requestedTurnId) {
               throw workerError(
@@ -1539,6 +1541,7 @@ export function createDurableLocalTaskWorker({
             }
             lastStepDisposition = null;
           }
+          if (closed) { releaseWork(); return false; }
           active = { claim, task: null };
           const executionPromise = executeClaim(claim, releaseWork)
             .catch((error) => {
@@ -1580,9 +1583,10 @@ export function createDurableLocalTaskWorker({
     },
     async close() {
       closed = true;
+      // Cancel owned Provider work before waiting for any pending network operation.
+      await Promise.all([active?.subtaskPool?.close?.().catch(() => undefined),
+        active?.task ? stopTask(active.task).catch(() => undefined) : undefined]);
       await pollPromise;
-      await active?.subtaskPool?.close?.().catch(() => undefined);
-      if (active?.task) await stopTask(active.task).catch(() => undefined);
       await activeExecutionPromise;
     },
   };

package/src/sqm/review-worker.js

@@ -1,3 +1,4 @@
+import { signalExecutorProcess } from "../runner.js";
 import spawn from "cross-spawn";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -44,7 +45,7 @@ export function createSqmLocalReviewApi({
   if (typeof fetchImpl !== "function") throw new TypeError("fetchImpl is required");
 
   return {
-    async request(body) {
+    async request(body, { signal, timeoutMs = requestTimeoutMs } = {}) {
       const connection = getConnection();
       if (!connection?.apiOrigin || !connection?.token) {
         throw new SqmLocalReviewError("The SIMY CLI session is not connected.", {
@@ -65,10 +66,11 @@ export function createSqmLocalReviewApi({
               { "Content-Type": "application/json" },
             ),
             body: JSON.stringify(body),
-            signal: AbortSignal.timeout(requestTimeoutMs),
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs),
           },
         );
       } catch (error) {
+        if (signal?.aborted) throw providerFailure("analysis_cancelled");
         throw new SqmLocalReviewError(`SIMY Web could not be reached: ${errorMessage(error)}`, {
           code: "sqm_local_review_gateway_unavailable",
         });
@@ -111,6 +113,7 @@ export function createSqmLocalReviewWorker({
   let activeJobId = null;
   let pollPromise = null;
   let closed = false;
+  let reviewController = null;
   let issue = null, pausedEnvironment = null, pauseReason = null;
   let issueContext = null;
   const failureDetails = new WeakMap();
@@ -159,7 +162,9 @@ export function createSqmLocalReviewWorker({
     let nextRequest = request;
     for (let attempt = 0; ; attempt += 1) {
       setStage(false);
+      if (reviewOptions.signal?.aborted) throw providerFailure("analysis_cancelled");
       const review = await runReview(nextRequest, provider, reviewOptions);
+      if (reviewOptions.signal?.aborted) throw providerFailure("analysis_cancelled");
       setStage(true);
       try {
         return { review, response: await submit(review) };
@@ -187,12 +192,14 @@ export function createSqmLocalReviewWorker({
     heartbeatTimer = setInterval(heartbeat, heartbeatIntervalMs);
     heartbeatTimer.unref?.();
     let stage = "analysis";
-    const reviewOptions = { providerReportingSupported: claim.capabilities?.reported_executor_provider === true,
-      beforeLeaseDispatch: () => api.request({ action: "heartbeat", ...leaseBody(claim, provider) }) };
+    const signal = reviewController?.signal;
+    const request = body => api.request(body, { signal });
+    const reviewOptions = { signal, providerReportingSupported: claim.capabilities?.reported_executor_provider === true,
+      beforeLeaseDispatch: () => request({ action: "heartbeat", ...leaseBody(claim, provider) }) };
     const providerReport = (review, selectedProvider = provider) => claim.capabilities?.reported_executor_provider === true
       ? { reported_executor_provider: review.provider || selectedProvider } : {};
     try {
-      const { review: analysis, response: advanced } = await validatedReview(claim.request, provider, "invalid_sqm_analysis_output", analysis => api.request({
+      const { review: analysis, response: advanced } = await validatedReview(claim.request, provider, "invalid_sqm_analysis_output", analysis => request({
         action: "advance",
         ...leaseBody(claim, provider),
         analysis_output: analysis.output,
@@ -204,7 +211,7 @@ export function createSqmLocalReviewWorker({
       if (item) item.provider = analysisProvider;
       if (advanced.completed) { await updateTask(claim.job_id, "completed", historyScope); return advanced; }
       stage = "adjudication";
-      const { review: adjudication, response: completed } = await validatedReview(advanced.request, analysisProvider, "invalid_sqm_adjudication_output", adjudication => api.request({
+      const { review: adjudication, response: completed } = await validatedReview(advanced.request, analysisProvider, "invalid_sqm_adjudication_output", adjudication => request({
         action: "complete",
         ...leaseBody(claim, provider),
         analysis_output: analysis.output,
@@ -223,11 +230,11 @@ export function createSqmLocalReviewWorker({
       if (!failureReported) {
         try {
           const report = await api.request({ action: "fail", ...leaseBody(claim, provider),
-            error_stage: failure.stage, error_code: failure.code, ...(failure.status ? { error_status: failure.status } : {}) });
+            error_stage: failure.stage, error_code: failure.code, ...(failure.status ? { error_status: failure.status } : {}) }, failure.code === "analysis_cancelled" ? { timeoutMs: 3000 } : undefined);
           failureReported = report?.recorded === true;
         } catch { /* Keep the original failure even when reporting fails. */ }
       }
-      await updateTask(claim.job_id, "failed", historyScope, failure, failureReported);
+      await updateTask(claim.job_id, failure.code === "analysis_cancelled" ? "cancelled" : "failed", historyScope, failure, failureReported);
       throw error;
     } finally {
       if (heartbeatTimer) clearInterval(heartbeatTimer);
@@ -242,7 +249,7 @@ export function createSqmLocalReviewWorker({
       return { active_job_id: activeJobId, polling: Boolean(pollPromise), closed, paused: pausedEnvironment !== null, pause_reason: pauseReason, issue: issueContext === contextKey(getProvider(), getHistoryScope()) ? issue : null,
         ...(pause ? { provider_pause: { code: pause.code, status: pause.status, retry_at: new Date(pause.retryAt).toISOString(), message: pause.message } } : {}) };
     },
-    desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item })) }; },
+    desktopTasks() { return { activeCount: activeJobId ? 1 : 0, items: visibleHistory().map(item => ({ ...item, canStop: item.id === activeJobId })) }; },
     desktopTaskDetail(key) {
       const item = visibleHistory().find(item => item.key === key);
       return item ? { key, instruction: `SQM local review · ${item.provider}`, result: item.state === "completed" ? "SQM review submitted." : "", error: item.error || "", links: item.webUrl ? [{ label: "Analysis details", url: item.webUrl }] : [] } : null;
@@ -266,13 +273,14 @@ export function createSqmLocalReviewWorker({
       const releaseWork = beginWork?.();
       if (!releaseWork) return Promise.resolve(null);
       const workspaceUrl = getWorkspaceUrl();
+      reviewController = new AbortController();
       pollPromise = (async () => {
         const claim = await api.request({
           action: "claim",
           executor_provider: provider,
           worker_id: workerId,
           lease_seconds: leaseSeconds,
-        });
+        }, { signal: reviewController.signal });
         if (issue) { issue = null; onChange(); }
         if (!claim?.claimed) {
           // A successful empty claim proves SIMY access recovered, but it says
@@ -285,6 +293,7 @@ export function createSqmLocalReviewWorker({
         return result;
       })()
         .catch(async (error) => {
+          if (error.code === "analysis_cancelled") return null;
           pauseForFailure(error, provider, historyScope, recoveryKey);
           if (error.jobId && /^[a-f0-9-]{36}$/i.test(error.jobId) && !history.some(item => item.id === error.jobId)) {
             const scope = historyScope;
@@ -305,13 +314,20 @@ export function createSqmLocalReviewWorker({
         })
         .finally(() => {
           pollPromise = null;
+          reviewController = null;
           releaseWork();
           onChange();
         });
       return pollPromise;
     },
+    async stop(key) {
+      if (key !== `sqm:${activeJobId}` || !activeJobId) throw new Error("This SQM task is no longer running.");
+      reviewController?.abort();
+      await pollPromise;
+    },
     async close() {
       closed = true;
+      reviewController?.abort();
       await pollPromise;
     },
   };
@@ -494,7 +510,7 @@ function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, cwd
     let child;
     try {
       child = spawnImpl(command, args, {
-        env: safeReviewEnvironment(environment, provider), cwd, windowsHide: true, stdio: ["pipe", "pipe", "pipe"],
+        env: safeReviewEnvironment(environment, provider), cwd, windowsHide: true, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"],
       });
     } catch { reject(providerFailure("provider_spawn_failed", { model })); return; }
     let stdout = "", stderrPending = "", outputBytes = 0;
@@ -503,9 +519,9 @@ function spawnReview(command, args, prompt, { spawnImpl, executionTimeoutMs, cwd
     const halt = error => {
       if (settled || terminalError) return;
       terminalError = error;
-      child.kill?.("SIGTERM");
+      signalExecutorProcess(child, "SIGTERM");
       if (!settled) killTimer = setTimeout(() => {
-        child.kill?.("SIGKILL");
+        signalExecutorProcess(child, "SIGKILL");
         // Keep the original timeout/cancellation if the process API never
         // acknowledges termination; do not replace it with an opaque error.
         if (!settled) killTimer = setTimeout(() => finish(terminalError), terminationGraceMs);