mixdog 0.9.62 → 0.9.64

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

@@ -0,0 +1,212 @@
+// Generic background-task tool (status/wait/cancel), extracted from bash-tool.mjs.
+import { getAbortSignalForSession } from '../../session/abort-lookup.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';
+import { buildBashPolicyScanTargets, checkExecPolicyMessage } from '../bash-policy-scan.mjs';
+import { markCodeGraphDirtyPaths, drainCodeGraphCache } from '../code-graph-state.mjs';
+import {
+    buildJobNotFoundMessage,
+    startBackgroundShellJob,
+    waitForShellJob,
+    peekShellJob,
+    killShellJob,
+    watchBackgroundShellJob,
+    cancelBackgroundShellJobWatch,
+    beginShellJobWait,
+    endShellJobWait,
+    clearShellJobNotifyCtx,
+    shellJobPublicTaskResult,
+    attachShellJobResourceLease,
+} from './shell-jobs.mjs';
+import {
+    analyzeShellCommandEffects,
+    foregroundLongCommandHint,
+    isAutobackgroundingAllowed,
+    preflightPowerShellHygiene,
+    shellSplitSegments,
+    shellSplitPipelineSegments,
+    shellTokenize,
+    stripShellProbeWrappers,
+} from './shell-analysis.mjs';
+import {
+    cancelBackgroundTask,
+    completeBackgroundTask,
+    getBackgroundTask,
+    registerBackgroundTask,
+    renderBackgroundTask,
+    renderBackgroundTaskList,
+    resolveExecutionMode,
+} from '../../../../shared/background-tasks.mjs';
+import { resolveShellFor } from './shell-runtime.mjs';
+import { smartMiddleTruncate } from './shell-output.mjs';
+import { normalizeOutputPath } from './path-utils.mjs';
+import { normalizeErrorMessage } from './path-diagnostics.mjs';
+import { invalidateBuiltinResultCache } from './cache-layers.mjs';
+import { resolveOptionalCwd } from './cwd-utils.mjs';
+import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
+import { resolveSessionCwd, stateFilePath, wrapPowerShellWithCwdProbe, wrapBashWithCwdProbe } from '../shell-state.mjs';
+import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
+
+// Post-exec drift detection. After a foreground shell command, compare the
+// live mtime+size of files mixdog has already read this session against their
+// pre-command state (captured just before exec). Files this command changed
+// surface as ONE compact reminder so the model re-reads before editing —
+// closing the "external write -> stale old_string -> code 8" gap when shell is
+// routed through this tool. Bounded to the tracked-read set (capped) so cost
+// stays off the whole-cwd path; emits nothing when no read file changed.
+
+const TERMINAL_TASK_STATUSES = new Set(['completed', 'failed', 'cancelled']);
+
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function shellJobToTaskStatus(status) {
+    if (status === 'completed') return 'completed';
+    if (status === 'cancelled') return 'cancelled';
+    if (status === 'running') return 'running';
+    return 'failed';
+}
+
+function refreshShellTask(taskId, { includeRunning = false } = {}) {
+    const job = peekShellJob(taskId);
+    if (!job) return null;
+    const publicResult = shellJobPublicTaskResult(job);
+    if (job.status !== 'running') {
+        completeBackgroundTask(taskId, {
+            status: shellJobToTaskStatus(job.status),
+            result: publicResult,
+            resultText: JSON.stringify(publicResult, null, 2),
+            notify: false,
+        });
+    } else if (includeRunning) {
+        const task = getBackgroundTask(taskId);
+        if (task) {
+            task.result = publicResult;
+            task.resultText = JSON.stringify(publicResult, null, 2);
+        }
+    }
+    return job;
+}
+
+async function waitForGenericTask(taskId, { timeoutMs = 30_000, pollMs = 250, context = {} } = {}) {
+    const started = Date.now();
+    const deadline = started + Math.max(0, Number(timeoutMs) || 0);
+    let task = getBackgroundTask(taskId, { context });
+    if (!task) return null;
+    while (task && task.status === 'running' && Date.now() < deadline) {
+        await sleep(Math.max(25, Number(pollMs) || 250));
+        task = getBackgroundTask(taskId, { context });
+    }
+    return {
+        task,
+        waitedMs: Date.now() - started,
+        waitTimedOut: Boolean(task && task.status === 'running'),
+    };
+}
+
+function renderTaskCancelSuccess(taskId, task) {
+    const surface = task?.surface || 'task';
+    const operation = task?.operation || 'run';
+    return [
+        'status: completed',
+        `task_id: ${taskId}`,
+        `cancelled: ${surface}/${operation}`,
+    ].join('\n');
+}
+
+export async function executeTaskTool(args, options = {}) {
+    const action = typeof args.action === 'string' ? args.action.toLowerCase() : (args.task_id ? 'wait' : 'list');
+    if (action === 'list') return renderBackgroundTaskList({ context: options });
+
+    const taskId = typeof args.task_id === 'string' ? args.task_id.trim() : '';
+    if (!taskId) return 'Error: task_id is required';
+    // sess_* values are agent/orchestrator session ids, not background shell
+    // tasks. task only resolves `shell mode=async` tasks, so surface a
+    // self-correcting hint instead of the bare "task not found" that otherwise
+    // invites a wrong-tool retry loop.
+    if (/^sess_/.test(taskId)) {
+        return `Error: "${taskId}" is an agent/session id, not a background task_id. Agent tasks deliver completion notifications; use agent list/read only for manual recovery.`;
+    }
+
+    const task = getBackgroundTask(taskId, { context: 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' });
+        const latest = getBackgroundTask(taskId, { context: options }) || task;
+        return renderBackgroundTask(latest, { includeResult: action === 'read' });
+    }
+
+    if (action === 'cancel') {
+        if (isShellTask) {
+            const job = killShellJob(taskId);
+            cancelBackgroundShellJobWatch(taskId);
+            clearShellJobNotifyCtx(taskId);
+            cancelBackgroundTask(taskId, 'cancelled by task control');
+            return job ? renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task) : buildJobNotFoundMessage(taskId);
+        }
+        cancelBackgroundTask(taskId, 'cancelled by task control');
+        return renderTaskCancelSuccess(taskId, getBackgroundTask(taskId, { context: options }) || task);
+    }
+
+    if (action !== 'wait') {
+        return `Error: task action must be one of list|status|read|wait|cancel (got ${JSON.stringify(args.action)})`;
+    }
+
+    if (!isShellTask) {
+        const waited = await waitForGenericTask(taskId, {
+            timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : 30_000,
+            pollMs: typeof args.poll_ms === 'number' ? args.poll_ms : 250,
+            context: options,
+        });
+        if (!waited?.task) return `Error: task not found: ${taskId}`;
+        const rendered = renderBackgroundTask(waited.task, { includeResult: TERMINAL_TASK_STATUSES.has(waited.task.status) });
+        return waited.waitTimedOut ? `${rendered}\nwait_timed_out: true\nwaited_ms: ${waited.waitedMs}` : rendered;
+    }
+    // Register as a synchronous waiter and cancel the armed watcher BEFORE
+    // awaiting: the caller consumes the outcome via task wait, so no async
+    // push is wanted, and cancelling up front closes the race where the armed
+    // watcher (watch callback or 2s poll) fires during the await window. The
+    // persistent notify ctx survives the cancel for a possible re-arm.
+    beginShellJobWait(taskId);
+    cancelBackgroundShellJobWatch(taskId);
+    try {
+        const job = await waitForShellJob(taskId, {
+            timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : 30_000,
+            pollMs: typeof args.poll_ms === 'number' ? args.poll_ms : 250,
+        });
+        if (!job) return buildJobNotFoundMessage(taskId);
+        if (job.status !== 'running') {
+            const publicResult = shellJobPublicTaskResult(job);
+            completeBackgroundTask(taskId, {
+                status: shellJobToTaskStatus(job.status),
+                result: publicResult,
+                resultText: JSON.stringify(publicResult, null, 2),
+                notify: false,
+            });
+        }
+        const latest = getBackgroundTask(taskId, { context: options }) || task;
+        const rendered = renderBackgroundTask(latest, { includeResult: job.status !== 'running' });
+        return job.status === 'running' ? `${rendered}\nwait_timed_out: true\nwaited_ms: ${job.waitedMs}` : rendered;
+    } finally {
+        // Only the LAST concurrent waiter (post-decrement count 0) may re-arm,
+        // and only for a still-running job (timed-out wait). Re-arm with no ctx
+        // arg — watchBackgroundShellJob falls back to the persistent ctx. This
+        // prevents the concurrent-waiter double-deliver: while any other waiter
+        // is still synchronously consuming the outcome, the watcher stays off.
+        const remaining = endShellJobWait(taskId);
+        if (remaining === 0) {
+            const latest = peekShellJob(taskId);
+            if (latest && latest.status === 'running') watchBackgroundShellJob(taskId);
+            // LAST waiter out and the job already finished — the outcome was
+            // consumed synchronously, so no re-arm. Drop the persisted ctx here
+            // or it leaks (cleanup only runs on a real watcher settle, which
+            // never happens for a never-re-armed entry).
+            else clearShellJobNotifyCtx(taskId);
+        }
+    }
+}

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

@@ -334,7 +334,7 @@ function editDistance(a, b) {
     return prev[bb.length];
 }
 
-export function suggestBuiltinToolName(name) {
+function suggestBuiltinToolName(name) {
     if (typeof name !== 'string' || !name) return null;
     const canonical = canonicalizeBuiltinToolName(name);
     if (canonical !== name) return canonical;

package/src/runtime/agent/orchestrator/tools/code-graph/build.mjs

@@ -42,7 +42,6 @@ import {
   ensureDiskCodeGraphLoaded,
   drainCodeGraphCacheStrict,
   getDiskCodeGraphEntry,
-  hasLegacyDiskCodeGraphCache,
   probeDiskCodeGraphEntry,
   _setDiskCodeGraphEntry,
 } from './disk-cache.mjs';
@@ -177,23 +176,18 @@ export async function _runDiskCodeGraphFastPath({
   }
 }
 
-// A legacy single-file cache can be very large. Its migration is deliberately
-// performed by _buildCodeGraph in the Worker; probing it here would poison the
-// parent disk-cache loaded state after a synchronous JSON.parse.
 export function _prepareDiskCodeGraphFastPath({
   graphCwd,
-  hasLegacyCache = hasLegacyDiskCodeGraphCache,
   ensureDiskLoaded = ensureDiskCodeGraphLoaded,
   probeDiskEntry = probeDiskCodeGraphEntry,
   runFastPath,
 }) {
-  if (hasLegacyCache()) return runFastPath(null);
   ensureDiskLoaded();
   return runFastPath(probeDiskEntry(graphCwd, CODE_GRAPH_FAST_PATH_MAX_BYTES));
 }
 
 // Worker disk writes are debounced with an unref'd timer. Drain before sending
-// success so legacy migration persists every loaded cwd before this Worker can
+// success so every loaded cwd persists before this Worker can
 // exit; a drain failure is intentionally thrown to the worker's failure path.
 export function _postCodeGraphWorkerSuccess(
   graph,

package/src/runtime/agent/orchestrator/tools/code-graph/disk-cache.mjs

@@ -1,5 +1,5 @@
-// Per-cwd on-disk code-graph cache: manifest + <hash>.json layout, legacy
-// single-file migration, budget pruning, orphan sweep, and a debounced
+// Per-cwd on-disk code-graph cache: manifest + <hash>.json layout, stray
+// single-file cleanup, budget pruning, orphan sweep, and a debounced
 // atomic flush. Owns its own module-level state (the in-memory disk map,
 // manifest, flush timer). Extracted verbatim from code-graph.mjs.
 import { createHash } from 'node:crypto';
@@ -58,37 +58,12 @@ function _hashCwd(cwd) {
   return hash;
 }
 
-function _migrateLegacyDiskCache() {
-  const legacy = join(getPluginData(), CODE_GRAPH_DISK_FILE);
-  if (!existsSync(legacy)) return;
-  try {
-    const parsed = JSON.parse(readFileSync(legacy, 'utf8'));
-    if (parsed && typeof parsed === 'object') {
-      for (const [cwd, entry] of Object.entries(parsed)) {
-        if (!entry || typeof entry !== 'object') continue;
-        _diskCodeGraphCache.set(_canonicalGraphCwd(cwd), entry);
-      }
-    }
-    // Rename rather than delete so a rollback can recover the blob if the
-    // per-cwd layout misbehaves. Next persist round writes the new layout
-    // and the legacy path no longer exists, so this branch is a one-shot.
-    renameSync(legacy, `${legacy}.bak-${Date.now()}`);
-    // Schedule an immediate flush so the in-memory entries we just loaded
-    // get written out as per-cwd files now, instead of waiting for the
-    // next graph rebuild to trigger _setDiskCodeGraphEntry. Without this,
-    // the layout transition is half-complete (legacy renamed, new layout
-    // empty) until an unrelated build happens to land.
-    _scheduleDiskCodeGraphCacheFlush();
-  } catch (err) {
-    process.stderr.write(`[code-graph] legacy cache migration failed: ${err?.message || err}\n`);
-  }
-}
-
-// This intentionally does not call _loadDiskCodeGraphCache: the parent-side
-// fast path uses it to leave a legacy blob's synchronous read/JSON.parse to
-// the Worker, where normal one-shot migration still happens.
-export function hasLegacyDiskCodeGraphCache() {
-  return existsSync(join(getPluginData(), CODE_GRAPH_DISK_FILE));
+// The pre-layout single-file cache blob is dead weight: caches are fully
+// regenerable, so remove the stray file instead of migrating its contents.
+function _cleanupLegacyDiskCache() {
+  const stale = join(getPluginData(), CODE_GRAPH_DISK_FILE);
+  if (!existsSync(stale)) return;
+  try { unlinkSync(stale); } catch { /* best-effort */ }
 }
 
 function _pruneDiskCodeGraphEntries(_now = Date.now()) {
@@ -234,9 +209,7 @@ function _loadDiskCodeGraphCache(now = Date.now()) {
   if (_diskCodeGraphCacheLoaded) return;
   _diskCodeGraphCacheLoaded = true;
 
-  // One-shot migration from the legacy single-file cache. Subsequent boots
-  // skip this branch because the source file was renamed to .bak.
-  _migrateLegacyDiskCache();
+  _cleanupLegacyDiskCache();
 
   // Manifest-only load: per-cwd entries are picked up by _ensureCwdLoaded()
   // at lookup time. Cold start now pays a single small JSON.parse instead

package/src/runtime/agent/orchestrator/tools/code-graph/dispatch.mjs

@@ -609,10 +609,18 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
   let effectiveCwd = baseCwd;
   const baseProjectRoot = _findDirProjectRoot(baseCwd);
   const filesystemRootCwd = !baseProjectRoot && _isFilesystemRootPath(baseCwd);
-  if (filesystemRootCwd) {
+  const aggregateFilesAtBase = _collectGraphFileList(args, { cap: false });
+  const rawModeAtBase = String(args?.mode || '').trim();
+  const exactDotFederation = aggregateFilesAtBase.length === 1
+    && aggregateFilesAtBase[0] === '.'
+    && ROOT_FEDERATED_MODES.has(rawModeAtBase);
+  const parentDotFederation = !baseProjectRoot
+    && !filesystemRootCwd
+    && exactDotFederation;
+  if (filesystemRootCwd || parentDotFederation) {
     const trustedRoots = collectTrustedCodeGraphRoots(baseCwd);
-    const files = _collectGraphFileList(args, { cap: false });
-    const rawMode = String(args?.mode || '').trim();
+    const files = exactDotFederation ? [] : aggregateFilesAtBase;
+    const rawMode = rawModeAtBase;
     const canFederate = files.length > 0 || ROOT_FEDERATED_MODES.has(rawMode);
     if (files.length) {
       if (files.some((file) => _AGGREGATE_FILE_WILDCARD_RE.test(file))) {
@@ -664,6 +672,10 @@ export async function executeCodeGraphTool(name, args, cwd, signal = null, optio
     if (trustedRoots.length && canFederate) {
       const projectArgs = { ...args };
       delete projectArgs.cwd;
+      if (exactDotFederation) {
+        delete projectArgs.file;
+        delete projectArgs.files;
+      }
       const runOne = async (root, nextArgs) => executeCodeGraphTool(
         name,
         nextArgs,