mixdog 0.9.41 → 0.9.43

package/src/runtime/agent/orchestrator/session/loop/compact-policy.mjs

@@ -3,9 +3,11 @@
 // runRecallFastTrackCompact stays in the loop (it drives the recall pipeline
 // against live session state).
 import {
+    contextMessagesSignature,
     estimateMessagesTokens,
     estimateRequestReserveTokens,
     resolveSessionCompactPolicy,
+    toolSchemaSignature,
 } from '../context-utils.mjs';
 import {
     compactTypeIsRecallFastTrack,
@@ -132,6 +134,7 @@ export function resolveWorkerCompactPolicy(sessionRef, tools) {
         reserveTokens: requestReserve + configuredReserve,
         requestReserveTokens: requestReserve,
         configuredReserveTokens: configuredReserve,
+        toolSchemaSignature: toolSchemaSignature(tools),
     };
 }
 /** Transcript + request reserve fallback used until an aligned provider baseline exists. */
@@ -159,13 +162,20 @@ function providerPressureTokens(sessionRef, usage) {
  * covers. Later pressure checks add estimates only for messages after this
  * baseline, matching Claude Code's actual-usage-plus-growth accounting.
  */
-export function recordProviderContextBaseline(sessionRef, messages, usage, { boundary = 'complete' } = {}) {
+export function recordProviderContextBaseline(sessionRef, messages, usage, {
+    boundary = 'complete',
+    sendTools = sessionRef?.tools,
+} = {}) {
     if (!sessionRef || !Array.isArray(messages)) return false;
     const tokens = providerPressureTokens(sessionRef, usage);
     if (!tokens) return false;
     sessionRef.contextPressureBaselineTokens = tokens;
     sessionRef.contextPressureBaselineOutputTokens = Math.max(0, Math.round(Number(usage?.outputTokens) || 0));
     sessionRef.contextPressureBaselineMessageCount = messages.length;
+    sessionRef.contextPressureBaselinePrefixSignature = contextMessagesSignature(messages);
+    sessionRef.contextPressureBaselineProvider = sessionRef.provider || null;
+    sessionRef.contextPressureBaselineModel = sessionRef.model || null;
+    sessionRef.contextPressureBaselineToolSignature = toolSchemaSignature(sendTools);
     // provider_send usage arrives before the response's assistant message is
     // appended. Mark that request boundary so pressure resolution skips the
     // first subsequent assistant representation: its output (including opaque
@@ -183,11 +193,15 @@ export function invalidateProviderContextBaseline(sessionRef) {
     sessionRef.contextPressureBaselineOutputTokens = null;
     sessionRef.contextPressureBaselineMessageCount = null;
     sessionRef.contextPressureBaselineBoundary = null;
+    sessionRef.contextPressureBaselinePrefixSignature = null;
+    sessionRef.contextPressureBaselineProvider = null;
+    sessionRef.contextPressureBaselineModel = null;
+    sessionRef.contextPressureBaselineToolSignature = null;
     sessionRef.contextPressureBaselineUpdatedAt = null;
     sessionRef.lastContextTokensStaleAfterCompact = true;
 }
 
-function providerBaselinePressureTokens(messages, sessionRef) {
+function providerBaselinePressureTokens(messages, sessionRef, policy) {
     if (!Array.isArray(messages) || !sessionRef
         || sessionRef.lastContextTokensStaleAfterCompact === true) return null;
     let tokens = positiveTokenInt(sessionRef.contextPressureBaselineTokens);
@@ -196,7 +210,11 @@ function providerBaselinePressureTokens(messages, sessionRef) {
     const baselineAt = Number(sessionRef.contextPressureBaselineUpdatedAt || 0);
     const compactAt = Number(sessionRef.compaction?.lastChangedAt || sessionRef.compaction?.lastCompactAt || 0);
     if (!tokens || !Number.isInteger(count) || count < 0 || count > messages.length
-        || (compactAt > 0 && baselineAt > 0 && baselineAt < compactAt)) return null;
+        || (compactAt > 0 && baselineAt > 0 && baselineAt < compactAt)
+        || sessionRef.contextPressureBaselineProvider !== (sessionRef.provider || null)
+        || sessionRef.contextPressureBaselineModel !== (sessionRef.model || null)
+        || sessionRef.contextPressureBaselineToolSignature !== policy?.toolSchemaSignature
+        || sessionRef.contextPressureBaselinePrefixSignature !== contextMessagesSignature(messages, count)) return null;
     if (sessionRef.contextPressureBaselineBoundary === 'request') {
         const assistantOffset = messages.slice(count).findIndex(message => message?.role === 'assistant');
         if (assistantOffset >= 0) {
@@ -213,14 +231,14 @@ function providerBaselinePressureTokens(messages, sessionRef) {
         const growth = count < messages.length
             ? estimateMessagesTokens(messages.slice(count))
             : 0;
-        return Math.max(0, tokens + growth);
+        return Math.max(0, tokens + growth + Math.max(0, Number(policy?.configuredReserveTokens) || 0));
     } catch {
         return null;
     }
 }
 
 export function resolveCompactionPressureTokens(messageTokensEst, policy, { messages, sessionRef } = {}) {
-    return providerBaselinePressureTokens(messages, sessionRef)
+    return providerBaselinePressureTokens(messages, sessionRef, policy)
         ?? compactPressureTokens(messageTokensEst, policy);
 }
 

package/src/runtime/agent/orchestrator/session/loop/termination.mjs

@@ -43,6 +43,9 @@ export function classifyTerminationReason(response, {
         // on its own contract.
         return 'iteration_cap';
     }
+    if (_finalStopReason === 'refusal') {
+        return 'refusal';
+    }
     if (_finalOutputLimitStop || (!_finalHasContent && _finalIncompleteStop)) {
         // Exhausted token-cap recovery is abnormal even with preserved partial
         // text. pause_turn/OTHER retain their prior non-empty completion

package/src/runtime/agent/orchestrator/session/loop/tool-exec.mjs

@@ -223,21 +223,30 @@ export async function executeTool(name, args, cwd, callerSessionId, sessionRef,
     })();
     if (typeof afterToolHook === 'function') {
         try {
+            // Tool outcome metadata is runtime-internal. Hooks receive the same
+            // model-visible result value they received before transient
+            // envelopes existed, never the envelope object itself.
+            const {
+                result: __res,
+                newMessages: __nm,
+                explicitSuccess: __explicitSuccess,
+            } = normalizeToolEnvelope(__result);
             const hookResult = await afterToolHook({
                 name,
                 args,
                 cwd,
                 sessionId: callerSessionId,
                 toolCallId: executeOpts.toolCallId || null,
-                result: __result,
+                result: __res,
             });
             // Envelope-aware hook override: a PostToolUse hook may override the
             // model-VISIBLE tool output (the envelope's `result` / stub), but it
             // must NEVER drop the `newMessages` channel. Split first, apply the
             // override to `result` only, then re-wrap so newMessages survive.
-            const { result: __res, newMessages: __nm } = normalizeToolEnvelope(__result);
             const __overridden = resolveToolResultAfterHook(__res, hookResult);
-            if (__nm.length) return makeToolEnvelope(__overridden, __nm);
+            if (__nm.length || __explicitSuccess) {
+                return makeToolEnvelope(__overridden, __nm, { explicitSuccess: __explicitSuccess });
+            }
             return __overridden;
         } catch {
             // PostToolUse hooks are best-effort; never let one break the tool result.

package/src/runtime/agent/orchestrator/session/manager/ask-session.mjs

@@ -341,7 +341,7 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                                 promptTokens: d.deltaPrompt,
                                 cachedTokens: d.deltaCachedRead,
                                 cacheWriteTokens: d.deltaCacheWrite,
-                            }, { boundary: 'request' });
+                            }, { boundary: 'request', sendTools: d.sendTools });
                         }
                         try { askOpts?.onUsageDelta?.(d); } catch {}
                     },
@@ -482,7 +482,9 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
             applyAskTerminalUsageTotals(session, result, {
                 skipTotalsIfIncremental: runtime?.usageMetricsTurnIncremental === true,
             });
-            recordProviderContextBaseline(session, session.messages, result.lastTurnUsage || result.usage);
+            recordProviderContextBaseline(session, session.messages, result.lastTurnUsage || result.usage, {
+                sendTools: result.lastSendTools,
+            });
             // Agent Runtime cache stats — record hit/miss after every successful
             // ask so the registry reflects all agent traffic, not just
             // maintenance cycles. Guarded against any agent-runtime error so

package/src/runtime/agent/orchestrator/session/result-classification.mjs

@@ -40,6 +40,8 @@
  *   "(no lines in range"    — read offset out-of-range       (builtin.mjs:739, 3571)
  *
  * @param {unknown} result
+ * @param {boolean} [explicitSuccess=false] true only when the tool handler
+ * explicitly returned `isError: false`
  * @returns {'normal' | 'error' | 'zero-match'}
  */
 const ZERO_MATCH_PREFIXES = [
@@ -56,7 +58,8 @@ const ZERO_MATCH_PREFIXES = [
     '(no lines in range',
 ];
 
-export function classifyResultKind(result) {
+export function classifyResultKind(result, explicitSuccess = false) {
+    if (explicitSuccess === true) return 'normal';
     if (typeof result !== 'string') return 'normal';
     const trimmed = result.trimStart();
     if (/^error(?:\s+\[code\b|\s*:)/i.test(trimmed) || /^\[error/i.test(trimmed) || /^\[exit code:/i.test(trimmed)) return 'error';

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -32,6 +32,11 @@ import { crossTurnSignature, crossTurnDedupStub, isEditProgressTool } from './lo
 import { getToolKind, isEagerDispatchable, parseNativeToolSearchPayload } from './loop/tool-helpers.mjs';
 import { restoreToolCallBodyForId, dropCompactedBodyArgsForId } from './loop/stored-tool-args.mjs';
 
+function classifyToolReturn(value) {
+    const normalized = normalizeToolEnvelope(value);
+    return classifyResultKind(normalized.result, normalized.explicitSuccess);
+}
+
 export async function processToolBatch(ctx) {
     const {
         calls, messages, tools, cwd, sessionId, sessionRef, signal, opts,
@@ -258,7 +263,7 @@ export async function processToolBatch(ctx) {
                     if (!settled.ok) throw settled.error;
                     result = settled.value;
                     toolEndedAt = eager.endedAt ?? Date.now();
-                    const _eagerKind = classifyResultKind(result);
+                    const _eagerKind = classifyToolReturn(result);
                     if (_eagerKind === 'error') {
                         _resultKind = 'error';
                         _executeOk = false;
@@ -286,7 +291,7 @@ export async function processToolBatch(ctx) {
                         // Boundary: tool-return string convention → structural kind.
                         // The only prefix check in this codebase; downstream layers
                         // operate on _resultKind.
-                        if (classifyResultKind(result) === 'error') {
+                        if (classifyToolReturn(result) === 'error') {
                             _resultKind = 'error';
                             _executeOk = false;
                         } else {

package/src/runtime/agent/orchestrator/session/tool-envelope.mjs

@@ -5,7 +5,8 @@
  *   - legacy: a string (or existing structured media object) — unchanged, OR
  *   - an envelope object:
  *       { __toolEnvelope: true, result: <string|structured>,
- *         newMessages: [{ role:'user', content:'...' }, ...] }
+ *         newMessages: [{ role:'user', content:'...' }, ...],
+ *         explicitSuccess?: true }
  *
  * The `__toolEnvelope` marker is deliberately namespaced so it can NEVER be
  * confused with the existing structured media content objects that
@@ -37,17 +38,18 @@ function isValidNewMessage(m) {
  * sees as the tool_result; `newMessages` are appended (as their own
  * messages, e.g. role:'user') AFTER the batch's tool results.
  */
-export function makeToolEnvelope(result, newMessages = []) {
+export function makeToolEnvelope(result, newMessages = [], options = {}) {
     return {
         [TOOL_ENVELOPE_MARKER]: true,
         result,
         newMessages: Array.isArray(newMessages) ? newMessages.filter(isValidNewMessage) : [],
+        ...(options.explicitSuccess === true ? { explicitSuccess: true } : {}),
     };
 }
 
 /**
- * Split a tool return value into `{ result, newMessages }`.
- *   - legacy string/object → { result: value, newMessages: [] }
+ * Split a tool return value into `{ result, newMessages, explicitSuccess }`.
+ *   - legacy string/object → { result: value, newMessages: [], explicitSuccess: false }
  *   - envelope             → { result, newMessages } (newMessages validated)
  */
 export function normalizeToolEnvelope(value) {
@@ -55,7 +57,7 @@ export function normalizeToolEnvelope(value) {
         const newMessages = Array.isArray(value.newMessages)
             ? value.newMessages.filter(isValidNewMessage)
             : [];
-        return { result: value.result, newMessages };
+        return { result: value.result, newMessages, explicitSuccess: value.explicitSuccess === true };
     }
-    return { result: value, newMessages: [] };
+    return { result: value, newMessages: [], explicitSuccess: false };
 }

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/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/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;
   }