mixdog 1.2.5 → 1.2.6

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

@@ -8,7 +8,7 @@ import {
 // eval), so the static cycle through session/manager.mjs is safe — same
 // pattern as loop/tool-exec.mjs.
 import { enqueuePendingMessage, markCompletionEntry } from '../../session/manager.mjs';
-import { completeBackgroundTask } from '../../../../shared/background-tasks.mjs';
+import { completeBackgroundTask, getBackgroundTask } from '../../../../shared/background-tasks.mjs';
 import {
   cancelNativeTask,
   getNativeTask,
@@ -35,29 +35,45 @@ import {
   retireShellJobRecord,
   takeReleaseRequest,
 } from './lib/shell-job-records.mjs';
-import { createProcessTreeTracker, killAfterSnapshot, watchTermination } from '../lib/shell-descendants.mjs';
+import {
+  createProcessTreeTracker,
+  killAfterSnapshot,
+  PROCESS_TABLE_READ_BOUND_MS,
+  watchTermination,
+  withinBound,
+} from '../lib/shell-descendants.mjs';
 import {
   flushPendingOwnerCancels,
+  prepareOwnedShellTreeKills,
   registerOwnedShellTree,
   unregisterOwnedShellTree,
 } from '../lib/owned-shell-trees.mjs';
 
-// Pre-kill snapshot of a tracked background job: the promotion baseline, or a
-// fresh read when that did not complete. Marks the job killed, so its settle
-// relies on this snapshot instead of an after-exit observation.
+// Bound on how long a runtime/session shutdown waits for the sweep of what a
+// cancelled job started outside its process group.
+const SHUTDOWN_TREE_CONFIRM_MS = 3_000;
+// Lead of the pre-deadline snapshot over a native timeout kill: one table
+// read's bound plus margin.
+const PRE_DEADLINE_CAPTURE_MS = PROCESS_TABLE_READ_BOUND_MS + 1_000;
+
+// Pre-kill snapshot of a tracked background job: always a fresh read, since
+// the promotion baseline predates whatever the job started since (a server,
+// an npm child); the baseline still stands when the fresh read fails. Marks
+// the job killed, so its settle relies on this snapshot instead of an
+// after-exit observation.
 function prepareTrackedKill(entry) {
   entry.killed = true;
-  if (entry.tracker.complete) return true;
-  return (entry.baseline || Promise.resolve(false)).then(
-    (complete) => complete || entry.tracker.capture().catch(() => false)
+  return (entry.baseline || Promise.resolve(false)).then(() =>
+    entry.tracker.capture().catch(() => entry.tracker.complete)
   );
 }
 import { isPidAlive } from '../../../../shared/pid-liveness.mjs';
 import {
   renderShellCompletionEnvelope,
-  renderShellCompletionNotice,
   shellCompletionInstruction,
 } from '../../../../shared/task-notification-envelope.mjs';
+import { formatDuration } from '../../../../shared/shell-output-summary.mjs';
+import { readShellTaskOutput } from './lib/shell-task-output.mjs';
 
 export { shellJobPublicTaskResult } from './lib/shell-job-insights.mjs';
 
@@ -105,7 +121,17 @@ function trackShellJobRecord(task, options) {
     adoptShellWorkspaceAdmission(jobId, hold);
   }
   const tracker = task?.cwd ? createProcessTreeTracker({ pid: task.pid }) : null;
-  const entry = { tracker, killed: false, baseline: null };
+  let resolveTerminated = null;
+  const entry = {
+    tracker,
+    killed: false,
+    baseline: null,
+    // Settles once every process of the job is confirmed gone (or the user
+    // force-released it): what `task cancel` waits on before it reports.
+    terminated: new Promise((resolve) => {
+      resolveTerminated = resolve;
+    }),
+  };
   if (tracker) {
     backgroundTrackers.set(jobId, entry);
     // Baseline identities while the promoted root is known to run, so a later
@@ -117,9 +143,24 @@ function trackShellJobRecord(task, options) {
   }
   let unsubscribe = null;
   let settled = false;
+  // The native runner enforces the job's deadline itself, with no snapshot
+  // from here: one is taken shortly before it, so the timeout kill has the
+  // identities of what the job started since its promotion.
+  const deadlineMs = Math.floor(Number(options?.timeoutMs) || 0);
+  const deadlineCapture =
+    tracker && deadlineMs > 0
+      ? setTimeout(
+          () => {
+            if (!settled) void tracker.capture().catch(() => false);
+          },
+          Math.max(0, deadlineMs - PRE_DEADLINE_CAPTURE_MS)
+        )
+      : null;
+  deadlineCapture?.unref?.();
   const settle = (detail) => {
     if (settled || !detail || detail.status === 'running') return;
     settled = true;
+    clearTimeout(deadlineCapture);
     try {
       unsubscribe?.();
     } catch {}
@@ -144,10 +185,13 @@ function trackShellJobRecord(task, options) {
       stop();
       clearTerminationHold(jobId);
       if (backgroundTrackers.get(jobId) === entry) backgroundTrackers.delete(jobId);
+      resolveTerminated(true);
       return completeShellJobRecord(jobId, normalized);
     };
     const stop = watchTermination({
       tracker,
+      // A killed job is not over while processes it started still run.
+      sweep: killed,
       onTerminated: finish,
       releaseRequested: () => takeReleaseRequest(jobId),
       onUnconfirmed: () => {
@@ -226,7 +270,18 @@ function shellJobFailureCause(detail) {
   return `exited with code ${exitCode}`;
 }
 
-export function buildShellCompletion(jobId, detail) {
+function completionStreams(detail) {
+  return {
+    stdout_path: detail?.stdoutPath || null,
+    stderr_path: detail?.mergeStderr === true ? null : detail?.stderrPath || null,
+    stdout_preview: detail?.stdoutPreview || '',
+    stderr_preview: detail?.mergeStderr === true ? '' : detail?.stderrPreview || '',
+  };
+}
+
+/** `output`: the unseen output to deliver (the task cursor's remainder). By
+ *  default the whole capture is read with a fresh cursor, consuming nothing. */
+export function buildShellCompletion(jobId, detail, { output } = {}) {
   const exitCode = typeof detail?.exitCode === 'number' ? detail.exitCode : null;
   const status = detail?.status || 'unknown';
   const taskStatus = shellJobTaskStatus(detail);
@@ -234,29 +289,36 @@ export function buildShellCompletion(jobId, detail) {
   // native task has no `error` of its own.
   const failureCause = taskStatus === 'failed' ? shellJobFailureCause(detail) : null;
   const reported = failureCause && !detail?.error ? { ...detail, error: failureCause } : detail;
+  const startedMs = Date.parse(detail?.startedAt || '');
+  const finishedMs = Date.parse(detail?.finishedAt || '');
+  // The completion carries the result itself — exit code, duration and the
+  // output (whole when short, else a summary with the log path) — so the
+  // agent never needs a follow-up read for it.
   const body = renderShellCompletionEnvelope({
     jobId,
     status: taskStatus,
     exitCode,
     command: detail?.command,
-    summary: detail?.summary || failureCause || null,
-    stdoutPreview: detail?.stdoutPreview,
-    stderrPreview: detail?.stderrPreview,
-    mergeStderr: detail?.mergeStderr,
     outputFile: detail?.stdoutPath,
     error: failureCause,
+    result: [
+      [
+        exitCode !== null ? `exit code: ${exitCode}` : null,
+        Number.isFinite(startedMs) && Number.isFinite(finishedMs)
+          ? `duration: ${formatDuration(finishedMs - startedMs)}`
+          : null,
+      ]
+        .filter(Boolean)
+        .join(', ') || null,
+      output ?? readShellTaskOutput({ status: 'completed' }, completionStreams(detail), { terminal: true }),
+    ]
+      .filter(Boolean)
+      .join('\n'),
   });
   return {
     taskStatus,
     body,
-    notification: renderShellCompletionNotice({
-      jobId,
-      status: taskStatus,
-      exitCode,
-      command: detail?.command,
-      outputFile: detail?.stdoutPath,
-      error: failureCause,
-    }),
+    notification: body,
     instruction: shellCompletionInstruction({ jobId, status, exitCode }),
     result: shellJobPublicTaskResult(reported),
     error: failureCause,
@@ -343,6 +405,15 @@ export function killShellJob(jobId) {
   return { ...attachJobInsights(normalizeShellJobDetail(detail)), killed: wasRunning };
 }
 
+/** True once every process of a tracked background job is confirmed gone,
+ *  false while any is still alive when `timeoutMs` passes. A job without a
+ *  process tracker (or one already finished) has nothing left to confirm. */
+export async function waitShellJobTerminated(jobId, timeoutMs) {
+  const entry = backgroundTrackers.get(String(jobId || ''));
+  if (!entry) return true;
+  return withinBound(entry.terminated, timeoutMs, false);
+}
+
 export function clearShellJobNotifyCtx(jobId) {
   jobNotifyCtxByJobId.delete(jobId);
 }
@@ -383,7 +454,14 @@ export function watchBackgroundShellJob(jobId, notifyCtx) {
     backgroundShellJobWatchers.delete(jobId);
     jobNotifyCtxByJobId.delete(jobId);
     const enriched = attachJobInsights(normalizeShellJobDetail(detail));
-    const completion = buildShellCompletion(jobId, enriched);
+    // The notice carries only what the agent has not seen yet: the task's
+    // cursor remainder. Kept on the task so a wait/read that reaches the
+    // finished task first returns that same remainder (and suppresses the
+    // notice) instead of an empty read.
+    const task = getBackgroundTask(jobId);
+    const output = task ? readShellTaskOutput(task, completionStreams(enriched), { terminal: true }) : undefined;
+    if (task) task.completionOutput = output;
+    const completion = buildShellCompletion(jobId, enriched, { output });
     const completedTask = completeBackgroundTask(jobId, {
       status: completion.taskStatus,
       result: completion.result,
@@ -471,7 +549,7 @@ export async function promoteForegroundShellJob({
   }
   // Added before tracking: the record's settlement removes it again.
   promotedJobIds.add(native.jobId);
-  trackShellJobRecord(native, { ownerSessionId, clientHostPid, startedAtMs: started });
+  trackShellJobRecord(native, { ownerSessionId, clientHostPid, startedAtMs: started, timeoutMs });
   return native;
 }
 
@@ -593,18 +671,26 @@ export async function shutdownShellJobs(_reason = 'runtime-close', { scope = nul
     (task) => task.status === 'running' && (!scoped || String(task.ownerSessionId || '') === ownerSessionId)
   );
   let cancelledWatchers = 0;
-  for (const task of jobs) {
-    if (cancelBackgroundShellJobWatch(task.jobId)) cancelledWatchers += 1;
-    try {
-      cancelNativeTask(task.jobId);
-    } catch {}
-    jobNotifyCtxByJobId.delete(task.jobId);
-  }
+  // Identities first, as every other kill does: once a root dies, what it
+  // started outside its process group is reparented and can no longer be
+  // found. The cancel is sent at the snapshot bound regardless.
+  await killAfterSnapshot(Promise.all(prepareOwnedShellTreeKills(scoped ? ownerSessionId : null)), () => {
+    for (const task of jobs) {
+      if (cancelBackgroundShellJobWatch(task.jobId)) cancelledWatchers += 1;
+      try {
+        cancelNativeTask(task.jobId);
+      } catch {}
+      jobNotifyCtxByJobId.delete(task.jobId);
+    }
+  });
   const settled = await Promise.all(jobs.map((task) => waitNativeTask(task.jobId, 1_200).catch(() => null)));
   // A process still running after the wait is not forgotten: it keeps being
   // stopped until its exit is confirmed.
   const unconfirmed = jobs.filter((_, index) => settled[index]?.status === 'running').map((task) => task.jobId);
   for (const jobId of unconfirmed) retryShutdownSurvivor(jobId, 1);
+  // The roots are gone; what they started outside their group is swept by
+  // each job's termination watch. Shutdown waits for that, bounded.
+  const treesGone = await Promise.all(jobs.map((task) => waitShellJobTerminated(task.jobId, SHUTDOWN_TREE_CONFIRM_MS)));
   if (scoped) {
     // The owning session is gone: nothing can query its tasks again, so
     // drop ALL of its retained state — not only the ones that happened to
@@ -624,6 +710,7 @@ export async function shutdownShellJobs(_reason = 'runtime-close', { scope = nul
     cancelledJobs: jobs.length,
     confirmedJobs: settled.filter((task) => task && task.status !== 'running').length,
     unconfirmedJobs: unconfirmed,
+    treeUnconfirmedJobs: jobs.filter((_, index) => !treesGone[index]).map((task) => task.jobId),
     cancelledWatchers,
   };
 }

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

@@ -213,6 +213,11 @@ function buildSuccessSummary(command, stdout) {
   return null;
 }
 
+// A line redrawn with `\r` shows only its last non-empty frame.
+function lastVisibleFrame(frames) {
+  return [...frames].reverse().find((frame) => frame !== '') ?? '';
+}
+
 export function foldCarriageReturnFrames(value) {
   const text = String(value ?? '');
   if (!/\r(?!\n)/.test(text)) return null;
@@ -223,12 +228,32 @@ export function foldCarriageReturnFrames(value) {
     const frames = line.split('\r');
     if (frames.length === 1) return line;
     omitted += frames.length - 1;
-    return [...frames].reverse().find((frame) => frame !== '') ?? '';
+    return lastVisibleFrame(frames);
   });
   if (!omitted) return null;
   return `${out.join('\n')}\n... [${omitted} overwritten progress frames omitted]`;
 }
 
+/** The same `\r` folding for output that arrives in chunks: the line still
+ *  open at a chunk's end keeps its state, so a progress bar redrawn across
+ *  deliveries shows its latest frame once, while plain continuation text of
+ *  that line is passed through as is. */
+export function createCarriageReturnFolder() {
+  let open = '';
+  return function fold(chunk) {
+    const lines = String(chunk ?? '')
+      .replace(/\r\n/g, '\n')
+      .split('\n');
+    const out = lines.map((line, index) => {
+      const redraw = line.includes('\r');
+      const visible = redraw ? lastVisibleFrame((index === 0 ? open + line : line).split('\r')) : line;
+      if (index === lines.length - 1) open = index === 0 && !redraw ? open + line : visible;
+      return visible;
+    });
+    return out.join('\n');
+  };
+}
+
 function hasDiagnosticHazard(value) {
   return /\b(?:errors?|warnings?|failed|failure|panic|fatal|xpass|xfailed|cancelled|todo|skipped)\b/i.test(
     String(value ?? '')

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

@@ -1,5 +1,6 @@
 import { countSplitLines } from './path-utils.mjs';
 import { TOOL_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
+import { DELIVERY_FULL_CHARS, fitPieces, shellTextPiece } from './lib/shell-delivery.mjs';
 
 const SHELL_OUTPUT_MAX_BYTES = TOOL_OUTPUT_MAX_BYTES;
 
@@ -7,11 +8,6 @@ export const SMART_BASH_MAX_LINES = 400;
 export const SMART_BASH_MAX_BYTES = TOOL_OUTPUT_MAX_BYTES;
 export const SMART_BASH_HEAD_LINES = 80;
 export const SMART_BASH_TAIL_LINES = 80;
-export const BACKGROUND_PARTIAL_OUTPUT_MAX_BYTES = 10 * 1024;
-const BACKGROUND_PARTIAL_OUTPUT_HEAD_BYTES = 2 * 1024;
-
-const BACKGROUND_PARTIAL_TRUNCATION_MARKER = '\n\n... [partial output truncated; head and tail shown] ...\n\n';
-
 function utf8Prefix(value, maxBytes) {
   const buffer = Buffer.from(String(value ?? ''), 'utf8');
   if (buffer.length <= maxBytes) return buffer.toString('utf8');
@@ -20,31 +16,20 @@ function utf8Prefix(value, maxBytes) {
   return buffer.subarray(0, end).toString('utf8');
 }
 
-function utf8Suffix(value, maxBytes) {
-  const buffer = Buffer.from(String(value ?? ''), 'utf8');
-  if (buffer.length <= maxBytes) return buffer.toString('utf8');
-  let start = buffer.length - maxBytes;
-  while (start < buffer.length && (buffer[start] & 0xc0) === 0x80) start += 1;
-  return buffer.subarray(start).toString('utf8');
-}
-
+// Partial output of a promoted command that has no task record, in the shared
+// delivery shape (lib/shell-delivery.mjs).
 export function renderBackgroundPartialOutput(stdout, stderr) {
-  const sections = [];
-  const out = String(stdout ?? '');
-  const err = String(stderr ?? '');
-  if (out) sections.push(`[partial stdout]\n${out}`);
-  if (err) sections.push(`[partial stderr]\n${err}`);
-  const merged = sections.join('\n\n');
-  if (!merged) return '';
-  if (Buffer.byteLength(merged, 'utf8') <= BACKGROUND_PARTIAL_OUTPUT_MAX_BYTES) return merged;
-
-  const markerBytes = Buffer.byteLength(BACKGROUND_PARTIAL_TRUNCATION_MARKER, 'utf8');
-  const tailBytes = BACKGROUND_PARTIAL_OUTPUT_MAX_BYTES - BACKGROUND_PARTIAL_OUTPUT_HEAD_BYTES - markerBytes;
-  return (
-    utf8Prefix(merged, BACKGROUND_PARTIAL_OUTPUT_HEAD_BYTES) +
-    BACKGROUND_PARTIAL_TRUNCATION_MARKER +
-    utf8Suffix(merged, tailBytes)
+  const streams = [
+    ['stdout', String(stdout ?? '')],
+    ['stderr', String(stderr ?? '')],
+  ].filter(([, text]) => text);
+  const headings = streams.map(([label]) => `[partial ${label}]\n`);
+  const fixed = headings.reduce((sum, heading) => sum + heading.length, 2 * Math.max(0, streams.length - 1));
+  const bodies = fitPieces(
+    streams.map(([label, text]) => shellTextPiece(text, { label })),
+    DELIVERY_FULL_CHARS - fixed
   );
+  return streams.map((_, index) => `${headings[index]}${bodies[index]}`).join('\n\n');
 }
 
 export function smartMiddleTruncate(content) {

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

@@ -9,10 +9,13 @@ import {
   shellJobPublicTaskResult,
   shellJobTaskStatus,
   waitForShellJob,
+  waitShellJobTerminated,
 } from './shell-jobs.mjs';
+import { beginSessionTaskWait } from '../../session/manager/runtime-liveness.mjs';
 import { TASK_WAIT_TIMEOUT_DEFAULT_MS, TASK_WAIT_TIMEOUT_MAX_MS, TASK_WAIT_TIMEOUT_MIN_MS } from './builtin-tools.mjs';
+import { AGENT_TASK_WAIT_DEFAULT_MS } from './wait-budgets.mjs';
 import { getAbortSignalForSession } from '../../session/abort-lookup.mjs';
-import { beginInterruptibleTaskWait } from '../../session/task-wait-control.mjs';
+import { TASK_WAIT_WAKE_NOTIFICATION, beginInterruptibleTaskWait } from '../../session/task-wait-control.mjs';
 import {
   acknowledgeBackgroundTaskCompletion,
   cancelBackgroundTask,
@@ -31,6 +34,18 @@ import { readShellTaskOutput } from './lib/shell-task-output.mjs';
 // wait returns the moment the native task settles, so this only bounds a
 // process that ignores the kill.
 const TASK_CANCEL_CONFIRM_MS = 5_000;
+// Ceiling for confirming that every process the task started is gone once its
+// root exited: a sweep is a table read, the kill and a second read (each read
+// ~1-2 s on Windows).
+const TASK_CANCEL_TREE_CONFIRM_MS = 15_000;
+
+function cancelPendingText(taskId) {
+  return [
+    'status: cancel-pending',
+    `task_id: ${taskId}`,
+    'the kill was sent and the command itself exited, but processes it started are still alive. They keep being terminated and stay tracked (the folder stays held) until they are gone; re-run task cancel or task read to check again.',
+  ].join('\n');
+}
 
 function recoveredTaskMatches(record, options = {}) {
   const context =
@@ -84,12 +99,22 @@ function renderTaskCancelSuccess(taskId, task) {
 
 // Clamp lives next to the caller; the bounds themselves are published by the
 // tool schema, so an out-of-range request is corrected rather than rejected.
-function resolveTaskWaitTimeoutMs(value) {
+function resolveTaskWaitTimeoutMs(value, defaultMs = TASK_WAIT_TIMEOUT_DEFAULT_MS) {
   const raw = Number(value);
-  if (!Number.isFinite(raw) || raw <= 0) return TASK_WAIT_TIMEOUT_DEFAULT_MS;
+  if (!Number.isFinite(raw) || raw <= 0) return defaultMs;
   return Math.min(TASK_WAIT_TIMEOUT_MAX_MS, Math.max(TASK_WAIT_TIMEOUT_MIN_MS, Math.floor(raw)));
 }
 
+// Agents run on the 5 m prompt cache, so their default wakes before it lapses;
+// the Lead keeps the 1 h cache and the longer default.
+async function defaultTaskWaitMs(sessionId) {
+  if (!sessionId) return TASK_WAIT_TIMEOUT_DEFAULT_MS;
+  const { getSession } = await import('../../session/manager.mjs');
+  const session = getSession(String(sessionId));
+  const agentOwned = session?.owner === 'agent' || session?.visibility === 'agent-only';
+  return agentOwned ? AGENT_TASK_WAIT_DEFAULT_MS : TASK_WAIT_TIMEOUT_DEFAULT_MS;
+}
+
 // Read-only counts of this runtime's shell work owned by OTHER sessions.
 // Admission is runtime-wide while task list/cancel are session-scoped, so
 // without this those holders are invisible. Counts only: another session's
@@ -128,8 +153,15 @@ async function listTasks(options) {
   return sections.join('\n');
 }
 
-// Blocks until the shell task settles, the timeout elapses, or the turn/user
-// interrupts; returns whether new user input cut the wait short.
+// Ceiling hits per still-running task, so a wait that keeps timing out on the
+// same job can suggest a different move. Keyed by the task object, so the count
+// goes with the task however it settles or is removed.
+const waitCeilingHits = new WeakMap();
+
+// Blocks until the shell task settles, the timeout elapses, the turn is
+// cancelled, or anything deliverable is queued for this session (user input,
+// steering, or any task notification: an agent or another shell job
+// finishing). Returns what cut the wait short.
 async function waitForShellTask(task, taskId, args, options) {
   // The turn's abort signal must cut the wait short; a cancelled turn
   // cannot sit out the remaining ceiling.
@@ -140,9 +172,12 @@ async function waitForShellTask(task, taskId, args, options) {
     turnSignal = null;
   }
   const waitControl = beginInterruptibleTaskWait(options?.sessionId, turnSignal);
+  const releaseWaitState = beginSessionTaskWait(options?.sessionId);
   const waitSignal = waitControl.signal;
-  const waitTimeoutMs = resolveTaskWaitTimeoutMs(args.timeout_ms);
+  const waitTimeoutMs = resolveTaskWaitTimeoutMs(args.timeout_ms, await defaultTaskWaitMs(options?.sessionId));
   let interruptedByUser = false;
+  let notified = false;
+  let notifiedTaskId = null;
   try {
     // A shell task whose descendants outlived the shell process has no
     // native job to subscribe to — the process it belonged to is gone.
@@ -175,9 +210,12 @@ async function waitForShellTask(task, taskId, args, options) {
     }
   } finally {
     interruptedByUser = waitControl.interruptedByUser;
+    notified = waitControl.wakeReason === TASK_WAIT_WAKE_NOTIFICATION;
+    notifiedTaskId = waitControl.wakeDetail;
     waitControl.dispose();
+    releaseWaitState();
   }
-  return interruptedByUser;
+  return { interruptedByUser, notified, notifiedTaskId };
 }
 
 // Outcome of a shell cancel: `outcome` is 'cancelled' only when the process is
@@ -208,6 +246,11 @@ async function cancelShellTaskOutcome(task, taskId, options) {
         ].join('\n'),
       };
     }
+    // The root exited; what it started outside its process group is swept
+    // by the job's termination watch. Cancelled means all of it is gone.
+    if (confirmed && !(await waitShellJobTerminated(taskId, TASK_CANCEL_TREE_CONFIRM_MS))) {
+      return { outcome: 'unconfirmed', text: cancelPendingText(taskId) };
+    }
     if (!confirmed) {
       // No terminal event and no observable task: absence of
       // state is not proof of termination. Stop tracking it so it
@@ -228,6 +271,10 @@ async function cancelShellTaskOutcome(task, taskId, options) {
   cancelBackgroundShellJobWatch(taskId);
   clearShellJobNotifyCtx(taskId);
   cancelBackgroundTask(taskId, 'cancelled by task control');
+  // A task whose own cancel hook kills (what a finished command left running)
+  // reports what that kill confirmed.
+  const hookKill = job ? null : await task.cancelOutcome;
+  if (hookKill && hookKill.terminated !== true) return { outcome: 'unconfirmed', text: cancelPendingText(taskId) };
   return job || wasRunning
     ? {
         outcome: 'cancelled',
@@ -323,27 +370,59 @@ export async function executeTaskTool(args, options = {}) {
 
   if (action === 'read' || action === 'wait') {
     let waitInterruptedByUser = false;
+    let waitNotified = false;
+    let notifiedTaskId = null;
     if (action === 'wait') {
       if (!isShellTask) return `Error: task wait is only available for shell tasks: ${taskId}`;
-      waitInterruptedByUser = await waitForShellTask(task, taskId, args, options);
+      ({
+        interruptedByUser: waitInterruptedByUser,
+        notified: waitNotified,
+        notifiedTaskId,
+      } = await waitForShellTask(task, taskId, args, options));
     }
     if (isShellTask) refreshShellTask(taskId, { includeRunning: true });
     const latest = getBackgroundTask(taskId, { context: options }) || task;
+    // A finished task whose completion notice is still unconsumed returns that
+    // notice's output (the unseen remainder) once; everything else reads the
+    // cursor. A wait that leaves the job running carries the progress digest.
+    const pendingCompletionOutput =
+      isShellTask &&
+      latest.status !== 'running' &&
+      latest.completionAcknowledged !== true &&
+      args.output !== 'tail' &&
+      typeof latest.completionOutput === 'string'
+        ? latest.completionOutput
+        : null;
     const visible =
       isShellTask && latest.result && typeof latest.result === 'object'
-        ? { ...latest, resultText: readShellTaskOutput(latest, latest.result, { output: args.output }) }
+        ? {
+            ...latest,
+            resultText:
+              pendingCompletionOutput ??
+              readShellTaskOutput(latest, latest.result, {
+                output: args.output,
+                digest: action === 'wait' && latest.status === 'running',
+              }),
+          }
         : latest;
     let rendered = renderBackgroundTask(visible, { includeResult: true });
     if (action === 'wait' && latest.status === 'running') {
       if (waitInterruptedByUser) {
         rendered +=
-          '\n\nWait interrupted by new user input; task still running. Handle the new message now and reply to it before waiting on this task again.';
+          '\n\nWait ended by new user input; task still running in the background. Handle the new message first.';
+      } else if (waitNotified) {
+        const from = notifiedTaskId && notifiedTaskId !== taskId ? ` (task_id: ${notifiedTaskId})` : '';
+        rendered += `\n\nWait ended because a notification arrived${from}; it is delivered to you now. This task (${taskId}) is still running in the background.`;
       } else {
+        const hits = (waitCeilingHits.get(latest) || 0) + 1;
+        waitCeilingHits.set(latest, hits);
         // In-band report cue: the static "periodic reports" rule does not
         // survive a long tool loop, so a ceiling-hit wait carries the
         // protocol reminder itself.
         rendered +=
-          '\n\nWait ceiling reached; task still running. If periodic reports were requested, write the user-facing report now, then call task wait for the next interval; otherwise continue independent work or end the turn.';
+          hits > 1
+            ? `\n\nWait ceiling reached again (${hits} times); task still running. Check whether it is progressing (task read output:tail, or the log file) and cancel it if it is stuck; otherwise continue other work — its result is delivered automatically.`
+            : '\n\nWait ceiling reached; task still running and its result is delivered automatically. If periodic reports were requested, write the user-facing report now; otherwise continue independent work or end the turn.';
       }
     }
     if (acknowledgeBackgroundTaskCompletion(taskId, { context: options })) {

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

@@ -0,0 +1,23 @@
+// The one place the shell hold and the task wait budgets are set. Every
+// schema, clamp, description and result text reads them from here.
+//
+// Shell hold: how long a foreground command may hold the tool call before it
+// moves to the background (it keeps running; completion is delivered
+// automatically). New user input ends the hold early. `wait_ms` picks a
+// different hold for one call, clamped to MIN..MAX.
+export const SHELL_HOLD_DEFAULT_MS = 60_000;
+export const SHELL_HOLD_MIN_MS = 1_000;
+export const SHELL_HOLD_MAX_MS = 600_000;
+
+// `task wait` ceiling. The wait returns the moment the task settles or new
+// user input arrives, so the ceiling only bounds a still-running task. The
+// floor stops a caller from turning wait into a busy poll. An agent's default
+// stays under the 5 m prompt-cache TTL with room for the turn's own generation
+// time, so a wait that runs to the ceiling wakes to a warm cache.
+export const TASK_WAIT_DEFAULT_MS = 300_000;
+export const AGENT_TASK_WAIT_DEFAULT_MS = 240_000;
+export const TASK_WAIT_MIN_MS = 10_000;
+export const TASK_WAIT_MAX_MS = 3_600_000;
+
+/** Whole seconds for descriptions and result text. */
+export const budgetSeconds = (ms) => Math.round(ms / 1000);