mixdog 0.9.40 → 0.9.43

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

@@ -344,6 +344,15 @@ function stripTrailingPatternArtifacts(v) {
     return out;
 }
 
+function coercePatternStringValues(v) {
+    const coerce = (value) => (
+        (typeof value === 'number' && Number.isFinite(value)) || typeof value === 'boolean'
+            ? String(value)
+            : value
+    );
+    return Array.isArray(v) ? v.map(coerce) : coerce(v);
+}
+
 // ---- per-tool guards ----
 
 function guardGrep(a) {
@@ -355,9 +364,10 @@ function guardGrep(a) {
     // Lossless cleanup of trailing artifacts before validation (item 5b).
     for (const k of patternKeys) {
         if (hasOwn(a, k)) {
-            a[k] = Array.isArray(a[k])
-                ? a[k].map(stripTrailingPatternArtifacts)
-                : stripTrailingPatternArtifacts(a[k]);
+            const value = coercePatternStringValues(a[k]);
+            a[k] = Array.isArray(value)
+                ? value.map(stripTrailingPatternArtifacts)
+                : stripTrailingPatternArtifacts(value);
         }
     }
 
@@ -376,6 +386,7 @@ function guardGrep(a) {
     // rg's PCRE2 engine (-P/--pcre2) when the installed rg build supports it,
     // falling back to this same error text only when PCRE2 is unavailable.
     for (const k of globKeys) {
+        if (hasOwn(a, k)) a[k] = coercePatternStringValues(a[k]);
         if (hasOwn(a, k) && !isStringOrStringArray(a[k])) {
             return `Error: grep arg "${k}" must be string or string[] (got ${describeType(a[k])})`;
         }
@@ -755,6 +766,7 @@ function guardGlob(a) {
         }
     }
     for (const k of globPatternKeys) {
+        if (hasOwn(a, k)) a[k] = coercePatternStringValues(a[k]);
         if (hasOwn(a, k) && !isStringOrStringArray(a[k])) {
             return `Error: glob arg "${k}" must be string or string[] (got ${describeType(a[k])})`;
         }

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

@@ -297,10 +297,9 @@ export async function executeBashTool(args, workDir, options = {}) {
     // Keep foreground commands on a long tool-owned timeout. The MCP dispatch
     // layer must not add a shorter fallback ceiling when timeout is omitted.
     // Reference-CLI parity (opencode/codex/claude-code): sync-first, no hard
-    // upper ceiling on a caller-provided timeout. Default 120 s (2 min) when
-    // omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides keep
-    // their semantics (max floored at default) but only bound the *omitted*
-    // default — an explicit args.timeout is honored UNCAPPED.
+    // upper ceiling on a caller-provided total timeout. Default 120 s (2 min)
+    // when omitted; BASH_DEFAULT_TIMEOUT_MS / BASH_MAX_TIMEOUT_MS env overrides
+    // 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
@@ -315,8 +314,14 @@ export async function executeBashTool(args, workDir, options = {}) {
         : DEFAULT_BASH_TIMEOUT_MS;
     const hasExplicitTimeout = typeof args.timeout === 'number' && args.timeout > 0;
     const timeoutMs = hasExplicitTimeout ? args.timeout : defaultTimeoutMs;
-    // Explicit caller timeout is uncapped (only the wmic-rewrite ceiling, when
-    // present, still bounds it); the omitted default keeps the MAX ceiling.
+    const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
+        String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
+    );
+    const backgroundOnTimeout = !runInBackground
+        && !_bgTasksDisabled
+        && isAutobackgroundingAllowed(command, resolvedSpec.shellType);
+    // 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
     // 2^31-1 wraps to a tiny/negative value and fires immediately. Clamp the
     // uncapped explicit timeout once here (~24.8 days ceiling) so every
@@ -325,11 +330,15 @@ export async function executeBashTool(args, workDir, options = {}) {
     const TIMER_MAX_MS = 2_147_483_647;
     // timeoutMs <= 0 (omitted background default) means unlimited: pass it
     // through untouched — the min() clamps below must not turn 0 into a bound.
-    const timeout = timeoutMs <= 0
+    const totalTimeout = timeoutMs <= 0
         ? 0
-        : (hasExplicitTimeout
-            ? Math.min(timeoutMs, wmicRewrite?.timeoutMs || TIMER_MAX_MS)
-            : Math.min(timeoutMs, wmicRewrite?.timeoutMs || MAX_BASH_TIMEOUT_MS));
+        : Math.min(timeoutMs, wmicRewrite?.timeoutMs || (hasExplicitTimeout ? TIMER_MAX_MS : MAX_BASH_TIMEOUT_MS));
+    const timeout = hasExplicitTimeout && backgroundOnTimeout
+        ? Math.min(totalTimeout, MAX_BASH_TIMEOUT_MS)
+        : totalTimeout;
+    const promotedTimeoutMs = hasExplicitTimeout && backgroundOnTimeout
+        ? Math.max(0, totalTimeout - timeout)
+        : 0;
     const mergeStderr = args.merge_stderr === true;
     const longForegroundHint = foregroundLongCommandHint(command, timeout, { ...args, run_in_background: runInBackground });
     if (longForegroundHint) return formatShellToolFailure(longForegroundHint);
@@ -458,12 +467,6 @@ export async function executeBashTool(args, workDir, options = {}) {
         // base commands (isAutobackgroundingAllowed), (b) the truthy
         // MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS env. Never applies to
         // run_in_background (already detached, handled above).
-        const _bgTasksDisabled = /^(1|true|yes|on)$/i.test(
-            String(process.env.MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS || '').trim(),
-        );
-        const backgroundOnTimeout = !runInBackground
-            && !_bgTasksDisabled
-            && isAutobackgroundingAllowed(command, shellType);
         const result = await execShellCommand({
             shell, shellArg, shellArgs, command: syncCommand,
             env: spawnEnv,
@@ -474,6 +477,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             // On a foreground timeout, promote the still-running child to a
             // tracked background job (unlimited) instead of killing it.
             backgroundOnTimeout,
+            promotedTimeoutMs,
             // Threaded so an auto-backgrounded foreground job is stamped with
             // the dispatching terminal's claude.exe pid (per-terminal scope).
             clientHostPid: options?.clientHostPid,
@@ -507,10 +511,7 @@ export async function executeBashTool(args, workDir, options = {}) {
                             stdout: result.stdoutPath ? normalizeOutputPath(result.stdoutPath) : null,
                             stderr: (!mergeStderr && result.stderrPath) ? normalizeOutputPath(result.stderrPath) : null,
                             cwd: bashWorkDir,
-                            // Adopted foreground jobs run unlimited (timeoutMs 0)
-                            // — matches the async default; the original
-                            // foreground timeout no longer bounds the promoted job.
-                            timeoutMs: 0,
+                            timeoutMs: result.backgroundTimeoutMs || 0,
                         },
                         resultType: 'shell_task_result',
                         cancel: () => killShellJob(result.jobId),
@@ -530,7 +531,7 @@ export async function executeBashTool(args, workDir, options = {}) {
             const lines = [
                 task ? renderBackgroundTask(task) : (result.jobId ? `[task_id: ${result.jobId}]` : null),
                 '',
-                result.backgroundMessage || 'auto-backgrounded; still running',
+                result.backgroundMessage || 'auto-backgrounded; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.',
                 partialStdout ? `\n[partial stdout]\n${partialStdout}` : '',
                 (!mergeStderr && partialStderr) ? `\n[partial stderr]\n${partialStderr}` : '',
             ].filter((l) => l !== null && l !== '');

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

@@ -83,7 +83,7 @@ export const BUILTIN_TOOLS = [
             properties: {
                 command: { type: 'string', description: 'Command.' },
                 cwd: { type: 'string', description: 'Working directory; persists across calls. Omit to reuse; absolute path changes it.' },
-                timeout: { type: 'number', description: `Timeout ms. Default ${_shellDefaultTimeoutMs()} (${_shellDefaultTimeoutMs() / 60000} min) when omitted; an explicit value is honored uncapped — long-running commands may set it higher. On timeout the command is MOVED TO BACKGROUND (a task_id you can wait/status/read/cancel) and keeps running instead of being killed; sleep-like commands and MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS opt out (killed with a [timeout] marker). async/background runs with timeout omitted have NO timeout (run until done/cancelled); an explicit timeout is still enforced.` },
+                timeout: { type: 'number', description: `Timeout ms. Default ${_shellDefaultTimeoutMs()} (${_shellDefaultTimeoutMs() / 60000} min) when omitted. On sync timeout the command is MOVED TO BACKGROUND (a task_id you can wait/status/read/cancel) and keeps running instead of being killed; an explicit timeout blocks for at most BASH_MAX_TIMEOUT_MS (default 10 min), and only its remainder beyond that cap is still enforced as a background deadline. Sleep-like commands and MIXDOG_SHELL_DISABLE_BACKGROUND_TASKS opt out (killed with a [timeout] marker after blocking for the full explicit timeout). async/background runs with timeout omitted have NO timeout (run until done/cancelled); an explicit timeout is still enforced.` },
                 merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows defaults to PowerShell; bash = Git Bash/POSIX.' },

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

@@ -773,7 +773,7 @@ export function foregroundLongCommandHint(command, timeoutMs, args = {}) {
     const longSleep = /\bsleep\s+(?:[3-9]\d|\d{3,}|\d+[mh])\b/i.test(cmd) || longPowerShellSleep;
     if (!watchLike && !longSleep) return '';
     if (!longTimeout && !watchLike && !longSleep) return '';
-    return 'Error: long foreground command detected.';
+    return 'Error: long foreground command detected. Use mode:"async" (background task) or task wait instead of blocking sleeps/watch loops.';
 }
 
 // Commands that must NOT be promoted to background on a foreground timeout —

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -500,6 +500,7 @@ export function execShellCommand({
   onProgress,
   clientHostPid,
   backgroundOnTimeout,
+  promotedTimeoutMs = 0,
 }) {
   return new Promise(async (resolve) => {
     const taskId = `shell_${randomUUID().slice(0, 8)}`;
@@ -741,9 +742,8 @@ export function execShellCommand({
     //      BACKGROUND_MS opt-in) — an EARLIER promotion before the timeout, and
     //   2. the foreground timeout deadline (backgroundOnTimeout) — the default
     //      promote-on-timeout that replaces the old tree-kill.
-    // Either way the adopted job runs UNLIMITED (timeoutMs 0, matching the
-    // async default): the original foreground timeout no longer bounds it, and
-    // the adopted-job cap poll still enforces the 100 MB output ceiling.
+    // A capped explicit foreground timeout supplies its remaining deadline to
+    // the adopted job; otherwise adoption remains unlimited as before.
     // Mutually exclusive with settle() via the autoBackgrounded flag set
     // synchronously at the top before any await.
     const _autoBackground = async ({ reason = 'threshold' } = {}) => {
@@ -754,8 +754,7 @@ export function execShellCommand({
       if (child.exitCode != null || child.signalCode != null) return;
       autoBackgrounded = true;
       // The foreground capture is over; stop the local watchdogs/timers so
-      // they cannot treeKill the now-adopted child. The adopted job runs
-      // unlimited; refreshShellJob only enforces the output cap.
+      // they cannot treeKill the now-adopted child.
       if (timer) { clearTimeout(timer); timer = null; }
       _clearProgressTimer();
       if (sizeWatchdog) { clearInterval(sizeWatchdog); sizeWatchdog = null; }
@@ -777,14 +776,13 @@ export function execShellCommand({
       const stdoutPath = taskOutput.spilled ? taskOutput.stdoutPath : null;
       const stderrPath = taskOutput.spilled ? taskOutput.stderrPath : null;
       let job = null;
+      const adoptedTimeoutMs = reason === 'timeout' ? promotedTimeoutMs : 0;
       try {
         job = adoptForegroundShellJob({
           command,
           cwd,
           pid: child.pid,
-          // Unlimited: the promoted job is no longer bounded by the foreground
-          // timeout (matches the async omitted-default behavior).
-          timeoutMs: 0,
+          timeoutMs: adoptedTimeoutMs,
           mergeStderr: false,
           stdoutPath,
           stderrPath,
@@ -854,9 +852,10 @@ export function execShellCommand({
           outputCaptureError: taskOutput.writeError,
           backgrounded: true,
           jobId,
+          backgroundTimeoutMs: adoptedTimeoutMs,
           backgroundMessage: jobId
-            ? `${_verb}; still running — completion will be delivered as a background task notification. Use task with task_id:${jobId} only for manual wait/status/read/cancel.`
-            : `${_verb}; still running`,
+            ? `${_verb}; still running. Waiting is a decision, not a default: judge from the partial output whether this will finish within your remaining budget — if progress looks slow or stalled, diagnose the cause and pursue an alternative instead of waiting. Completion will be delivered as a background task notification; use task with task_id:${jobId} only for manual wait/status/read/cancel.`
+            : `${_verb}; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.`,
         }),
       );
     };

package/src/runtime/memory/tool-defs.mjs

@@ -8,21 +8,22 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status. Use recall for retrieval. Persist with action:"core" op:"add" when: user corrects/confirms your approach, states a durable preference, or says "remember". Only what code/git/docs cannot derive; include the why. Never transient task state. No prior recall dedup needed — the cycle dedups.',
+    description: 'Core-memory mutation and status. Use recall for retrieval. Persist with action:"core" op:"add" when: user corrects/confirms your approach, states a durable preference, or says "remember". Core add/edit requires project_id + category + element + summary. Only what code/git/docs cannot derive; include the why. Never transient task state. No prior recall dedup needed — the cycle dedups.',
     inputSchema: {
       type: 'object',
       properties: {
         action: { type: 'string', enum: ['core','status'], description: 'Operation.' },
         op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
         id: { type: 'number', description: 'Exact memory id.' },
-        element: { type: 'string', description: 'Memory key/title. Max 40 chars.' },
-        summary: { type: 'string', description: 'Memory content: 1 fact, 1-2 sentences, max 100 chars.' },
+        element: { type: 'string', maxLength: 40, description: 'Memory key/title. Max 40 chars.' },
+        summary: { type: 'string', maxLength: 100, description: 'Memory content: 1 fact, 1-2 sentences, max 100 chars.' },
         category: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'], description: 'Category.' },
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
         project_id: { type: 'string', description: 'Core pool: common, slug, or *. Required for core add/edit; there is no default pool.' },
       },
+      additionalProperties: false,
       required: ['action'],
     },
   },

package/src/runtime/shared/tool-surface.mjs

@@ -514,8 +514,7 @@ export function toolWorkUnit(name, args = {}, category = '') {
     case 'memory': {
       const action = String(a.action || '').toLowerCase();
       const op = String(a.op || '').toLowerCase();
-      const isMutation = op === 'add' || op === 'edit' || op === 'delete' || op === 'promote' || op === 'dismiss'
-        || (action === 'core' && !op);
+      const isMutation = op === 'add' || op === 'edit' || op === 'delete' || op === 'promote' || op === 'dismiss';
       if (isMutation) return unitDescriptor('Memory', { count: queryCount(a, 'entries', 'items', 'memories', 'query', 'text', 'value') || 1, active: 'Writing', done: 'Wrote', noun: 'memory item' });
       return unitDescriptor('Memory', { count: queryCount(a, 'entries', 'items', 'memories', 'query', 'text', 'value') || 1, active: 'Checking', done: 'Checked', noun: 'memory item' });
     }

package/src/session-runtime/context-status.mjs

@@ -2,8 +2,10 @@ import {
   estimateRequestReserveTokens,
   estimateToolSchemaTokens,
   estimateTranscriptContextUsage,
+  contextMessagesRevision,
   resolveSessionCompactPolicy,
   summarizeContextMessages,
+  toolSchemaSignature,
 } from '../runtime/agent/orchestrator/session/context-utils.mjs';
 import { estimateToolSchemaBreakdown } from './tool-catalog.mjs';
 
@@ -16,7 +18,7 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
   let contextStatusCacheKey = null;
   let contextStatusCacheValue = null;
 
-  function contextStatusCacheKeyFor({ messages, tools }) {
+  function contextStatusCacheKeyFor({ messages, tools, messagesRevision, toolsSignature }) {
     const session = getSession();
     const route = getRoute();
     const compaction = session?.compaction || {};
@@ -30,11 +32,13 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
       mode: getMode(),
       messages,
       messageCount: messages.length,
+      messagesRevision,
       lastMessage,
       lastMessageRole: lastMessage?.role || null,
       lastMessageContent: lastMessage?.content || null,
       tools,
       toolCount: tools.length,
+      toolsSignature,
       contextWindow: session?.contextWindow || null,
       rawContextWindow: session?.rawContextWindow || null,
       effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
@@ -85,7 +89,9 @@ export function createContextStatus({ getSession, getRoute, getCurrentCwd, getMo
     const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
     const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
     const tools = Array.isArray(session?.tools) ? session.tools : [];
-    const cacheKey = contextStatusCacheKeyFor({ messages, tools });
+    const messagesRevision = contextMessagesRevision(messages);
+    const toolsSignature = toolSchemaSignature(tools);
+    const cacheKey = contextStatusCacheKeyFor({ messages, tools, messagesRevision, toolsSignature });
     if (contextStatusCacheValue && sameContextStatusCacheKey(cacheKey, contextStatusCacheKey)) {
       return contextStatusCacheValue;
     }

package/src/standalone/agent-tool/render.mjs

@@ -37,6 +37,8 @@ export function abnormalEmptyFinishError(result, agent) {
       // Only tagged for PUBLIC agents (hidden agents legitimately emit empty
       // terminal turns and are left untagged by the loop).
       return `agent '${agent}' finished without a final answer (stopReason=${stopReason ?? 'none'}, ${iterations} iterations, ${toolCallsTotal} tool calls)`;
+    case 'refusal':
+      return `agent '${agent}' response was refused by the safety classifier (${iterations} iterations, ${toolCallsTotal} tool calls)`;
     default:
       return null;
   }