mixdog 0.9.68 → 0.9.70

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

@@ -0,0 +1,154 @@
+// Grep output formatting: line/block normalization, context-block windowing
+// (head_limit + offset count MATCH BLOCKS, truncation keeps head+tail), the
+// pattern[] fan-out dedupe and the plain windowed renderer. Extracted from
+// search-tool.mjs, which keeps argument handling and rg execution.
+import { normalizeOutputPath } from '../path-utils.mjs';
+import {
+    groupGrepContentByFile,
+    splitGrepLineNumberOnlyPrefix,
+    splitGrepLinePrefix,
+} from '../grep-formatting.mjs';
+import { relativeGrepLine } from './search-input-helpers.mjs';
+
+export function grepMissingPatternMessage() {
+    return 'Error: grep requires pattern.';
+}
+
+export function globMissingPatternMessage() {
+    return 'Error: glob requires pattern.';
+}
+
+// --- context-mode match-block windowing (Parts 2 & 3) ---------------------
+// In context mode (explicit -A/-B/-C or content_with_context auto), head_limit
+// and offset count MATCH BLOCKS, not raw output lines, and truncation keeps a
+// head+tail slice with a middle marker instead of dropping the tail.
+function grepBlockMatchAnchor(line, filenameOmitted) {
+    if (filenameOmitted) {
+        const p = splitGrepLineNumberOnlyPrefix(line);
+        return p && p.delimiter === ':' ? `#${p.lineNo}` : '';
+    }
+    const s = splitGrepLinePrefix(line);
+    return s && s.delimiter === ':' ? `${s.path}\0${s.lineNo}` : '';
+}
+
+function parseGrepContextBlocks(lines, filenameOmitted) {
+    const blocks = [];
+    let pending = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line === '--') { pending = []; i++; continue; }
+        const anchor = grepBlockMatchAnchor(line, filenameOmitted);
+        if (anchor) {
+            const blockLines = pending.concat([line]);
+            pending = [];
+            i++;
+            while (i < lines.length) {
+                const next = lines[i];
+                if (next === '--' || grepBlockMatchAnchor(next, filenameOmitted)) break;
+                blockLines.push(next);
+                i++;
+            }
+            blocks.push({ anchor, lines: blockLines });
+            continue;
+        }
+        pending.push(line);
+        i++;
+    }
+    return blocks;
+}
+
+export function formatGrepContextOutput({ allLines, workDir, outputMode, filenameOmitted, headLimit, offset, totalKnown = true }) {
+    const norm = allLines.map((l) => (l === '--' ? '--' : relativeGrepLine(l, workDir, false, outputMode, filenameOmitted)));
+    const blocks = parseGrepContextBlocks(norm, filenameOmitted);
+    const total = blocks.length;
+    if (total === 0) return { text: '', total: 0, shown: 0, omitted: 0 };
+    // Finding 2/3: denominator is the PRE-offset grand total; on a partial rg
+    // read (stdout cap / stream cap) it is a lower bound, so print ">=T".
+    const totalStr = totalKnown ? `${total}` : `>=${total}`;
+    const afterOffset = offset > 0 ? blocks.slice(offset) : blocks;
+    if (afterOffset.length === 0) {
+        // On a partial stream (line cap / timeout) the parsed blocks are a
+        // lower bound — an offset beyond them is NOT proven past the last
+        // match, so steer toward narrowing instead of claiming "past end".
+        const text = totalKnown
+            ? `[Showing 0 of ${totalStr} matches; offset ${offset} past end]`
+            : `[Showing 0 of ${totalStr} matches (results partial); offset ${offset} is beyond the streamed window — matches past it may exist. Narrow path/glob/pattern instead of paging deeper.]`;
+        return { text, total, shown: 0, omitted: 0 };
+    }
+    const shown = headLimit === Infinity ? afterOffset.length : Math.min(headLimit, afterOffset.length);
+    const omitted = afterOffset.length - shown;
+    const render = (arr) => arr.map((b) => b.lines.join('\n'));
+    let segments;
+    let nextOffset = offset + shown;
+    if (omitted > 0 && shown > 0) {
+        // Keep head + tail so both ends of the match range stay visible.
+        const headCount = Math.max(1, Math.ceil(shown / 2));
+        const tailCount = shown - headCount;
+        const head = render(afterOffset.slice(0, headCount));
+        const tail = tailCount > 0 ? render(afterOffset.slice(afterOffset.length - tailCount)) : [];
+        segments = [...head, `…${omitted} matches omitted…`, ...tail];
+        // Paging must resume at the first OMITTED block (right after the head
+        // slice): offset+shown would permanently skip the middle blocks that
+        // the tail slice displaced. Tail blocks re-appear on later pages —
+        // duplication is acceptable, silent loss is not.
+        nextOffset = offset + headCount;
+    } else {
+        segments = render(afterOffset.slice(0, shown));
+    }
+    const notice = (omitted > 0 || !totalKnown)
+        ? `\n[Showing ${shown} of ${totalStr} matches${totalKnown ? '' : ' (results partial)'}; pass offset:${nextOffset} for more]`
+        : '';
+    return { text: segments.join('\n--\n') + notice, total, shown, omitted };
+}
+
+// Part 1: drop path:line match lines already emitted by an earlier pattern in
+// a pattern[] fan-out. Context ('-') lines and non-match lines pass through.
+export function dedupeFanoutMatchLines(body, seen) {
+    const text = String(body);
+    if (/^Error:/.test(text)) return text;
+    const out = [];
+    for (const line of text.split('\n')) {
+        const s = splitGrepLinePrefix(line);
+        if (s && s.delimiter === ':') {
+            const key = `${s.path}\0${s.lineNo}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+        }
+        out.push(line);
+    }
+    return out.join('\n');
+}
+
+export function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offset, outputMode, patterns: _patterns, beforeN, afterN, contextN, searchPath, grepResolvedPath: _grepResolvedPath, workDir, globPatterns: _globPatterns, fileType: _fileType, filenameOmitted = false, prefix = '', broadAdvisory: _broadAdvisory = true, disableContentGrouping = false }) {
+    const lines = headLimit === Infinity ? windowed : windowed.slice(0, headLimit);
+    const normalized = lines.map((line) => relativeGrepLine(line, workDir, outputMode === 'files_with_matches', outputMode, filenameOmitted));
+    const remaining = Math.max(0, totalWindowed - lines.length);
+    const shown = lines.length;
+    // Finding 3: PRE-offset grand total so the denominator matches the
+    // context-mode notice (offset==0 leaves this unchanged).
+    const total = offset + totalWindowed;
+    const scopePath = JSON.stringify(normalizeOutputPath(searchPath));
+    const truncated = (remaining > 0 || !totalKnown)
+        ? (totalKnown
+            ? `\n[Showing ${shown} of ${total} results; pass offset:${offset + shown} for more]`
+            : `\n[Showing ${shown} (more matches exist — use output_mode:'count' for the exact total on ${scopePath}); pass offset:${offset + shown} for more]`)
+        : '';
+
+    let countSummary = '';
+    if (outputMode === 'count') {
+        let totalMatches = 0;
+        let fileCount = 0;
+        for (const line of normalized) {
+            const m = line.match(/(?:^|:)(\d+)$/);
+            if (m) { totalMatches += Number(m[1]); fileCount++; }
+        }
+        countSummary = `\n[total ${totalMatches} match${totalMatches === 1 ? '' : 'es'} across ${fileCount} file${fileCount === 1 ? '' : 's'}]`;
+    }
+    const hasContext = (beforeN > 0 || afterN > 0 || contextN > 0);
+    const groupedBody = (outputMode === 'content' && !hasContext && !filenameOmitted && !disableContentGrouping)
+        ? groupGrepContentByFile(normalized)
+        : normalized.join('\n');
+    const body = groupedBody + truncated + countSummary;
+    return `${prefix}${body}`;
+}

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

@@ -141,13 +141,10 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
     }
     // Image files (png/jpg/jpeg/gif/webp): return an MCP image block so the
     // model can actually SEE the image. native Read does this, but mixdog's
-    // Read is shim-blocked, so this is the only image-view path. Single string
-    // path only — batch and head/tail/count modes stay text.
-    // options.mediaTextOnly is set by the batch dispatcher (child reads are
-    // assembled into a flat string), so an image content-block object would
-    // stringify to "[object Object]". Skip the image fast-path in that context
-    // and let the file fall through to the normal text/binary read, which
-    // emits a string. Scalar reads (no mediaTextOnly) get the rich image block.
+    // Read is shim-blocked, so this is the only image-view path. Batch children
+    // opt into this rich path for full image reads and the parent flattens each
+    // child's content parts into one structured result. mediaTextOnly remains
+    // available for callers that explicitly require a flat text result.
     if (options?.mediaTextOnly !== true && typeof args.path === 'string' && imageMimeForPath(args.path)) {
         const _imgNorm = normalizeInputPath(args.path);
         // W1 H: device-file / UNC / Windows-device / ADS guards must run
@@ -325,13 +322,17 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
                 const readEntry = _diskWin
                     ? { ...entry, offset: _diskWin.offset, limit: _diskWin.limit }
                     : entry;
-                // mediaTextOnly: a batch aggregate is assembled as a flat
-                // string (String(r.body) + join), so media branches must
-                // return text (pdf-parse text / notebook text), never a
-                // document/image content-block object that would stringify to
-                // "[object Object]" and drop the payload. Scalar reads (the
-                // single-file path below) keep the rich block shapes.
-                const body = await executeChildBuiltinTool('read', readEntry, workDir, { suppressReadUnchangedStub: true, mediaTextOnly: true, _skipReachPreflight: true });
+                // Full image children retain their rich blocks; the aggregate
+                // assembler below flattens them without stringification.
+                // Other media (PDF/notebook) remains text-only in a batch so
+                // its existing per-entry rendering contract is unchanged.
+                const richImage = (!readEntry.mode || readEntry.mode === 'full')
+                    && !!imageMimeForPath(readEntry.path);
+                const body = await executeChildBuiltinTool('read', readEntry, workDir, {
+                    suppressReadUnchangedStub: true,
+                    mediaTextOnly: !richImage,
+                    _skipReachPreflight: true,
+                });
                 results[index] = { path: entry.path, mode: entry.mode || 'full', n: entry.n, body };
             };
             const key = entry.path || `#missing-${index}`;
@@ -363,7 +364,7 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
                 const origLimit = typeof orig._origLimit === 'number'
                     ? orig._origLimit
                     : 2000;
-                const body = needsSlice
+                const body = needsSlice && typeof r.body === 'string'
                     ? sliceReadBodyByLines(r.body, origOffset, origLimit)
                     : r.body;
                 return { ...r, mode: orig.mode || 'full', n: orig.n, body };
@@ -411,6 +412,24 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
                 });
             }
         }
+        const richPartsFor = (value) => (
+            value
+            && typeof value === 'object'
+            && !Array.isArray(value)
+            && Array.isArray(value.content)
+        ) ? value.content : null;
+        const bodyTextFor = (value) => {
+            const parts = richPartsFor(value);
+            if (!parts) return String(value || '');
+            return parts
+                .map((part) => (part && typeof part === 'object' && typeof part.text === 'string') ? part.text : '')
+                .filter(Boolean)
+                .join('\n');
+        };
+        const bodyFailed = (value) => (
+            value?.isError === true
+            || classifyResultKind(bodyTextFor(value)) === 'error'
+        );
         // Header path → forward slash; error bodies already normalised
         // inside the read case's catch blocks. When `read` emitted a
         // smart-cap marker, surface the truncation state in the header
@@ -423,14 +442,14 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
             }
         }
         const summaryLine = summaries.length ? ` ${summaries.join('; ')}` : '';
-        const failedReads = orderedResults.filter((r) => classifyResultKind(String(r.body || '')) === 'error').length;
+        const failedReads = orderedResults.filter((r) => bodyFailed(r.body)).length;
         // reject_partial:true — when the caller asked for all-or-none,
         // refuse to return a mixed payload that downstream parsers
         // would have to disambiguate per-entry.
         if (failedReads > 0 && args.reject_partial === true) {
             const reasons = orderedResults
-                .filter((r) => classifyResultKind(String(r.body || '')) === 'error')
-                .map((r) => `${normalizeOutputPath(r.path)}: ${String(r.body || '').split('\n')[0]}`)
+                .filter((r) => bodyFailed(r.body))
+                .map((r) => `${normalizeOutputPath(r.path)}: ${bodyTextFor(r.body).split('\n')[0] || 'structured media read failed'}`)
                 .join('; ');
             return `Error: batch read rejected (${failedReads} of ${orderedResults.length} failed; reject_partial:true) — ${reasons}`;
         }
@@ -442,6 +461,47 @@ export async function executeReadTool(args, workDir, readStateScope, executeChil
         const header = failedReads > 0
             ? `read ${orderedResults.length} (${failedReads} failed)${summaryLine}`
             : `read ${orderedResults.length}${summaryLine}`;
+        const hasRichBodies = orderedResults.some((r) => richPartsFor(r.body) !== null);
+        if (hasRichBodies) {
+            const content = [{ type: 'text', text: header }];
+            const seenTextEntryBody = new Map();
+            const seenRichEntryBody = new WeakMap();
+            for (let i = 0; i < orderedResults.length; i++) {
+                const r = orderedResults[i];
+                const path = normalizeOutputPath(r.path);
+                const mode = r.n !== undefined ? `${r.mode} n=${r.n}` : r.mode;
+                const status = bodyFailed(r.body) ? 'error' : 'ok';
+                const textBody = bodyTextFor(r.body);
+                const match = /\[TRUNCATED (?:—|-) file is (\d+) lines \/ (\d+) KB\./.exec(textBody);
+                const suffix = match ? ` (truncated ${match[1]}L/${match[2]}KB)` : '';
+                const entryHeader = `${path} [${mode}] [${status}]${suffix}`;
+                const richParts = richPartsFor(r.body);
+                let priorIdx;
+                if (richParts) {
+                    let seenByKey = seenRichEntryBody.get(r.body);
+                    if (!seenByKey) {
+                        seenByKey = new Map();
+                        seenRichEntryBody.set(r.body, seenByKey);
+                    }
+                    const key = JSON.stringify([path, mode]);
+                    priorIdx = seenByKey.get(key);
+                    if (priorIdx === undefined) seenByKey.set(key, i);
+                } else {
+                    const key = JSON.stringify([path, mode, r.body || '']);
+                    priorIdx = seenTextEntryBody.get(key);
+                    if (priorIdx === undefined) seenTextEntryBody.set(key, i);
+                }
+                if (priorIdx !== undefined) {
+                    content.push({ type: 'text', text: `${entryHeader} [= entry #${priorIdx + 1}, identical result omitted]` });
+                    continue;
+                }
+                content.push({ type: 'text', text: entryHeader });
+                if (richParts) content.push(...richParts);
+                else content.push({ type: 'text', text: String(r.body || '') });
+            }
+            if (args._batchCapNote) content.push({ type: 'text', text: args._batchCapNote });
+            return { content };
+        }
         // Identical-entry dedup: when the caller puts the exact same window
         // twice in the path array, coalesceObjectReadEntries already merges
         // the disk read, but the 1:1 request/response contract still renders

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

@@ -49,11 +49,8 @@ import {
 import { runRg, runRgWindowedLines, rgSupportsPcre2 } from './rg-runner.mjs';
 import { markScopedCacheIncomplete } from '../../session/cache/scoped-cache-outcome.mjs';
 import {
-    groupGrepContentByFile,
     normalizeGrepLine,
     splitGrepCountPrefix,
-    splitGrepLinePrefix,
-    splitGrepLineNumberOnlyPrefix,
 } from './grep-formatting.mjs';
 import {
     cacheGet,
@@ -95,148 +92,16 @@ const GREP_AUTO_CONTEXT_LINES = 25;
 // each into its own --glob. Brace patterns ("*.{ts,tsx}") are left intact so
 // their internal commas are not torn apart.
 
-function grepMissingPatternMessage() {
-    return 'Error: grep requires pattern.';
-}
-
-function globMissingPatternMessage() {
-    return 'Error: glob requires pattern.';
-}
-
-// --- context-mode match-block windowing (Parts 2 & 3) ---------------------
-// In context mode (explicit -A/-B/-C or content_with_context auto), head_limit
-// and offset count MATCH BLOCKS, not raw output lines, and truncation keeps a
-// head+tail slice with a middle marker instead of dropping the tail.
-function grepBlockMatchAnchor(line, filenameOmitted) {
-    if (filenameOmitted) {
-        const p = splitGrepLineNumberOnlyPrefix(line);
-        return p && p.delimiter === ':' ? `#${p.lineNo}` : '';
-    }
-    const s = splitGrepLinePrefix(line);
-    return s && s.delimiter === ':' ? `${s.path}\0${s.lineNo}` : '';
-}
-
-function parseGrepContextBlocks(lines, filenameOmitted) {
-    const blocks = [];
-    let pending = [];
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i];
-        if (line === '--') { pending = []; i++; continue; }
-        const anchor = grepBlockMatchAnchor(line, filenameOmitted);
-        if (anchor) {
-            const blockLines = pending.concat([line]);
-            pending = [];
-            i++;
-            while (i < lines.length) {
-                const next = lines[i];
-                if (next === '--' || grepBlockMatchAnchor(next, filenameOmitted)) break;
-                blockLines.push(next);
-                i++;
-            }
-            blocks.push({ anchor, lines: blockLines });
-            continue;
-        }
-        pending.push(line);
-        i++;
-    }
-    return blocks;
-}
-
-function formatGrepContextOutput({ allLines, workDir, outputMode, filenameOmitted, headLimit, offset, totalKnown = true }) {
-    const norm = allLines.map((l) => (l === '--' ? '--' : relativeGrepLine(l, workDir, false, outputMode, filenameOmitted)));
-    const blocks = parseGrepContextBlocks(norm, filenameOmitted);
-    const total = blocks.length;
-    if (total === 0) return { text: '', total: 0, shown: 0, omitted: 0 };
-    // Finding 2/3: denominator is the PRE-offset grand total; on a partial rg
-    // read (stdout cap / stream cap) it is a lower bound, so print ">=T".
-    const totalStr = totalKnown ? `${total}` : `>=${total}`;
-    const afterOffset = offset > 0 ? blocks.slice(offset) : blocks;
-    if (afterOffset.length === 0) {
-        // On a partial stream (line cap / timeout) the parsed blocks are a
-        // lower bound — an offset beyond them is NOT proven past the last
-        // match, so steer toward narrowing instead of claiming "past end".
-        const text = totalKnown
-            ? `[Showing 0 of ${totalStr} matches; offset ${offset} past end]`
-            : `[Showing 0 of ${totalStr} matches (results partial); offset ${offset} is beyond the streamed window — matches past it may exist. Narrow path/glob/pattern instead of paging deeper.]`;
-        return { text, total, shown: 0, omitted: 0 };
-    }
-    const shown = headLimit === Infinity ? afterOffset.length : Math.min(headLimit, afterOffset.length);
-    const omitted = afterOffset.length - shown;
-    const render = (arr) => arr.map((b) => b.lines.join('\n'));
-    let segments;
-    let nextOffset = offset + shown;
-    if (omitted > 0 && shown > 0) {
-        // Keep head + tail so both ends of the match range stay visible.
-        const headCount = Math.max(1, Math.ceil(shown / 2));
-        const tailCount = shown - headCount;
-        const head = render(afterOffset.slice(0, headCount));
-        const tail = tailCount > 0 ? render(afterOffset.slice(afterOffset.length - tailCount)) : [];
-        segments = [...head, `…${omitted} matches omitted…`, ...tail];
-        // Paging must resume at the first OMITTED block (right after the head
-        // slice): offset+shown would permanently skip the middle blocks that
-        // the tail slice displaced. Tail blocks re-appear on later pages —
-        // duplication is acceptable, silent loss is not.
-        nextOffset = offset + headCount;
-    } else {
-        segments = render(afterOffset.slice(0, shown));
-    }
-    const notice = (omitted > 0 || !totalKnown)
-        ? `\n[Showing ${shown} of ${totalStr} matches${totalKnown ? '' : ' (results partial)'}; pass offset:${nextOffset} for more]`
-        : '';
-    return { text: segments.join('\n--\n') + notice, total, shown, omitted };
-}
-
-// Part 1: drop path:line match lines already emitted by an earlier pattern in
-// a pattern[] fan-out. Context ('-') lines and non-match lines pass through.
-function dedupeFanoutMatchLines(body, seen) {
-    const text = String(body);
-    if (/^Error:/.test(text)) return text;
-    const out = [];
-    for (const line of text.split('\n')) {
-        const s = splitGrepLinePrefix(line);
-        if (s && s.delimiter === ':') {
-            const key = `${s.path}\0${s.lineNo}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
-        }
-        out.push(line);
-    }
-    return out.join('\n');
-}
-
-function formatGrepOutput({ windowed, totalWindowed, totalKnown, headLimit, offset, outputMode, patterns: _patterns, beforeN, afterN, contextN, searchPath, grepResolvedPath: _grepResolvedPath, workDir, globPatterns: _globPatterns, fileType: _fileType, filenameOmitted = false, prefix = '', broadAdvisory: _broadAdvisory = true, disableContentGrouping = false }) {
-    const lines = headLimit === Infinity ? windowed : windowed.slice(0, headLimit);
-    const normalized = lines.map((line) => relativeGrepLine(line, workDir, outputMode === 'files_with_matches', outputMode, filenameOmitted));
-    const remaining = Math.max(0, totalWindowed - lines.length);
-    const shown = lines.length;
-    // Finding 3: PRE-offset grand total so the denominator matches the
-    // context-mode notice (offset==0 leaves this unchanged).
-    const total = offset + totalWindowed;
-    const scopePath = JSON.stringify(normalizeOutputPath(searchPath));
-    const truncated = (remaining > 0 || !totalKnown)
-        ? (totalKnown
-            ? `\n[Showing ${shown} of ${total} results; pass offset:${offset + shown} for more]`
-            : `\n[Showing ${shown} (more matches exist — use output_mode:'count' for the exact total on ${scopePath}); pass offset:${offset + shown} for more]`)
-        : '';
+// Grep output rendering (context-block windowing, fan-out dedupe, notices)
+// lives in lib/grep-output.mjs.
+import {
+    dedupeFanoutMatchLines,
+    formatGrepContextOutput,
+    formatGrepOutput,
+    globMissingPatternMessage,
+    grepMissingPatternMessage,
+} from './lib/grep-output.mjs';
 
-    let countSummary = '';
-    if (outputMode === 'count') {
-        let totalMatches = 0;
-        let fileCount = 0;
-        for (const line of normalized) {
-            const m = line.match(/(?:^|:)(\d+)$/);
-            if (m) { totalMatches += Number(m[1]); fileCount++; }
-        }
-        countSummary = `\n[total ${totalMatches} match${totalMatches === 1 ? '' : 'es'} across ${fileCount} file${fileCount === 1 ? '' : 's'}]`;
-    }
-    const hasContext = (beforeN > 0 || afterN > 0 || contextN > 0);
-    const groupedBody = (outputMode === 'content' && !hasContext && !filenameOmitted && !disableContentGrouping)
-        ? groupGrepContentByFile(normalized)
-        : normalized.join('\n');
-    const body = groupedBody + truncated + countSummary;
-    return `${prefix}${body}`;
-}
 
 export async function executeGrepTool(args, workDir, executeChildBuiltinTool, readStateScope = null, options = {}) {
     args = normalizeGrepArgs(args);

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

@@ -46,10 +46,14 @@ export function trimShellJobSpill(detail) {
 // stat/unlink keeps the main event loop free; fire-and-forget so the
 // synchronous caller receives `dir` immediately.
 const SHELL_JOB_STALE_MS = 24 * 60 * 60 * 1000;
-let shellJobsSwept = false;
+// The sweep used to run ONCE per process. A desktop/CLI session that stays up
+// for days therefore never reclaimed anything after boot; re-arm it on an
+// interval so long-lived hosts keep collecting.
+const SHELL_JOB_SWEEP_INTERVAL_MS = 60 * 60 * 1000;
+let shellJobsSweptAt = 0;
 async function sweepStaleShellJobs(dir) {
-    if (shellJobsSwept) return;
-    shellJobsSwept = true;
+    if (Date.now() - shellJobsSweptAt < SHELL_JOB_SWEEP_INTERVAL_MS) return;
+    shellJobsSweptAt = Date.now();
     const cutoff = Date.now() - SHELL_JOB_STALE_MS;
     let names;
     try { names = await fsPromises.readdir(dir); } catch { return; }

package/src/runtime/agent/orchestrator/tools/patch/matcher.mjs

@@ -457,15 +457,52 @@ function scoreSimilarPatchLine(candidate, target) {
   return score;
 }
 
-export function nearestPatchLineHint(sourceLines, expectedLine, preferredLine) {
+// Best fuzzy candidate for one patch line, as a structured match so callers can
+// both describe it AND centre a source excerpt on it.
+export function nearestPatchLineMatch(sourceLines, expectedLine, preferredLine) {
   const expected = String(expectedLine || '');
-  if (!expected.trim()) return '';
+  if (!expected.trim()) return null;
   let best = null;
   const preferred = Number.isFinite(preferredLine) && preferredLine >= 0 ? preferredLine : 0;
   for (let i = 0; i < sourceLines.length; i++) {
     const score = scoreSimilarPatchLine(sourceLines[i], expected) - (Math.abs(i - preferred) * 0.01);
     if (!best || score > best.score) best = { score, index: i, line: sourceLines[i] };
   }
-  if (!best || best.score <= 0) return '';
+  if (!best || best.score <= 0) return null;
+  return best;
+}
+
+export function nearestPatchLineHint(sourceLines, expectedLine, preferredLine) {
+  const best = nearestPatchLineMatch(sourceLines, expectedLine, preferredLine);
+  if (!best) return '';
   return `nearest line ${best.index + 1}: ${JSON.stringify(compactPatchPreviewLine(best.line))}`;
 }
+
+// Bounded verbatim window of the CURRENT file around a failed match, so a
+// context-miss retry can be built from the error alone instead of costing an
+// extra read turn. Hard caps keep the added context small (<= ~1 KB).
+const PATCH_EXCERPT_MAX_LINES = 14;
+const PATCH_EXCERPT_MAX_CHARS = 1000;
+
+export function formatPatchSourceExcerpt(sourceLines, centerIdx, spanLen = 1) {
+  const lines = sourceLines || [];
+  if (!lines.length) return '';
+  if (!Number.isFinite(centerIdx) || centerIdx < 0) return '';
+  const want = Math.max(6, Math.min(PATCH_EXCERPT_MAX_LINES, (Number(spanLen) || 1) + 4));
+  const before = Math.min(3, Math.floor(want / 3));
+  const start = Math.max(0, Math.min(centerIdx - before, Math.max(0, lines.length - want)));
+  const end = Math.min(lines.length, start + want);
+  const out = [];
+  let chars = 0;
+  for (let i = start; i < end; i++) {
+    const text = `${String(i + 1).padStart(5, ' ')}| ${compactPatchPreviewLine(lines[i], 120)}`;
+    chars += text.length + 1;
+    if (chars > PATCH_EXCERPT_MAX_CHARS) {
+      out.push('     | …');
+      break;
+    }
+    out.push(text);
+  }
+  if (!out.length) return '';
+  return `\ncurrent file lines ${start + 1}-${start + out.length} (verbatim — build the retry from these):\n${out.join('\n')}`;
+}

package/src/runtime/agent/orchestrator/tools/patch/v4a-convert.mjs

@@ -30,6 +30,8 @@ import {
   splitTextLinesForPatch,
   firstMeaningfulPatchLine,
   nearestPatchLineHint,
+  nearestPatchLineMatch,
+  formatPatchSourceExcerpt,
   compactPatchPreviewLine,
   decodeValidUtf8OrNull,
 } from './matcher.mjs';
@@ -88,25 +90,36 @@ function formatV4AAnchorMissHint(sourceLines, hunk) {
 function formatV4AContextMissHint(sourceLines, stats, anchorLine) {
   const expected = firstMeaningfulPatchLine(stats.oldLines);
   const parts = [];
+  let centerIdx = -1;
   if (expected) {
     const nearest = nearestPatchLineHint(sourceLines, expected, anchorLine);
     parts.push(`expected first old line: ${JSON.stringify(compactPatchPreviewLine(expected))}`);
     if (nearest) parts.push(nearest);
     const divergence = firstV4ADivergenceHint(sourceLines, stats.oldLines, anchorLine);
-    if (divergence) parts.push(divergence);
+    if (divergence) {
+      parts.push(divergence.text);
+      centerIdx = divergence.fileIdx;
+    } else {
+      const match = nearestPatchLineMatch(sourceLines, expected, anchorLine);
+      if (match) centerIdx = match.index;
+    }
   }
+  if (centerIdx < 0 && Number.isFinite(anchorLine) && anchorLine >= 0) centerIdx = anchorLine;
   parts.push('use exact current context or a broader @@ anchor; no stubs.');
-  return ` ${parts.join('; ')}`;
+  const head = ` ${parts.join('; ')} Copy the context lines verbatim from the excerpt below — do not retype them from memory.`;
+  return `${head}${formatPatchSourceExcerpt(sourceLines, centerIdx, (stats.oldLines || []).length)}`;
 }
 
 // When the FIRST old line does exist verbatim in the source, the real
 // mismatch is some later line of the block — name it, with both sides
 // JSON-escaped so invisible differences (real char vs literal \uXXXX
-// escape, tabs, trailing spaces) become visible in the error.
+// escape, tabs, trailing spaces) become visible in the error. Returns the
+// message plus the file index it points at, so the caller can centre the
+// source excerpt on the true divergence instead of the anchor.
 function firstV4ADivergenceHint(sourceLines, oldLines, anchorLine) {
   const lines = oldLines || [];
   const firstIdx = lines.findIndex((l) => String(l ?? '').trim().length > 0);
-  if (firstIdx < 0) return '';
+  if (firstIdx < 0) return null;
   const first = lines[firstIdx];
   const starts = [];
   for (let i = 0; i < sourceLines.length; i++) {
@@ -115,16 +128,19 @@ function firstV4ADivergenceHint(sourceLines, oldLines, anchorLine) {
   const pref = Number.isFinite(anchorLine) && anchorLine >= 0 ? anchorLine : 0;
   const start = starts.filter((s) => s >= 0)
     .sort((a, b) => Math.abs(a - pref) - Math.abs(b - pref) || a - b)[0];
-  if (start === undefined) return '';
+  if (start === undefined) return null;
   for (let k = 0; k < lines.length; k++) {
     const exp = lines[k];
     const act = sourceLines[start + k];
     if (act !== exp) {
       const actText = act === undefined ? '(past EOF)' : JSON.stringify(compactPatchPreviewLine(act));
-      return `first divergent line: old[${k + 1}] expected ${JSON.stringify(compactPatchPreviewLine(exp))} vs file line ${start + k + 1} actual ${actText}`;
+      return {
+        text: `first divergent line: old[${k + 1}] expected ${JSON.stringify(compactPatchPreviewLine(exp))} vs file line ${start + k + 1} actual ${actText}`,
+        fileIdx: start + k,
+      };
     }
   }
-  return '';
+  return null;
 }
 
 function joinTextLinesForPatch(lines) {
@@ -205,7 +221,7 @@ function resolveV4AHunkPosition(sourceLines, hunk, nextSearchLine, options = {})
     }
   }
   if (oldStartIdx < 0) {
-    const msg = `V4A hunk context not found: ${formatV4AHunkLocator(hunk)};${formatV4AContextMissHint(sourceLines, stats, anchorLine)} Copy context lines verbatim from the latest read output — do not retype them from memory.`;
+    const msg = `V4A hunk context not found: ${formatV4AHunkLocator(hunk)};${formatV4AContextMissHint(sourceLines, stats, anchorLine)}`;
     return { error: msg };
   }
   const matchLen = stats.oldCount === 0 ? 0 : oldLinesPattern.length;

package/src/runtime/channels/lib/owned-runtime.mjs

@@ -477,7 +477,14 @@ async function reloadRuntimeConfig() {
     getConfig().interactive ?? [],
     // Single resolved main-channel id used for the schedule `channel` flag.
     getConfig().channelId,
-    { restart: getBridgeRuntimeConnected() }
+    // The scheduler must be RE-ARMED by the reload whenever it is supposed to
+    // be running. `restart: false` only destroys the cron/one-shot bindings and
+    // hands lifecycle back to the caller — but on an automation-only install
+    // (no messaging backend) startAutomationRuntime() is already past its
+    // `automationRunning` guard, so nobody would ever call scheduler.start()
+    // again and every saved/edited schedule stayed silently disarmed until the
+    // daemon restarted.
+    { restart: automationRunning || getBridgeRuntimeConnected() }
   );
   const nextBackend = createBackend(getConfig());
   const backendTypeChanged = (nextBackend?.name || "") !== previousBackendName;