mixdog 0.9.130 → 0.9.131

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.130",
+  "version": "0.9.131",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/release-timing-report.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { appendFile, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function payloadJobs(payload) {
+  const pages = Array.isArray(payload) ? payload : [payload];
+  return pages.flatMap((page) => Array.isArray(page?.jobs) ? page.jobs : []);
+}
+
+function elapsedSeconds(startedAt, completedAt) {
+  const start = Date.parse(startedAt || '');
+  const end = Date.parse(completedAt || '');
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) return null;
+  return Math.round((end - start) / 1000);
+}
+
+function timingRows(payload) {
+  return payloadJobs(payload).flatMap((job) => (job.steps || []).flatMap((step) => {
+    const seconds = elapsedSeconds(step.started_at, step.completed_at);
+    if (seconds === null) return [];
+    return [{
+      key: `${job.name} / ${step.name}`,
+      job: job.name,
+      step: step.name,
+      seconds,
+    }];
+  }));
+}
+
+function workflowSeconds(payload) {
+  const jobs = payloadJobs(payload);
+  const starts = jobs.map((job) => Date.parse(job.started_at || '')).filter(Number.isFinite);
+  const ends = jobs.map((job) => Date.parse(job.completed_at || '')).filter(Number.isFinite);
+  if (starts.length === 0 || ends.length === 0) return null;
+  return Math.round((Math.max(...ends) - Math.min(...starts)) / 1000);
+}
+
+function percentChange(current, baseline) {
+  if (!(baseline > 0)) return null;
+  return Math.round(((current - baseline) / baseline) * 100);
+}
+
+export function buildReleaseTimingReport(currentPayload, baselinePayload = []) {
+  const currentRows = timingRows(currentPayload);
+  const baselineRows = timingRows(baselinePayload);
+  const baselineByKey = new Map(baselineRows.map((row) => [row.key, row]));
+  const regressions = currentRows.flatMap((row) => {
+    const baseline = baselineByKey.get(row.key);
+    if (!baseline) return [];
+    const percent = percentChange(row.seconds, baseline.seconds);
+    if (percent === null || percent <= 10 || row.seconds - baseline.seconds < 15) return [];
+    return [{ ...row, baselineSeconds: baseline.seconds, percent }];
+  }).sort((a, b) => b.percent - a.percent || b.seconds - a.seconds);
+
+  const currentWorkflowSeconds = workflowSeconds(currentPayload);
+  const baselineWorkflowSeconds = workflowSeconds(baselinePayload);
+  const workflowPercent = currentWorkflowSeconds !== null && baselineWorkflowSeconds !== null
+    ? percentChange(currentWorkflowSeconds, baselineWorkflowSeconds)
+    : null;
+  const slowest = [...currentRows].sort((a, b) => b.seconds - a.seconds).slice(0, 15);
+  const markdown = [
+    '## Release timing',
+    '',
+    `- Current workflow span: ${currentWorkflowSeconds ?? 'n/a'}s`,
+    `- Previous successful span: ${baselineWorkflowSeconds ?? 'n/a'}s`,
+    `- Material step regressions (>10% and ≥15s): ${regressions.length}`,
+    '',
+    '| Slowest step | Current | Previous | Change |',
+    '| --- | ---: | ---: | ---: |',
+    ...slowest.map((row) => {
+      const baseline = baselineByKey.get(row.key);
+      const change = baseline ? percentChange(row.seconds, baseline.seconds) : null;
+      return `| ${row.key.replaceAll('|', '\\|')} | ${row.seconds}s | ${baseline ? `${baseline.seconds}s` : 'n/a'} | ${change === null ? 'n/a' : `${change > 0 ? '+' : ''}${change}%`} |`;
+    }),
+    '',
+  ].join('\n');
+
+  return {
+    currentWorkflowSeconds,
+    baselineWorkflowSeconds,
+    workflowPercent,
+    regressions,
+    markdown,
+  };
+}
+
+function commandValue(value) {
+  return String(value).replaceAll('%', '%25').replaceAll('\r', '%0D').replaceAll('\n', '%0A');
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : '';
+if (invokedPath === import.meta.url) {
+  const currentPath = process.argv[2];
+  const baselinePath = process.argv[3];
+  if (!currentPath) throw new Error('Usage: release-timing-report.mjs <current-jobs.json> [baseline-jobs.json]');
+  const current = JSON.parse(await readFile(currentPath, 'utf8'));
+  const baseline = baselinePath ? JSON.parse(await readFile(baselinePath, 'utf8')) : [];
+  const report = buildReleaseTimingReport(current, baseline);
+  if (process.env.GITHUB_STEP_SUMMARY) {
+    await appendFile(process.env.GITHUB_STEP_SUMMARY, `${report.markdown}\n`);
+  }
+  if (report.workflowPercent > 10
+      && report.currentWorkflowSeconds - report.baselineWorkflowSeconds >= 30) {
+    console.log(`::warning title=Release duration regression::Workflow span increased ${report.workflowPercent}% to ${report.currentWorkflowSeconds}s`);
+  }
+  for (const row of report.regressions) {
+    console.log(`::warning title=Release step regression::${commandValue(row.key)} increased ${row.percent}% (${row.baselineSeconds}s to ${row.seconds}s)`);
+  }
+  console.log(`Release timing recorded: ${report.currentWorkflowSeconds ?? 'n/a'}s, ${report.regressions.length} material step regressions.`);
+}

package/src/rules/shared/01-tool.md

@@ -62,17 +62,16 @@
   execution, runtime/state operations, calculations, data transformation, file
   generation, or formats unsupported by file tools. Do not use `shell` instead
   of an available file tool for ordinary file-content inspection.
-- Start shell commands in the foreground. Set `run_in_background:true` only when their result is not needed
-  immediately and completion notification is sufficient. Tracked sync/async
-  commands belong to the current run. Only when the request explicitly requires
+- Shell commands start in the foreground. If still running after 10 seconds,
+  the call returns a tracked `task_id` and completion arrives by notification.
+  Only when the request explicitly requires
   a service to survive after the run exits, detach it at shell level (for
   example, `nohup ... &`); never detach ordinary jobs merely to avoid tracking.
   A sync call may return a `task_id` and partial output after its blocking
   budget. Do not poll: completion resumes automatically. When intermediate output must drive
-  decisions or the user requests monitoring, use `task check_after` with an
-  explicit `after_ms` to schedule one non-blocking progress snapshot: normally
-  10–30s for active progress and 30–60s for long downloads/builds. Schedule
-  another only after inspecting that snapshot; completion cancels a pending
-  check.
+  decisions or the user explicitly requests monitoring, call `task read` once
+  to return the current status and output snapshot. If it is still running,
+  await the completion notification; do not
+  call `task` again unless the user explicitly asks for another snapshot.
   Omit timeout by default, including for long jobs; set it only for a real total
   deadline, since it kills even async jobs.

package/src/runtime/agent/orchestrator/agent-trace-format.mjs

@@ -138,8 +138,8 @@ const TOOL_ARG_KEYS = {
     recall: ['query', 'limit', 'session_id', 'cwd'],
     search: ['query', 'limit', 'cwd'],
     code_graph: ['mode', 'file', 'files', 'symbol', 'symbols', 'body', 'language', 'limit', 'depth', 'page', 'cwd'],
-    shell: ['command', 'cwd', 'timeout', 'mode', 'run_in_background', 'persistent', 'session_id'],
-    task: ['task_id', 'action', 'after_ms'],
+    shell: ['command', 'timeout_ms'],
+    task: ['action', 'task_id'],
     edit: ['path', 'replace_all', 'edits'],
     edit_many: ['edits'],
     write: ['path'],

package/src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs

@@ -633,10 +633,10 @@ function guardRead(a) {
 }
 
 function guardShell(a) {
-    const allowed = new Set(['command', 'timeout_ms', 'run_in_background']);
+    const allowed = new Set(['command', 'timeout_ms']);
     const unsupported = Object.keys(a).find((key) => !allowed.has(key));
     if (unsupported) {
-        return `Error: shell arg "${unsupported}" is unsupported; use only command, timeout_ms, and run_in_background`;
+        return `Error: shell arg "${unsupported}" is unsupported; use only command and timeout_ms`;
     }
     if (!hasOwn(a, 'command')) {
         return 'Error: shell requires "command"';
@@ -650,18 +650,18 @@ function guardShell(a) {
     if (hasOwn(a, 'timeout_ms') && (typeof a.timeout_ms !== 'number' || !Number.isFinite(a.timeout_ms) || a.timeout_ms < 0)) {
         return `Error: shell arg "timeout_ms" must be a non-negative number (got ${describeType(a.timeout_ms)})`;
     }
-    if (hasOwn(a, 'run_in_background') && typeof a.run_in_background !== 'boolean') {
-        return `Error: shell arg "run_in_background" must be a boolean (got ${describeType(a.run_in_background)})`;
-    }
     return null;
 }
 
 function guardTask(a) {
     const action = typeof a.action === 'string'
         ? a.action.trim().toLowerCase()
-        : (hasOwn(a, 'action') ? a.action : (hasOwn(a, 'task_id') ? 'status' : 'list'));
-    if (hasOwn(a, 'action') && !['list', 'status', 'read', 'check_after', 'cancel'].includes(action)) {
-        return `Error: task arg "action" must be one of list|status|read|check_after|cancel (got ${JSON.stringify(a.action)})`;
+        : (hasOwn(a, 'action') ? a.action : '');
+    if (!hasOwn(a, 'action')) {
+        return 'Error: task requires explicit "action"';
+    }
+    if (!['list', 'read', 'cancel'].includes(action)) {
+        return `Error: task arg "action" must be one of list|read|cancel (got ${JSON.stringify(a.action)})`;
     }
     if (action === 'list') return null;
     if (!hasOwn(a, 'task_id')) {
@@ -670,12 +670,6 @@ function guardTask(a) {
     if (typeof a.task_id !== 'string' || a.task_id.trim().length === 0) {
         return `Error: task arg "task_id" must be a non-empty string (got ${describeType(a.task_id)})`;
     }
-    if (action === 'check_after') {
-        if (!hasOwn(a, 'after_ms')) {
-            return 'Error: task action "check_after" requires explicit "after_ms"';
-        }
-        return checkIntInRange(a, 'after_ms', 1, 2_147_483_647);
-    }
     return null;
 }
 

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -5,7 +5,7 @@ import { delimiter as pathDelimiter } from 'node:path';
 import { join as pathJoin } from 'node:path';
 import { isLegitimateShellExit } from '../../session/result-classification.mjs';
 import { makeToolEnvelope } from '../../session/tool-envelope.mjs';
-import { acquireShellLeaseBounded, execShellCommand, stripAnsi } from '../shell-command.mjs';
+import { execShellCommand, stripAnsi } from '../shell-command.mjs';
 import { wrapCommandWithSnapshot } from '../shell-snapshot.mjs';
 import { getDestructiveCommandWarning } from '../destructive-warning.mjs';
 import { maybeRewriteWmicProcessCommand } from '../shell-policy.mjs';
@@ -13,7 +13,6 @@ import { buildBashPolicyScanTargets, checkExecPolicyMessage } from '../bash-poli
 import { markCodeGraphDirtyPaths, drainCodeGraphCache } from '../code-graph-state.mjs';
 import {
     buildJobNotFoundMessage,
-    startBackgroundShellJob,
     waitForShellJob,
     peekShellJob,
     killShellJob,
@@ -23,16 +22,13 @@ import {
     endShellJobWait,
     clearShellJobNotifyCtx,
     shellJobPublicTaskResult,
-    attachShellJobResourceLease,
 } from './shell-jobs.mjs';
 import {
     analyzeShellCommandEffects,
     buildPowerShellFilterTeePlan,
     consumeFilterTeeCapture,
     extractShellApplyPatchInvocation,
-    foregroundLongCommandHint,
     hasPowerShellOnlySyntax,
-    isAutobackgroundingAllowed,
     planInlineScriptHoist,
     preflightPowerShellHygiene,
     shellSplitSegments,
@@ -41,7 +37,6 @@ import {
     stripShellProbeWrappers,
 } from './shell-analysis.mjs';
 import {
-    cancelBackgroundTask,
     completeBackgroundTask,
     getBackgroundTask,
     registerBackgroundTask,
@@ -62,16 +57,15 @@ import { normalizeOutputPath } from './path-utils.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { applyShellEgressPolicy, scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from '../env-scrub.mjs';
-import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 import {
     findPathExecutable,
     SHELL_RUNTIME_CANDIDATES,
 } from './runtime-capabilities.mjs';
 import { planDirectExeSpawn } from './shell-direct-exe.mjs';
 
-// Claude Code assistant-mode parity: short foreground commands stay inline;
-// only work still running after the 15 s coordination budget is promoted.
-export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 15_000;
+// Commands start in the foreground. Only work still running after the
+// 10 s coordination budget is promoted to a tracked background task.
+export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 10_000;
 
 // Post-exec drift detection. After a foreground shell command, compare the
 // live mtime+size of files mixdog has already read this session against their
@@ -351,8 +345,6 @@ export async function executeBashTool(args, workDir, options = {}) {
     // never creates a second session cwd authority beside the dedicated cwd tool.
     const bashWorkDir = workDir;
     const _readStateScope = options?.readStateScope ?? options?.sessionId ?? null;
-    let runInBackground = args?.run_in_background === true;
-
     // Run hard-block policy before any shell dispatch.
     const _rawCmd = String(args && args.command != null ? args.command : '');
     // `apply_patch` typed into the shell (heredoc/argument/bare
@@ -428,25 +420,22 @@ export async function executeBashTool(args, workDir, options = {}) {
     if (_execPolicyBlock) {
         return formatShellToolFailure(_execPolicyBlock);
     }
-    // Inline-script hoisting (sync runs only — a background job would outlive
-    // the temp file). The body is written verbatim and the invocation becomes a
+    // Inline-script hoisting. The body is written verbatim and the invocation becomes a
     // file run, so the host shell never has to carry the script through its
     // quoting layer. planInlineScriptHoist refuses every case where file
     // semantics would differ, so this is a transport change only.
     let _inlineHoistPath = null;
-    if (!runInBackground) {
-        const hoist = planInlineScriptHoist(command);
-        if (hoist) {
-            try {
-                const file = pathJoin(
-                    tmpdir(),
-                    `mixdog-inline-${process.pid}-${Date.now().toString(36)}${hoist.extension}`,
-                );
-                writeFileSync(file, hoist.body, 'utf8');
-                _inlineHoistPath = file;
-                command = hoist.replace(file.replace(/\\/g, '/'));
-            } catch { _inlineHoistPath = null; }
-        }
+    const hoist = planInlineScriptHoist(command);
+    if (hoist) {
+        try {
+            const file = pathJoin(
+                tmpdir(),
+                `mixdog-inline-${process.pid}-${Date.now().toString(36)}${hoist.extension}`,
+            );
+            writeFileSync(file, hoist.body, 'utf8');
+            _inlineHoistPath = file;
+            command = hoist.replace(file.replace(/\\/g, '/'));
+        } catch { _inlineHoistPath = null; }
     }
 
     const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
@@ -468,11 +457,6 @@ export async function executeBashTool(args, workDir, options = {}) {
     // bound the blocking window when timeout promotion is available.
     const _envDefaultTimeout = parseInt(process.env.BASH_DEFAULT_TIMEOUT_MS ?? '', 10);
     const DEFAULT_BASH_TIMEOUT_MS = _envDefaultTimeout > 0 ? _envDefaultTimeout : 120_000;
-    // Background (async / run_in_background) jobs get NO omitted default: 0
-    // means "unlimited" and flows unchanged through startBackgroundShellJob →
-    // task meta (detail.timeoutMs 0). An explicit args.timeout_ms is still honored
-    // and enforced exactly as before. Sync path keeps the 120s omitted default.
-    const DEFAULT_BACKGROUND_BASH_TIMEOUT_MS = 0;
     const _envMaxTimeout = parseInt(process.env.BASH_MAX_TIMEOUT_MS ?? '', 10);
     // Foreground blocking cap when timeout promotion is available. 600s let a
     // caller-supplied 10-15 min timeout hold the conversation synchronously
@@ -481,14 +465,10 @@ export async function executeBashTool(args, workDir, options = {}) {
     // detaches as a tracked job with the REMAINDER of the explicit timeout as
     // its background deadline (user decision: 2 minutes).
     const MAX_BASH_TIMEOUT_MS = Math.max(_envMaxTimeout > 0 ? _envMaxTimeout : 120_000, DEFAULT_BASH_TIMEOUT_MS);
-    const defaultTimeoutMs = runInBackground
-        ? DEFAULT_BACKGROUND_BASH_TIMEOUT_MS
-        : DEFAULT_BASH_TIMEOUT_MS;
+    const defaultTimeoutMs = DEFAULT_BASH_TIMEOUT_MS;
     const hasExplicitTimeout = typeof args.timeout_ms === 'number' && args.timeout_ms > 0;
     const timeoutMs = hasExplicitTimeout ? args.timeout_ms : defaultTimeoutMs;
-    const backgroundOnTimeout = !runInBackground
-        && !_bgTasksDisabled
-        && isAutobackgroundingAllowed(command, resolvedSpec.shellType);
+    const backgroundOnTimeout = !_bgTasksDisabled;
     // Explicit caller timeout remains the total deadline. When promotion is
     // available, cap only its foreground blocking portion at MAX.
     // JS timers (setTimeout) and PS WaitForExit(ms) are 32-bit: a delay above
@@ -514,19 +494,11 @@ export async function executeBashTool(args, workDir, options = {}) {
     const promoteAtTimeout = backgroundOnTimeout
         && (!hasExplicitTimeout || promotedTimeoutMs > 0);
     const mergeStderr = true;
-    const longForegroundHint = foregroundLongCommandHint(
-        command,
-        timeout,
-        { run_in_background: runInBackground },
-        { backgroundTasksDisabled: _bgTasksDisabled },
-    );
-    if (longForegroundHint) return formatShellToolFailure(longForegroundHint);
     // Main-agent blocking budget. A timeout is the command's total deadline,
     // not permission to hold the conversation open for that whole duration:
-    // after 15 s a still-running command becomes a tracked background task and
+    // after 10 s a still-running command becomes a tracked background task and
     // completion is pushed to the owner. Explicit timeouts keep their remaining
-    // deadline after promotion. Never applies to run_in_background (already
-    // detached) or commands barred from backgrounding.
+    // deadline after promotion.
     // MIXDOG_SHELL_AUTO_BACKGROUND_MS overrides; an explicit 0 disables.
     const _autoBgEnvRaw = process.env.MIXDOG_SHELL_AUTO_BACKGROUND_MS;
     const _autoBgEnvMs = Number(_autoBgEnvRaw);
@@ -534,10 +506,7 @@ export async function executeBashTool(args, workDir, options = {}) {
       && Number.isFinite(_autoBgEnvMs) && _autoBgEnvMs >= 0)
       ? Math.floor(_autoBgEnvMs)
       : DEFAULT_SHELL_AUTO_BACKGROUND_MS;
-    // Gate on backgroundOnTimeout rather than just `runInBackground`: it already
-    // encodes "promotion is available for this command" (not detached, background
-    // tasks enabled, command shape allows it), so the soft threshold can never
-    // promote something the hard timeout would refuse to.
+    // Gate on backgroundOnTimeout so disabled background tasks remain foreground.
     const autoBackgroundMs = (!backgroundOnTimeout || DEFAULT_AUTO_BACKGROUND_MS <= 0)
       ? 0
       : Math.min(DEFAULT_AUTO_BACKGROUND_MS, timeout);
@@ -556,14 +525,12 @@ export async function executeBashTool(args, workDir, options = {}) {
         let execShellArg = shellArg;
         let execShellArgs = shellArgs;
         let directArgv = null;
-        const directPlan = !runInBackground
-            ? planDirectExeSpawn(command, {
-                shellType,
-                cwd: bashWorkDir,
-                pathValue: spawnEnv.PATH,
-                env: spawnEnv,
-            })
-            : null;
+        const directPlan = planDirectExeSpawn(command, {
+            shellType,
+            cwd: bashWorkDir,
+            pathValue: spawnEnv.PATH,
+            env: spawnEnv,
+        });
         // PowerShell UTF-8 prefix is PS-only: the Windows Git Bash path
         // (shellType==='posix') must NOT receive it. Snapshot wrapper stays
         // POSIX-host-only for now — no snapshot for Windows Git Bash initially.
@@ -574,14 +541,12 @@ export async function executeBashTool(args, workDir, options = {}) {
             execShellArgs = [];
             directArgv = directPlan.argv;
         } else if (process.platform === 'win32' && shellType === 'powershell') {
-            // Filter-swallow rescue (sync path only): tee the unfiltered
+            // Filter-swallow rescue: tee the unfiltered
             // producer stream of an exactly-recognized filter pipeline so a
             // failing run can attach the original output tail in THIS call
             // instead of returning `[exit code: N]` + `(no output)`. Any
             // ambiguity yields a null plan and the command runs untouched.
-            if (!runInBackground) {
-                try { _teePlan = buildPowerShellFilterTeePlan(command); } catch { _teePlan = null; }
-            }
+            try { _teePlan = buildPowerShellFilterTeePlan(command); } catch { _teePlan = null; }
             wrappedCommand = _prefixPowerShellUtf8(_teePlan ? _teePlan.command : command);
         } else if (process.platform !== 'win32' && (shell.includes('bash') || shell.includes('zsh'))) {
             try {
@@ -592,108 +557,6 @@ export async function executeBashTool(args, workDir, options = {}) {
         } else {
             wrappedCommand = command;
         }
-        if (runInBackground) {
-            let asyncAbortSignal = null;
-            try { asyncAbortSignal = (await getAbortSignalForSession(options?.sessionId)) || null; }
-            catch { asyncAbortSignal = null; }
-            const combinedAsyncAbort = _combineAbortSignals(asyncAbortSignal, options?.abortSignal || null);
-            let asyncLease = null;
-            let job;
-            try {
-                asyncLease = await acquireShellLeaseBounded(options?.resourceAdmission || resourceAdmission, {
-                    abortSignal: combinedAsyncAbort.signal,
-                    label: String(command).replace(/\s+/g, ' ').slice(0, 120),
-                    dependency: 'detached',
-                    ownerKey: options?.callerSessionId || options?.sessionId || null,
-                });
-                if (combinedAsyncAbort.signal?.aborted) {
-                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled before spawn');
-                }
-                job = await startBackgroundShellJob({
-                    command: wrappedCommand,
-                    timeoutMs: timeout,
-                    workDir: bashWorkDir,
-                    mergeStderr,
-                    spawnEnv,
-                    shell,
-                    shellArg,
-                    shellArgs,
-                    shellType,
-                    // Per-terminal session stamp: the dispatching terminal's
-                    // claude.exe pid (server-main threads callerSession.clientHostPid).
-                    clientHostPid: options?.clientHostPid,
-                    // Dispatching session: hosts that pool many sessions in one
-                    // process (desktop) scope the job to its own pane with this.
-                    ownerSessionId: options?.callerSessionId || options?.sessionId || null,
-                    ...(options?.shellJobRuntime || {}),
-                });
-                if (job && job.error) {
-                    if (job.rollbackPending && attachShellJobResourceLease(job.jobId, asyncLease, { allowUnpersisted: true })) {
-                        asyncLease = null;
-                    }
-                    return formatShellToolFailure(job.error);
-                }
-                if (combinedAsyncAbort.signal?.aborted) {
-                    try { killShellJob(job.jobId); } catch {}
-                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled before registration');
-                }
-                if (job && !job.error && attachShellJobResourceLease(job.jobId, asyncLease)) {
-                    asyncLease = null;
-                }
-                const task = registerBackgroundTask({
-                    taskId: job.jobId,
-                    surface: 'shell',
-                    operation: 'shell',
-                    label: String(command).replace(/\s+/g, ' ').slice(0, 120),
-                    input: { command, cwd: bashWorkDir },
-                    context: {
-                        notifyFn: typeof options?.notifyFn === 'function' ? options.notifyFn : null,
-                        callerSessionId: options?.callerSessionId || options?.sessionId || null,
-                        routingSessionId: options?.routingSessionId || options?.sessionId || null,
-                        clientHostPid: options?.clientHostPid,
-                    },
-                    meta: {
-                        task_id: job.jobId,
-                        pid: job.pid,
-                        stdout: normalizeOutputPath(job.stdoutPath),
-                        stderr: mergeStderr ? null : normalizeOutputPath(job.stderrPath),
-                        cwd: bashWorkDir,
-                        timeoutMs: timeout,
-                    },
-                    resultType: 'shell_task_result',
-                    cancel: () => killShellJob(job.jobId),
-                });
-                if (combinedAsyncAbort.signal?.aborted) {
-                    try { killShellJob(job.jobId); } catch {}
-                    cancelBackgroundTask(job.jobId, 'cancelled before background registration completed');
-                    throw combinedAsyncAbort.signal.reason || new Error('shell background task cancelled during registration');
-                }
-                // Wire a one-shot completion push so the dispatching session learns
-                // the background task finished (no polling tool is auto-driven).
-                try {
-                    watchBackgroundShellJob(job.jobId, {
-                        notifyFn: typeof options?.notifyFn === 'function' ? options.notifyFn : null,
-                        callerSessionId: options?.callerSessionId || options?.sessionId,
-                        routingSessionId: options?.routingSessionId,
-                        clientHostPid: options?.clientHostPid,
-                    });
-                } catch { /* watcher arm is best-effort; never blocks the spawn */ }
-                return _prependDestructiveWarning(command, [
-                    renderBackgroundTask(task),
-                    '',
-                    'You will be notified when it completes; do not poll.',
-                ].join('\n'));
-            } catch (error) {
-                if (job?.jobId && !job.error) {
-                    try { killShellJob(job.jobId); } catch {}
-                }
-                return formatShellToolFailure(normalizeErrorMessage(error instanceof Error ? error.message : String(error)));
-            } finally {
-                combinedAsyncAbort.cleanup();
-                try { await asyncLease?.release(); } catch {}
-            }
-        }
-
         let bashAbortSignal = null;
         try { bashAbortSignal = (await getAbortSignalForSession(options?.sessionId)) || null; }
         catch { bashAbortSignal = null; }
@@ -701,10 +564,8 @@ export async function executeBashTool(args, workDir, options = {}) {
         // Promote-at-timeout (CC shouldAutoBackground parity). When a
         // foreground one-shot hits its timeout and is still running, adopt it
         // as a background job (task_id + notify) instead of tree-killing it.
-        // Opt-outs restore the old kill behavior: (a) disallowed sleep-like
-        // base commands (isAutobackgroundingAllowed), (b) the truthy
-        // MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS env. Never applies to
-        // run_in_background (already detached, handled above).
+        // The truthy MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS env restores the old
+        // foreground-only behavior.
         const foregroundStartedAtMs = Date.now();
         const result = await execShellCommand({
             shell: execShell, shellArg: execShellArg, shellArgs: execShellArgs,

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -12,8 +12,8 @@ const _shellSyntaxCheat =
 export const BUILTIN_TOOLS = [
     {
         name: 'read',
-        title: 'Mixdog Read',
-        annotations: { title: 'Mixdog Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
+        title: 'Read',
+        annotations: { title: 'Read', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: false },
         description: 'Known-file contents or line ranges. Images render for viewing; not directories. Replaces cat/head/tail.',
         inputSchema: {
             type: 'object',
@@ -39,9 +39,9 @@ export const BUILTIN_TOOLS = [
     },
     {
         name: 'shell',
-        title: 'Mixdog Shell',
-        annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: 'Run programs and runtime/state operations; perform calculations, transform data, generate computed files, or inspect formats unsupported by file tools. Do not use for ordinary file-content inspection. A command that may alter source evidence may run only after a separate completed tool round has preserved the original or established verified read-only access. Tracked sync/async commands belong to the current run; only a service explicitly required after the run exits should be shell-detached (for example, nohup ... &).',
+        title: 'Shell',
+        annotations: { title: 'Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
+        description: 'Run programs, runtime/state operations, calculations, transformations, file generation, and unsupported-format inspection. After 10s, a running command returns task_id and completes by notification.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -50,7 +50,6 @@ export const BUILTIN_TOOLS = [
                     type: 'number',
                     description: 'Optional total deadline.',
                 },
-                run_in_background: { type: 'boolean', description: 'Run immediately as a tracked background task; returns task_id and sends a completion notification.' },
             },
             required: ['command'],
             additionalProperties: false,
@@ -58,24 +57,23 @@ export const BUILTIN_TOOLS = [
     },
     {
         name: 'task',
-        title: 'Background Task Control',
-        annotations: { title: 'Background Task Control', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
-        description: 'Schedule one progress check or manually inspect/cancel a shell background task_id; normal completion arrives by notification. Not for session or agent ids.',
+        title: 'Task',
+        annotations: { title: 'Task', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+        description: 'List shell tasks, read one current output snapshot, or cancel by task_id; completion arrives by notification.',
         inputSchema: {
             type: 'object',
             properties: {
-                task_id: { type: 'string', description: 'Shell task_id.' },
-                action: { type: 'string', enum: ['list', 'status', 'read', 'check_after', 'cancel'], description: 'Default list; task_id alone defaults to non-blocking status. check_after schedules one non-blocking progress notification.' },
-                after_ms: { type: 'number', description: 'Required explicitly for check_after; one-shot delay before the progress snapshot, not the task deadline.' },
+                task_id: { type: 'string', description: 'Shell task_id; required for read/cancel.' },
+                action: { type: 'string', enum: ['list', 'read', 'cancel'], description: 'list all; read snapshot; cancel task.' },
             },
-            required: [],
+            required: ['action'],
             additionalProperties: false,
         },
     },
     {
         name: 'grep',
-        title: 'Mixdog Grep',
-        annotations: { title: 'Mixdog Grep', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
+        title: 'Grep',
+        annotations: { title: 'Grep', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
         description: 'Search file contents for literal or regex matches; contextual path:line blocks are directly usable—read only omitted lines. Replaces grep/rg.',
         inputSchema: {
             type: 'object',
@@ -103,8 +101,8 @@ export const BUILTIN_TOOLS = [
     },
     {
         name: 'glob',
-        title: 'Mixdog Glob',
-        annotations: { title: 'Mixdog Glob', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
+        title: 'Glob',
+        annotations: { title: 'Glob', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
         description: 'Return wildcard-matching paths under a known base when those paths are needed. Replaces find -name.',
         inputSchema: {
             type: 'object',
@@ -126,8 +124,8 @@ export const BUILTIN_TOOLS = [
     },
     {
         name: 'find',
-        title: 'Mixdog Find Files',
-        annotations: { title: 'Mixdog Find Files', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
+        title: 'Find Files',
+        annotations: { title: 'Find Files', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
         description: 'Fuzzy filename/directory path lookup when the location itself is unknown; returns paths only. No source-content, symbol, value, or line search.',
         inputSchema: {
             type: 'object',
@@ -146,8 +144,8 @@ export const BUILTIN_TOOLS = [
     },
     {
         name: 'list',
-        title: 'Mixdog List Directory',
-        annotations: { title: 'Mixdog List Directory', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
+        title: 'List Directory',
+        annotations: { title: 'List Directory', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false, compressible: true },
         description: "Return a known directory's immediate entries (path + type) when the entry list itself is needed; not a prerequisite for another tool on that directory. No wildcard; meta:true adds size/mtime/mode.",
         inputSchema: {
             type: 'object',

package/src/runtime/agent/orchestrator/tools/builtin/shell-analysis.mjs

@@ -3,7 +3,6 @@ import { assertPathReachable, assertPathsReachable } from './fs-reachability.mjs
 import { isAbsolute, join, resolve } from 'path';
 import { tmpdir } from 'os';
 import { randomUUID } from 'crypto';
-import { WRAPPER_NAMES } from '../shell-policy.mjs';
 import {
     cwdRelativePath,
     normalizeInputPath,
@@ -830,36 +829,6 @@ export async function analyzeShellCommandEffects(command, cwd) {
     return { mutationMode: 'none', paths: [], finalCwd: localCwd };
 }
 
-// CC detectBlockedSleepPattern parity: a LEADING integer `sleep N` (or the
-// PowerShell `Start-Sleep`/`sleep` alias forms) of 2s or more is blocked
-// preflight with an instructive error instead of running and being killed at
-// its deadline. Only the first top-level segment is considered — sleeps inside
-// pipelines/subshells/scripts are legitimate pacing and pass through. Float
-// durations (sleep 0.5) are allowed, mirroring the reference CLI.
-// Explicit async execution bypasses this validation. Sync callers receive the
-// same corrective direction as the reference CLI instead of being silently
-// changed to a different execution mode.
-export function detectBlockedSleepPattern(command, minSecs = 2) {
-    const cmd = String(command || '').trim();
-    if (!cmd) return null;
-    const sep = cmd.match(/&&|\|\||;|\|/);
-    const first = (sep ? cmd.slice(0, sep.index) : cmd).trim();
-    let secs = null;
-    const posix = /^sleep\s+(\d+)\s*$/.exec(first);
-    if (posix) secs = Number.parseInt(posix[1], 10);
-    if (secs == null) {
-        const ps = /^(?:start-sleep|sleep)\s+(?:-(?:seconds|s)\s+)?(\d+)\s*$/i.exec(first);
-        if (ps) secs = Number.parseInt(ps[1], 10);
-    }
-    if (secs == null) {
-        const psMs = /^start-sleep\s+-(?:milliseconds|m)\s+(\d+)\s*$/i.exec(first);
-        if (psMs) secs = Math.floor(Number.parseInt(psMs[1], 10) / 1000);
-    }
-    if (secs == null || secs < minSecs) return null;
-    const rest = sep ? cmd.slice(sep.index).replace(/^(?:&&|\|\||;|\|)\s*/, '').trim() : '';
-    return rest ? `sleep ${secs} followed by: ${rest.slice(0, 80)}` : `standalone sleep ${secs}`;
-}
-
 // Shell interception: patch-trained models type `apply_patch <<'EOF' … EOF`
 // INTO THE SHELL. No
 // such binary exists here, so the invocation is extracted and routed to the
@@ -903,81 +872,6 @@ export function extractShellApplyPatchInvocation(command) {
     return { error: 'apply_patch requires the patch text (heredoc or single argument)' };
 }
 
-export function foregroundLongCommandHint(command, timeoutMs, args = {}, opts = {}) {
-    if (args.run_in_background === true) return '';
-    const cmd = String(command || '').trim();
-    if (!cmd) return '';
-    // CC validateInput parity: block only while background tasks are enabled —
-    // the remedy we point at (background execution / completion notification) must exist.
-    if (opts.backgroundTasksDisabled !== true) {
-        const blocked = detectBlockedSleepPattern(cmd);
-        if (blocked) {
-            return `Error: blocked — ${blocked}. Set run_in_background:true and act on the completion notification. If you genuinely need a delay (rate limiting, pacing), keep it under 2 seconds.`;
-        }
-    }
-    return '';
-}
-
-// Commands that must NOT be promoted to background on a foreground timeout —
-// they run in the foreground and are killed at their deadline instead. Mirrors
-// the reference CLI DISALLOWED_AUTO_BACKGROUND_COMMANDS: `sleep` on posix,
-// `start-sleep`/`sleep` (the PS built-in alias) on PowerShell. A `sleep`/
-// `Start-Sleep` the caller wants to survive must be launched with
-// run_in_background:true explicitly.
-const _DISALLOWED_AUTO_BACKGROUND_POSIX = ['sleep'];
-const _DISALLOWED_AUTO_BACKGROUND_PS = ['start-sleep', 'sleep'];
-
-// Whether one shell segment reaches a disallowed sleep-like command. Strips a
-// leading subshell/paren/brace/`&`, then walks tokens skipping VAR=val and
-// option flags (quotes stripped so `'Start-Sleep'` resolves). A disallowed base
-// name found anywhere reachable blocks promotion. Once a command-runner wrapper
-// (env/sudo/timeout/nice/…, shell-policy.mjs's WRAPPER_NAMES) has been seen we
-// do NOT model that wrapper's flag arity — we keep scanning EVERY later bare
-// token for a hidden `sleep`, so `sudo -u nobody sleep 5` / `setpriv --reuid
-// user sleep` are caught (erring toward NOT promoting). Without a wrapper the
-// first real command token decides the segment.
-function _segmentDisallowed(segment, disallowed) {
-    const stripped = String(segment || '').replace(/^[\s(){}&]+/, '');
-    const tokens = stripped.split(/\s+/).filter(Boolean);
-    let sawWrapper = false;
-    for (let tok of tokens) {
-        tok = tok.replace(/^['"]+|['"]+$/g, '');
-        if (!tok) continue;
-        if (/^[A-Za-z_]\w*=/.test(tok)) continue;            // VAR=val assignment
-        if (tok.startsWith('-')) continue;                    // option flag
-        const stem = tok.toLowerCase().replace(/^.*[\\/]/, '').replace(/\.exe$/, '');
-        if (disallowed.includes(stem)) return true;           // sleep reachable here
-        if (WRAPPER_NAMES.has(stem)) { sawWrapper = true; continue; }
-        if (/^\d+(?:\.\d+)?[smhd]?$/i.test(tok)) continue;    // numeric/duration arg
-        // First real command token. Without a preceding wrapper it IS the base
-        // command and it wasn't disallowed → segment is safe. With a wrapper,
-        // this may be a wrapper value arg (`sudo -u nobody …`); keep scanning
-        // for a hidden sleep instead of stopping here.
-        if (!sawWrapper) return false;
-    }
-    return false;
-}
-
-// Whether a still-running foreground one-shot may be promoted to a background
-// job when it hits its timeout (CC isAutobackgroundingAllowed analogue).
-// Scans EVERY segment of a &&/||/;/|/& chain and, per segment, peels wrappers
-// before reading the base command — so a sleep-like hidden behind a chain
-// (`cd x && sleep 5`) or a runner wrapper (`timeout 5 sleep`, `env sleep`) is
-// still caught. Errs toward NOT promoting: any disallowed base command in any
-// segment blocks promotion. shellType 'powershell' uses the PS disallow list.
-export function isAutobackgroundingAllowed(command, shellType) {
-    const cmd = String(command || '').trim();
-    if (!cmd) return true;
-    const disallowed = shellType === 'powershell'
-        ? _DISALLOWED_AUTO_BACKGROUND_PS
-        : _DISALLOWED_AUTO_BACKGROUND_POSIX;
-    const segments = cmd.split(/(?:&&|\|\||[;\n|&])/);
-    for (const seg of segments) {
-        if (_segmentDisallowed(seg, disallowed)) return false;
-    }
-    return true;
-}
-
 // ---------------------------------------------------------------------------
 // Filter-swallow rescue (PowerShell one-shot path). Measured 2026-08: ~37
 // failures/14d were `<producer> 2>&1 | Select-String … | Select-Object …`

package/src/runtime/agent/orchestrator/tools/builtin/task-tool.mjs

@@ -11,7 +11,6 @@ import {
     cancelBackgroundTask,
     completeBackgroundTask,
     getBackgroundTask,
-    notifyBackgroundTaskProgress,
     renderBackgroundTask,
     renderBackgroundTaskList,
 } from '../../../../shared/background-tasks.mjs';
@@ -54,38 +53,9 @@ function renderTaskCancelSuccess(taskId, task) {
     ].join('\n');
 }
 
-function scheduleShellProgressCheck(task, afterMs) {
-    const replaced = Boolean(task.progressCheckTimer);
-    if (task.progressCheckTimer) {
-        try { clearTimeout(task.progressCheckTimer); } catch {}
-    }
-    const scheduledAt = Date.now();
-    const timer = setTimeout(() => {
-        const current = getBackgroundTask(task.taskId);
-        if (!current || current.progressCheckTimer !== timer) return;
-        current.progressCheckTimer = null;
-        if (current.status !== 'running') return;
-        const job = peekShellJob(task.taskId);
-        if (!job || job.status !== 'running') return;
-        const snapshot = shellJobPublicTaskResult(job);
-        notifyBackgroundTaskProgress(current, {
-            text: [
-                renderBackgroundTask(current),
-                '',
-                JSON.stringify(snapshot, null, 2),
-            ].join('\n'),
-            resultType: 'shell_task_progress',
-            instruction: `The scheduled progress check for shell task ${task.taskId} is ready; inspect this snapshot and schedule another check_after only if needed.`,
-            key: `scheduled-progress-${scheduledAt}`,
-        });
-    }, afterMs);
-    if (typeof timer.unref === 'function') timer.unref();
-    task.progressCheckTimer = timer;
-    return replaced;
-}
-
 export async function executeTaskTool(args, options = {}) {
-    const action = typeof args.action === 'string' ? args.action.toLowerCase() : (args.task_id ? 'status' : 'list');
+    const action = typeof args.action === 'string' ? args.action.toLowerCase() : '';
+    if (!action) return 'Error: task action is required';
     if (action === 'list') return renderBackgroundTaskList({ context: options });
 
     const taskId = typeof args.task_id === 'string' ? args.task_id.trim() : '';
@@ -102,10 +72,16 @@ export async function executeTaskTool(args, options = {}) {
     if (!task) return `Error: task not found: ${taskId}`;
     const isShellTask = task.surface === 'shell';
 
-    if (action === 'status' || action === 'read') {
-        if (isShellTask) refreshShellTask(taskId, { includeRunning: action === 'read' });
+    if (action === 'read') {
+        if (isShellTask) refreshShellTask(taskId, { includeRunning: true });
         const latest = getBackgroundTask(taskId, { context: options }) || task;
-        return renderBackgroundTask(latest, { includeResult: action === 'read' });
+        const rendered = renderBackgroundTask(latest, { includeResult: true });
+        if (latest.status !== 'running') return rendered;
+        return [
+            rendered,
+            '',
+            'Still running. Completion will be delivered automatically; do not poll or call task again unless the user explicitly asks for another snapshot.',
+        ].join('\n');
     }
 
     if (action === 'cancel') {
@@ -120,26 +96,5 @@ export async function executeTaskTool(args, options = {}) {
         return renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task);
     }
 
-    if (action === 'check_after') {
-        if (!Number.isInteger(args.after_ms) || args.after_ms <= 0 || args.after_ms > 2_147_483_647) {
-            return 'Error: task action "check_after" requires explicit positive integer "after_ms"';
-        }
-        if (!isShellTask) return 'Error: task action "check_after" supports shell task_id values only';
-        const job = peekShellJob(taskId);
-        if (!job) return buildJobNotFoundMessage(taskId);
-        if (job.status !== 'running') {
-            refreshShellTask(taskId);
-            return renderBackgroundTask(getBackgroundTask(taskId, { context: options }) || task, { includeResult: true });
-        }
-        const replaced = scheduleShellProgressCheck(task, args.after_ms);
-        return [
-            'status: running',
-            `task_id: ${taskId}`,
-            'progress_check_scheduled: true',
-            `after_ms: ${args.after_ms}`,
-            replaced ? 'replaced_previous_check: true' : null,
-        ].filter(Boolean).join('\n');
-    }
-
-    return `Error: task action must be one of list|status|read|check_after|cancel (got ${JSON.stringify(args.action)})`;
+    return `Error: task action must be one of list|read|cancel (got ${JSON.stringify(args.action)})`;
 }

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.12",
+  "version": "0.1.13",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.12/mixdog-graph-darwin-arm64",
-      "sha256": "c8fa189949ddbcb4794f4f44a6ac355ecb520c31a23e9a94bc364baa18d9c01e"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.13/mixdog-graph-darwin-arm64",
+      "sha256": "356ddd4c591ff96f6dea32af360798568db7cf474215692a218622e25276b923"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.12/mixdog-graph-darwin-x64",
-      "sha256": "949262757f112e0bf3da58593f3b67d48192aeeb69a1e9e953cc0d553312b7c5"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.13/mixdog-graph-darwin-x64",
+      "sha256": "54cb3aaaa3c0b0d8e5d5defc4c8f6f701a2e4e574095f5d377773692ce33fbeb"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.12/mixdog-graph-linux-arm64",
-      "sha256": "a60c7ecc5bbfc7f8537b73f0184abc7d1c5414a0775b43282a99bcc4e4e23bc2"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.13/mixdog-graph-linux-arm64",
+      "sha256": "c14a2df85d881af3436dc56622fbd4a2078bd2e3d1a615a23332e92efefc7f0f"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.12/mixdog-graph-linux-x64",
-      "sha256": "919b5859ea6d74147439d4182ac3c2faf5bc30451ecfbf901276a49830bf713d"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.13/mixdog-graph-linux-x64",
+      "sha256": "c616be0a16547ea9568b487d2ca0e6e4515c9a740f27b73ec09e6bc368461b3f"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.12/mixdog-graph-win32-x64.exe",
-      "sha256": "59d9c7337f853e80575d582cfac277983eb58ef0506518d2ce768c7d2d0a0f53"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.13/mixdog-graph-win32-x64.exe",
+      "sha256": "132cab2c467800a87f0ac05cd5ef5023db8f3b0c12ad2047b5368ee49a8d1e60"
     }
   }
 }

package/src/runtime/shared/background-tasks.mjs

@@ -320,10 +320,6 @@ export function completeBackgroundTask(taskId, {
   const task = getBackgroundTask(taskId);
   if (!task) return null;
   if (TERMINAL_STATUSES.has(task.status)) return task;
-  if (task.progressCheckTimer) {
-    try { clearTimeout(task.progressCheckTimer); } catch {}
-    task.progressCheckTimer = null;
-  }
   const now = Date.now();
   task.status = normalizeStatus(status);
   task.finishedAtMs = now;

package/src/runtime/shared/tool-execution-contract.mjs

@@ -5,7 +5,7 @@ export const TOOL_ASYNC_EXECUTION_CONTRACT =
   'Runs sync inline by default; async returns a background task_id and delivers a completion notification.';
 
 export const TOOL_MANUAL_CONTROL_CONTRACT =
-  'check_after schedules one progress notification; read/status/cancel are for manual recovery.';
+  'read returns one current output snapshot; cancel is for manual recovery, while normal completion arrives by notification.';
 
 function clean(value) {
   return String(value ?? '').trim();

package/src/standalone/agent-tool/tag-registry.mjs

@@ -82,6 +82,7 @@ export function createTagRegistry({
     const add = (session, fallbackTag = '') => {
       const tag = agentTagOf(session) || clean(fallbackTag);
       if (!tag || !session?.id || session.closed === true) return;
+      if (isLeadPoolAgent(session.agent)) return;
       if (!sessionMatchesContext(session, context)) return;
       if (seen.has(session.id)) return;
       seen.add(session.id);
@@ -158,6 +159,7 @@ export function createTagRegistry({
     }
     if (!scanSessions) return;
     for (const session of mgr.listSessions({ includeClosed: false }) || []) {
+      if (isLeadPoolAgent(session?.agent)) continue;
       const tag = agentTagOf(session);
       if (!tag || tags.has(tag)) continue;
       if (!sessionMatchesContext(session, context)) continue;

package/src/standalone/agent-tool/worker-index.mjs

@@ -282,6 +282,17 @@ export function createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCw
     const rows = readWorkerRows(context);
     for (const row of rows) {
       if (!row.tag || !row.sessionId) continue;
+      if (isLeadPoolAgent(row.agent)) {
+        // Lead pool rows are status projections, not agent-tool children.
+        // Purge a projection left by older code so closeAll cannot mistake
+        // the owning desktop session for a worker and close it.
+        if (tags.get(row.tag) === row.sessionId) {
+          tags.delete(row.tag);
+          tagAgents.delete(row.tag);
+          tagCwds.delete(row.tag);
+        }
+        continue;
+      }
       tags.set(row.tag, row.sessionId);
       if (row.agent) tagAgents.set(row.tag, row.agent);
       if (row.cwd) tagCwds.set(row.tag, row.cwd);

package/src/standalone/agent-tool.mjs

@@ -450,6 +450,9 @@ export function createStandaloneAgent({
       }
       throw new Error(`agent close: target "${target}" not found`);
     }
+    if (isLeadPoolAgent(getLiveSession(sessionId)?.agent)) {
+      throw new Error(`agent close: target "${target}" is a Lead session`);
+    }
     cancelReap(sessionId);
     const tag = tagForSession(sessionId);
     forgetTerminalSession(tag, sessionId);