mixdog 0.9.120 → 0.9.121

package/package.json

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

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

@@ -19,7 +19,8 @@
   project-relative paths and omit optional scopes equal to its root; explicit
   paths may be outside cwd only for targets outside the project.
 - Plan the fewest dependent rounds, then the fewest calls. Known state —
-  anything the task supplied, a tool returned, or a check already proved —
+  anything the task supplied, a tool returned (applied patches and envelope
+  hints included), or a check already proved —
   is never re-found, re-derived, or re-verified; a change to its subject
   re-opens it. Batch calls iff none needs
   another's output or can change another's inputs/state; otherwise
@@ -37,16 +38,23 @@
   covers only what returned spans cannot, as an anchored offset/limit
   window. A conclusive result ends its facet; evidence that determines the
   answer, edit, or deliverable ends retrieval — patch if needed.
+- Inspect read-only; writable handles, repair, or cleanup only when the
+  deliverable requires them, copying what they could destroy. Never clear
+  an obstacle or unexpected state by mutating it; unrecoverably lost
+  evidence ends its search — report best effort.
 - Once the edit or deliverable is determined, finish in one assistant turn:
   before `apply_patch`, obtain every target hunk's exact current content and
-  anchor from `grep`, `code_graph`, or `read`; never infer patch context from
+  anchor from `grep`, `code_graph`, `read`, or a prior successful patch
+  envelope; never infer patch context from
   another file, a sample, or expected text. Then issue `apply_patch` calls
   serially, never in parallel; use one cohesive call with one file section per
   target, all patches first, then their one batched verification `shell` in
   the same turn — the runtime runs it after every patch and only if all
   succeeded, so verification never needs its own turn. It runs the real
   required postconditions on every changed file and produced artifact,
-  never echoing a claim; a postcondition that did not actually run is
+  never echoing a claim; changes made through `shell` verify under the same
+  one-batch contract — one script proving every postcondition, value-level
+  included, never one check per round; a postcondition that did not actually run is
   unresolved, not passed. Retry only failed envelopes; rerun a failed check only
   after a change that can alter its outcome — commands alike; else switch
   route or report it unresolved.

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

@@ -1,6 +1,7 @@
 import { getAbortSignalForSession } from '../../session/abort-lookup.mjs';
-import { unlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
+import { accessSync, constants as fsConstants, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { constants as osConstants, tmpdir } from 'node:os';
+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';
@@ -246,10 +247,69 @@ export function _shellFailureStatus(result, timeout) {
             ? `[timeout: ${timeout}ms${signalDetail || ' signal: unknown'}${causeDetail}]${timeoutHint}`
             : (signal
                 ? `[signal: ${signal}${causeDetail}]`
-                : (exitCode !== 0 && exitCode !== null ? `[exit code: ${exitCode}]` : '')));
+                : (exitCode !== 0 && exitCode !== null ? `[exit code: ${exitCode}]${_exitClassDiagnostic(exitCode, result.stderr)}` : '')));
     return { signal, exitCode, shellToolFailed, statusDetail };
 }
 
+// Deterministic POSIX exit-class facts only (127 not-found, 126 not
+// executable, 128+N signal). Per-command meanings (grep 1 = no match, test
+// runner 1 = failures) stay uninterpreted — that would need a per-command
+// dictionary, which is banned steering. 127 additionally names verified
+// same-prefix executables actually present on PATH (fact statement, no
+// substitution suggestion) so the model skips the "then what exists?" probe.
+const _SIGNAL_NAME_BY_NUMBER = new Map(
+    Object.entries(osConstants.signals || {}).map(([name, num]) => [num, name]).reverse(),
+);
+function _missingCommandFrom(stderr) {
+    const text = String(stderr || '');
+    const m = /(?:^|\n)[^\n]*?(?:line \d+:\s*)?([A-Za-z0-9._+-]+):\s*(?:command )?not found/.exec(text)
+        || /The term '([^']+)' is not recognized/.exec(text);
+    return m ? m[1] : null;
+}
+function _pathPrefixExecutables(cmd, limit = 5) {
+    const needle = String(cmd || '').toLowerCase();
+    const hits = [];
+    if (!needle) return hits;
+    const seenDirs = new Set();
+    for (const dir of String(process.env.PATH || '').split(pathDelimiter)) {
+        if (!dir || seenDirs.has(dir)) continue;
+        seenDirs.add(dir);
+        if (seenDirs.size > 64) break;
+        let entries;
+        try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+        for (const ent of entries) {
+            if (ent.isDirectory()) continue;
+            if (!ent.name.toLowerCase().startsWith(needle)) continue;
+            if (process.platform !== 'win32') {
+                try { accessSync(pathJoin(dir, ent.name), fsConstants.X_OK); } catch { continue; }
+            }
+            hits.push(`${ent.name} (${dir.replace(/\\/g, '/')})`);
+            if (hits.length >= limit) return hits;
+        }
+    }
+    return hits;
+}
+export function _exitClassDiagnostic(exitCode, stderr) {
+    // Not gated on 127: compound chains (`a && b; c`) and pipelines mask the
+    // 127 into the chain's final code (observed as exit 1 in 6/28 bench
+    // cases), so the stderr fact decides, not the exit code.
+    {
+        const cmd = _missingCommandFrom(stderr);
+        if (cmd) {
+            const hits = _pathPrefixExecutables(cmd);
+            return hits.length
+                ? ` — '${cmd}' is not on PATH; PATH does have: ${hits.join(', ')}`
+                : ` — '${cmd}' is not on PATH and no '${cmd}*' executable exists on PATH`;
+        }
+    }
+    if (exitCode === 126) return ' — 126: command found but not executable (permission or format)';
+    if (exitCode > 128 && exitCode < 165) {
+        const name = _SIGNAL_NAME_BY_NUMBER.get(exitCode - 128);
+        if (name) return ` — 128+${exitCode - 128}: terminated by ${name}`;
+    }
+    return '';
+}
+
 export function _composeShellFailure(statusMarker, errorPrefix, warningBlock, payload) {
     return `${errorPrefix}${statusMarker}${warningBlock ? `\n${warningBlock}` : ''}\n\n${payload}`;
 }

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

@@ -76,6 +76,9 @@ export function findFileByBasename(searchRoot, fullPath, { limit = 3, maxDirs =
                 }
             }
         }
+        // Queue drained without hitting maxDirs/limit → the walk covered the
+        // whole (non-vendor, non-hidden) tree; a miss is conclusive.
+        matches.exhaustive = queue.length === 0;
         return matches;
     } catch { return []; }
 }
@@ -153,6 +156,7 @@ export function findDirectoryByBasename(searchRoot, fullPath, { limit = 3, maxDi
                 }
             }
         }
+        matches.exhaustive = queue.length === 0;
         return matches;
     } catch { return []; }
 }

package/src/runtime/agent/orchestrator/tools/builtin/search-path-diagnostics.mjs

@@ -67,6 +67,11 @@ const NOT_FOUND_CODES = new Set(['ENOENT', 'ENOTDIR']);
 
 const ENOENT_FIND_NUDGE = 'Locate with find on the basename before retrying.';
 
+// Exhaustive-scan miss: the basename BFS drained its queue (whole non-vendor,
+// non-hidden tree walked) with zero hits, so a follow-up find/list re-probe
+// cannot succeed. Declare the miss conclusive instead of nudging one.
+const ENOENT_ABSENT = ' Nothing same-named elsewhere in the project scan — treat the path as absent (create it if the task requires).';
+
 // Per-invocation memo for the ENOENT recovery fs scans. A single grep/glob
 // ENOENT surfaces the SAME missing path through tryReadFamilyEnoentRedirect
 // (resolveUniqueEnoentRedirect) AND buildNotFoundHint (which re-runs
@@ -120,7 +125,7 @@ function spaceJoinedPathHint(requestedPath) {
 
 function appendEnoentFindNudge(text = '') {
     const base = String(text || '');
-    if (base.includes(ENOENT_FIND_NUDGE)) return base;
+    if (base.includes(ENOENT_FIND_NUDGE) || base.includes(ENOENT_ABSENT)) return base;
     const sep = base.length && !/\s$/.test(base) ? ' ' : '';
     return `${base}${sep}${ENOENT_FIND_NUDGE}`;
 }
@@ -191,6 +196,7 @@ export function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'E
         if (dirHits.length === 1) {
             return ` Not found at this path; the same directory name exists at: "${normalizeOutputPath(dirHits[0])}". ${actionVerb} that path directly.`;
         }
+        const absent = elsewhere.exhaustive === true && dirHits.exhaustive === true ? ENOENT_ABSENT : '';
         const parentRel = nearestExistingParentRel(workDir, missingPath);
         if (parentRel) {
             const resolvedParent = parentRel === '.' ? workDir : resolveAgainstCwd(parentRel, workDir);
@@ -200,11 +206,12 @@ export function buildNotFoundHint(workDir, missingPath, actionVerb, errCode = 'E
                 .slice(0, 3);
             if (siblings.length) {
                 const shown = parentRel === '.' ? '.' : normalizeOutputPath(parentRel);
-                return ` Not found; under "${shown}" try: ${siblings.map((n) => `"${n}"`).join(', ')}.`;
+                return ` Not found; under "${shown}" try: ${siblings.map((n) => `"${n}"`).join(', ')}.${absent}`;
             }
         }
+        return absent;
     }
-    return '';
+    return elsewhere.exhaustive === true ? ENOENT_ABSENT : '';
 }
 
 export function relativePathPrefix(pathPrefix, workDir) {