mixdog 0.9.128 → 0.9.129

package/package.json

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

package/src/app.mjs

@@ -86,6 +86,8 @@ export async function run(argv = [], classifiedInvocation = null) {
       model: opts.model,
       effort: opts.effort,
       fast: opts.fast,
+      webSearch: opts.webSearch,
+      memory: opts.memory,
       json: opts.json,
       cwd: process.cwd(),
     });

package/src/headless-command.mjs

@@ -4,7 +4,7 @@ const FLAG_OPTIONS = new Set([
   '--web-search', '--memory', '--json',
 ]);
 const EXEC_UNSUPPORTED_FLAGS = new Set([
-  '--readonly', '--remote', '--onboarding', '--web-search', '--memory',
+  '--readonly', '--remote', '--onboarding',
 ]);
 const HEADLESS_WORKFLOW_ERROR = 'option --workflow is not supported for mixdog exec';
 

package/src/headless-exec.mjs

@@ -90,6 +90,8 @@ function createJsonLifecycle({
   effort,
   fast,
   cwd,
+  webSearch = false,
+  memory = false,
 }) {
   let threadId = `exec_${randomUUID().replace(/-/g, '')}`;
   const turnId = 'turn_1';
@@ -143,6 +145,8 @@ function createJsonLifecycle({
         tool_mode: 'full',
         approval_mode: 'implicit',
         delegation: false,
+        web_search: webSearch === true,
+        memory: memory === true,
       },
     }, turnStartedAt);
     emit({
@@ -540,6 +544,8 @@ export async function runHeadlessExec({
   model,
   effort,
   fast,
+  webSearch = false,
+  memory = false,
   json = false,
   cwd = process.cwd(),
   write = (text) => stdout.write(text),
@@ -571,6 +577,8 @@ export async function runHeadlessExec({
     effort,
     fast,
     cwd,
+    webSearch,
+    memory,
   }) : null;
   let boundary = null;
   let runtime = null;
@@ -602,6 +610,12 @@ export async function runHeadlessExec({
     const createRuntime = runtimeFactory || (
       await import('./mixdog-session-runtime.mjs')
     ).createMixdogSessionRuntime;
+    // Headless defaults: web research and memory tools stay OFF unless the
+    // caller opts in via --web-search / --memory. Delegation is already
+    // disallowed below, completing the solo surface. The per-process
+    // MIXDOG_FEATURE_* overrides are the runtime's canonical switches.
+    process.env.MIXDOG_FEATURE_WEB_SEARCH = webSearch === true ? '1' : '0';
+    process.env.MIXDOG_FEATURE_MEMORY = memory === true ? '1' : '0';
     runtime = await createRuntime({
       provider,
       model,

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

@@ -1009,6 +1009,7 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
         // server-side cache prefix stable.
         const _assistantTurnMsg = attachAssistantTranscriptMetadata({
             role: 'assistant',
+            createdAt: Date.now(),
             // Sub-agent tool-call turns carry only mid-turn preamble in
             // response.content (the real result rides the later final-answer
             // turn). Blank it so it never accumulates as input tokens.

package/src/runtime/agent/orchestrator/session/compact/handoff.mjs

@@ -1,7 +1,6 @@
 import { estimateTokens } from '../context-utils.mjs';
 
 const CONVERSATION_LINE_CHARS = 800;
-const WORKING_FILE_CAP = 20;
 const TOOL_OUTCOME_CHARS = 80;
 
 function textOf(m) {
@@ -42,13 +41,15 @@ function normalizeWorkingPath(value, cwd) {
 
 function pathsFromTool(name, args) {
     const out = [];
-    const rawPath = args.path;
-    const candidates = Array.isArray(rawPath)
-        ? rawPath
-        : String(rawPath || '').split(',');
-    for (const item of candidates) {
-        const value = typeof item === 'string' ? item.trim() : '';
-        if (isFilePath(value)) out.push(value);
+    const rawPaths = [args.path, name === 'code_graph' ? args.files : null];
+    for (const rawPath of rawPaths) {
+        const candidates = Array.isArray(rawPath)
+            ? rawPath
+            : String(rawPath || '').split(',');
+        for (const item of candidates) {
+            const value = typeof item === 'string' ? item.trim() : '';
+            if (isFilePath(value)) out.push(value);
+        }
     }
     if (name === 'apply_patch' && typeof args.patch === 'string') {
         for (const line of args.patch.split('\n')) {
@@ -59,28 +60,206 @@ function pathsFromTool(name, args) {
     return out;
 }
 
-export function collectWorkingFiles(messages, cap = WORKING_FILE_CAP, { cwd } = {}) {
-    const limit = Math.max(1, Math.floor(Number(cap) || WORKING_FILE_CAP));
-    const seen = new Set();
-    const out = [];
-    for (let i = (messages || []).length - 1; i >= 0 && out.length < limit; i -= 1) {
+function normalizeEventTime(value) {
+    if (value == null || value === '') return null;
+    const millis = typeof value === 'number' ? value : Date.parse(String(value));
+    if (!Number.isFinite(millis) || millis <= 0) return null;
+    return new Date(millis).toISOString();
+}
+
+function newerEventTime(left, right) {
+    const leftMs = left ? Date.parse(left) : 0;
+    const rightMs = right ? Date.parse(right) : 0;
+    return rightMs > leftMs ? right : left;
+}
+
+function toolEventTime(message, toolCall, resultMessage, fallback) {
+    const candidates = [
+        resultMessage?.createdAt,
+        resultMessage?.timestamp,
+        toolCall?.createdAt,
+        toolCall?.timestamp,
+        message?.createdAt,
+        message?.timestamp,
+        message?.meta?.createdAt,
+        fallback,
+    ];
+    for (const candidate of candidates) {
+        const normalized = normalizeEventTime(candidate);
+        if (normalized) return normalized;
+    }
+    return null;
+}
+
+function parseWorkingEntry(value) {
+    const raw = String(value || '').trim();
+    const metadata = /\s+\[([^\]]+)\]\s*$/.exec(raw);
+    const path = metadata ? raw.slice(0, metadata.index).trim() : raw;
+    const fields = {};
+    for (const part of String(metadata?.[1] || '').split(';')) {
+        const hit = /^\s*(editedAt|seenAt)=(.+?)\s*$/.exec(part);
+        if (hit) fields[hit[1]] = normalizeEventTime(hit[2]);
+    }
+    return {
+        path,
+        editedAt: fields.editedAt || null,
+        seenAt: fields.seenAt || null,
+    };
+}
+
+function priorWorkingFileGroups(text, cwd) {
+    const modified = [];
+    const referenced = [];
+    let section = null;
+    for (const raw of String(text || '').split('\n')) {
+        const line = raw.trim();
+        if (line === '## Working files') {
+            section = 'referenced';
+            continue;
+        }
+        if (!section) continue;
+        if (line === '### Modified') {
+            section = 'modified';
+            continue;
+        }
+        if (line === '### Referenced') {
+            section = 'referenced';
+            continue;
+        }
+        if (/^##\s+/.test(line) || /^<\/?prior-compacted-context>$/.test(line)) {
+            section = null;
+            continue;
+        }
+        const hit = /^-\s+(.+)$/.exec(line);
+        if (!hit || hit[1] === '(none)' || /^\+\d+\s+omitted$/.test(hit[1])) continue;
+        const entry = parseWorkingEntry(hit[1]);
+        entry.path = normalizeWorkingPath(entry.path, cwd);
+        if (!isFilePath(entry.path)) continue;
+        if (section === 'modified') {
+            modified.push(entry);
+        } else {
+            referenced.push(entry);
+        }
+    }
+    return { modified, referenced };
+}
+
+function mergeWorkingEntries(current, prior, limit, cwd) {
+    const entries = new Map();
+    let order = 0;
+    const touch = (raw, kind) => {
+        const path = normalizeWorkingPath(raw?.path, cwd);
+        if (!isFilePath(path)) return;
+        const key = path.toLowerCase();
+        let entry = entries.get(key);
+        if (!entry) {
+            entry = {
+                path,
+                editedAt: null,
+                seenAt: null,
+                modified: false,
+                order: order++,
+            };
+            entries.set(key, entry);
+        }
+        entry.seenAt = newerEventTime(entry.seenAt, normalizeEventTime(raw?.seenAt));
+        if (kind === 'modified') {
+            entry.modified = true;
+            entry.editedAt = newerEventTime(entry.editedAt, normalizeEventTime(raw?.editedAt));
+        }
+    };
+    for (const entry of current.modified) touch(entry, 'modified');
+    for (const entry of current.referenced) touch(entry, 'referenced');
+    for (const entry of prior.modified) touch(entry, 'modified');
+    for (const entry of prior.referenced) touch(entry, 'referenced');
+    const sorted = [...entries.values()].sort((left, right) => {
+        const leftTime = Date.parse(left.editedAt || left.seenAt || '') || 0;
+        const rightTime = Date.parse(right.editedAt || right.seenAt || '') || 0;
+        return rightTime - leftTime || left.order - right.order;
+    });
+    const modified = sorted.filter((entry) => entry.modified);
+    const referenced = sorted.filter((entry) => !entry.modified);
+    if (!Number.isFinite(limit)) return { modified, referenced };
+    const keptModified = modified.slice(0, limit);
+    return {
+        modified: keptModified,
+        referenced: referenced.slice(0, Math.max(0, limit - keptModified.length)),
+    };
+}
+
+export function collectWorkingFileGroups(messages, cap = Number.POSITIVE_INFINITY, {
+    cwd,
+    previousSummary,
+    now = Date.now(),
+} = {}) {
+    const numericCap = Number(cap);
+    const limit = Number.isFinite(numericCap) && numericCap > 0
+        ? Math.floor(numericCap)
+        : Number.POSITIVE_INFINITY;
+    const results = indexToolResults(messages);
+    const resultMessages = indexToolResultMessages(messages);
+    const currentModified = [];
+    const currentReferenced = [];
+    const supported = new Set(['read', 'apply_patch', 'grep', 'glob', 'find', 'code_graph', 'list']);
+    for (let i = (messages || []).length - 1; i >= 0; i -= 1) {
         const m = messages[i];
         if (m?.role !== 'assistant' || !Array.isArray(m.toolCalls)) continue;
-        for (let j = m.toolCalls.length - 1; j >= 0 && out.length < limit; j -= 1) {
+        for (let j = m.toolCalls.length - 1; j >= 0; j -= 1) {
             const tc = m.toolCalls[j];
             const name = toolName(tc);
-            if (!['read', 'apply_patch', 'grep', 'glob', 'find'].includes(name)) continue;
+            if (!supported.has(name)) continue;
+            const resultMessage = resultMessages.get(String(tc.id || tc.toolCallId || ''));
+            if (name === 'apply_patch') {
+                const output = results.get(String(tc.id || tc.toolCallId || ''));
+                if (/Error:|failed|rejected/i.test(String(output || ''))) continue;
+            }
+            const eventTime = toolEventTime(m, tc, resultMessage, now);
             for (const p of pathsFromTool(name, parseArgs(tc))) {
-                const normalized = normalizeWorkingPath(p, cwd);
-                const key = normalized.toLowerCase();
-                if (seen.has(key)) continue;
-                seen.add(key);
-                out.push(normalized);
-                if (out.length >= limit) break;
+                const path = normalizeWorkingPath(p, cwd);
+                if (!path) continue;
+                if (name === 'apply_patch') {
+                    currentModified.push({
+                        path,
+                        editedAt: eventTime,
+                        seenAt: eventTime,
+                    });
+                } else {
+                    currentReferenced.push({
+                        path,
+                        editedAt: null,
+                        seenAt: eventTime,
+                    });
+                }
             }
         }
     }
-    return out;
+    const prior = priorWorkingFileGroups(previousSummary, cwd);
+    return mergeWorkingEntries({
+        modified: currentModified,
+        referenced: currentReferenced,
+    }, prior, limit, cwd);
+}
+
+export function collectWorkingFiles(messages, cap = Number.POSITIVE_INFINITY, options = {}) {
+    const groups = collectWorkingFileGroups(messages, cap, options);
+    return [...groups.modified, ...groups.referenced].map((entry) => entry.path);
+}
+
+export function stripWorkingFileSections(text) {
+    const out = [];
+    let skipping = false;
+    for (const raw of String(text || '').split('\n')) {
+        const line = raw.trim();
+        if (line === '## Working files') {
+            skipping = true;
+            continue;
+        }
+        if (skipping && (/^##\s+/.test(line) || /^<\/?prior-compacted-context>$/.test(line))) {
+            skipping = false;
+        }
+        if (!skipping) out.push(raw);
+    }
+    return out.join('\n').replace(/\n{3,}/g, '\n\n');
 }
 
 function indexToolResults(messages) {
@@ -93,6 +272,16 @@ function indexToolResults(messages) {
     return map;
 }
 
+function indexToolResultMessages(messages) {
+    const map = new Map();
+    for (const message of messages || []) {
+        if (message?.role !== 'tool') continue;
+        const id = String(message.toolCallId || message.tool_call_id || '');
+        if (id) map.set(id, message);
+    }
+    return map;
+}
+
 function patchTarget(args) {
     if (isFilePath(args.path)) return String(args.path).trim();
     if (typeof args.patch === 'string') {
@@ -215,7 +404,31 @@ export function composeRecallHandoff({
         parts.push('', '## Tool results', ...toolLines);
     }
     parts.push('', '## Working files');
-    parts.push(...(workingFiles.length ? workingFiles.map((p) => `- ${p}`) : ['- (none)']));
+    const groups = Array.isArray(workingFiles)
+        ? {
+            modified: [],
+            referenced: workingFiles.map((entry) => (
+                typeof entry === 'string' ? { path: entry, seenAt: null } : entry
+            )),
+        }
+        : {
+            modified: Array.isArray(workingFiles?.modified) ? workingFiles.modified : [],
+            referenced: Array.isArray(workingFiles?.referenced) ? workingFiles.referenced : [],
+        };
+    const formatEntry = (entry, modified) => {
+        const normalized = typeof entry === 'string' ? { path: entry } : entry;
+        const fields = [];
+        if (modified) fields.push(`editedAt=${normalized?.editedAt || 'unknown'}`);
+        fields.push(`seenAt=${normalized?.seenAt || normalized?.editedAt || 'unknown'}`);
+        return `- ${normalized?.path || ''} [${fields.join('; ')}]`;
+    };
+    if (groups.modified.length) {
+        parts.push('### Modified', ...groups.modified.map((entry) => formatEntry(entry, true)));
+    }
+    if (groups.referenced.length) {
+        parts.push('### Referenced', ...groups.referenced.map((entry) => formatEntry(entry, false)));
+    }
+    if (!groups.modified.length && !groups.referenced.length) parts.push('- (none)');
     return parts.join('\n');
 }
 
@@ -240,8 +453,48 @@ export function fitRecallHandoffText(text, maxTokens) {
         candidate = `${prefix}${kept.join('\n')}${suffix}`;
     }
     if (estimateTokens(candidate) > cap && start >= lines.length) {
-        const withoutTools = candidate.replace(/\n## Tool results\n[\s\S]*?(?=\n## Working files)/, '\n');
-        if (estimateTokens(withoutTools) <= cap) return withoutTools;
+        candidate = candidate.replace(/\n## Tool results\n[\s\S]*?(?=\n## Working files)/, '\n');
+    }
+    if (estimateTokens(candidate) <= cap) return candidate;
+    const rows = candidate.split('\n');
+    const referencedAt = rows.findIndex((line) => line.trim() === '### Referenced');
+    if (referencedAt < 0) return candidate;
+    let referencedEnd = referencedAt + 1;
+    while (referencedEnd < rows.length && !/^#{2,3}\s+/.test(rows[referencedEnd].trim())) {
+        referencedEnd += 1;
+    }
+    const references = rows
+        .slice(referencedAt + 1, referencedEnd)
+        .filter((line) => /^-\s+/.test(line) && !/^\-\s+\+\d+\s+omitted$/.test(line));
+    const prefixRows = rows.slice(0, referencedAt + 1);
+    const suffixRows = rows.slice(referencedEnd);
+    let lo = 0;
+    let hi = references.length;
+    let best = -1;
+    while (lo <= hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        const omitted = references.length - mid;
+        const next = [
+            ...prefixRows,
+            ...references.slice(0, mid),
+            ...(omitted > 0 ? [`- +${omitted} omitted`] : []),
+            ...suffixRows,
+        ].join('\n');
+        if (estimateTokens(next) <= cap) {
+            best = mid;
+            lo = mid + 1;
+        } else {
+            hi = mid - 1;
+        }
+    }
+    if (best >= 0) {
+        const omitted = references.length - best;
+        return [
+            ...prefixRows,
+            ...references.slice(0, best),
+            ...(omitted > 0 ? [`- +${omitted} omitted`] : []),
+            ...suffixRows,
+        ].join('\n');
     }
     return candidate;
 }

package/src/runtime/agent/orchestrator/session/compact/runner.mjs

@@ -51,11 +51,12 @@ import {
 import { buildPostCompactFileAttachment } from './file-reattach.mjs';
 import {
     collectToolOutcomeLines,
-    collectWorkingFiles,
+    collectWorkingFileGroups,
     composeRecallHandoff,
     fitRecallHandoffText,
     conversationLinesFromMemoryText,
     excludeTailFromConversation,
+    stripWorkingFileSections,
 } from './handoff.mjs';
 
 // Post-compact file re-attachment (claude-code parity): re-inject fresh reads
@@ -839,22 +840,38 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
     const recallRoom = (Number.isFinite(recallTokenCap) && recallTokenCap > 0)
         ? Math.min(recallRoomUncapped, Math.max(512, recallTokenCap - tailTokens))
         : recallRoomUncapped;
-    const toolLines = collectToolOutcomeLines(live);
-    const workingFiles = collectWorkingFiles(live, 20, { cwd: opts.cwd });
+    const priorWithoutWorkingFiles = stripWorkingFileSections(recallFit.prior);
+    const priorLines = new Set(
+        priorWithoutWorkingFiles
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean),
+    );
+    const toolLines = collectToolOutcomeLines(live)
+        .filter((line) => !priorLines.has(String(line || '').trim()));
+    const workingFiles = collectWorkingFileGroups(live, undefined, {
+        cwd: opts.cwd,
+        previousSummary: recallFit.prior,
+        now: Date.now(),
+    });
     const conversationLines = excludeTailFromConversation(
         conversationLinesFromMemoryText(recallFit.recall),
         recallTail,
-    );
+    ).filter((line) => !priorLines.has(String(line || '').trim()));
     const composedRecall = composeRecallHandoff({
         sessionId: opts.sessionId || '',
         conversationLines,
         toolLines,
         workingFiles,
     });
-    const fittedRecall = fitRecallHandoffText(composedRecall, Math.max(256, recallRoom - 400));
-    const priorPart = conversationLines.length > 0
-        ? ''
-        : recallFit.prior;
+    const priorRoom = priorWithoutWorkingFiles
+        ? Math.max(256, Math.floor((recallRoom - 200) * 0.55))
+        : 0;
+    const currentRoom = Math.max(256, recallRoom - priorRoom - 200);
+    const fittedRecall = fitRecallHandoffText(composedRecall, currentRoom);
+    const priorPart = priorWithoutWorkingFiles
+        ? fitRecallHandoffText(priorWithoutWorkingFiles, priorRoom)
+        : '';
     const summaryMessage = fitRecallFastTrackSummaryMessage(
         oldHistory,
         fittedRecall,
@@ -911,7 +928,7 @@ function _recallFastTrackCompactMessages(messages, budgetTokens, opts = {}) {
         recallEmpty: !recallFit.recall,
         priorEmpty: !recallFit.prior,
         recallTruncatedInSummary: !!recallFit.recall && !summaryContent.includes(recallFit.recall),
-        priorTruncatedInSummary: !!recallFit.prior && !summaryContent.includes(recallFit.prior),
+        priorTruncatedInSummary: !!priorPart && !summaryContent.includes(priorPart),
         tailTruncated: recallTail.some((m) => messageContentHasMarker(m, RECALL_TAIL_TRUNCATION_MARKER) || messageContentHasMarker(m, RECALL_TAIL_SHORT_TRUNCATION_MARKER)),
         fileReattached: reattach.reattached,
         tailOptions: recallTailOpts,

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

@@ -61,7 +61,7 @@ import {
 import { normalizeOutputPath } from './path-utils.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
-import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from '../env-scrub.mjs';
+import { applyShellEgressPolicy, scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from '../env-scrub.mjs';
 import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 import {
     findPathExecutable,
@@ -549,6 +549,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         scrubProviderSecrets(spawnEnv);
         scrubLoaderVars(spawnEnv);
         scrubRuntimeRootVars(spawnEnv);
+        applyShellEgressPolicy(spawnEnv);
         let wrappedCommand;
         let _teePlan = null;
         let execShell = shell;

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

@@ -108,7 +108,14 @@ export function describeShellStartupPolicy({
 } = {}) {
     const { available, unavailable } = detectPathCapabilities(pathOptions);
     const resolvedShell = shell || basename(String(resolveShellFor('default')?.shell || 'unknown'));
-    return `- Shell startup environment: OS=${os}; shell=${resolvedShell}; available=${available.join(', ') || 'none'}; unavailable=${unavailable.join(', ') || 'none'}. For shell commands, treat every unavailable entry as absent. Invoke one only if the same command first installs it or exposes it on PATH.`;
+    // Session-variable capability line: when the process-level egress block
+    // is active (mixdog exec default pins MIXDOG_FEATURE_WEB_SEARCH=0 and
+    // shell children get a dead proxy), say so here — the model must not
+    // spend calls attempting web access that is guaranteed to fail.
+    const network = String(process.env.MIXDOG_FEATURE_WEB_SEARCH || '') === '0'
+        ? ' network=offline (external egress blocked for every command — curl/wget/pip/apt/git included; only loopback services are reachable; never attempt web access).'
+        : '';
+    return `- Shell startup environment: OS=${os}; shell=${resolvedShell}; available=${available.join(', ') || 'none'}; unavailable=${unavailable.join(', ') || 'none'}.${network} For shell commands, treat every unavailable entry as absent. Invoke one only if the same command first installs it or exposes it on PATH.`;
 }
 
 export function appendShellStartupPolicy(rules, tools, options = {}) {

package/src/runtime/agent/orchestrator/tools/env-scrub.mjs

@@ -75,6 +75,33 @@ const SECRET_EXACT = new Set([
 export function scrubLoaderVars(env) {
     if (!env || typeof env !== 'object') return env;
     for (const k of LOADER_VARS) delete env[k];
+    return _continueScrubLoaderVars(env);
+}
+
+// Headless "web off" reaches shell children too: `mixdog exec` pins
+// MIXDOG_FEATURE_WEB_SEARCH=0 (default; --web-search opts back in) and every
+// model-spawned subprocess then receives the standard proxy variables pointed
+// at a dead loopback endpoint. curl/wget/git-http/pip/apt honor these and
+// fail fast on public hosts, while NO_PROXY keeps loopback traffic
+// (task-local servers) working. Raw-socket clients bypass proxy variables —
+// this is a uniform egress policy for the common tooling path, not a sandbox.
+// The runtime's own provider calls are unaffected: this mutates only the
+// child spawn env, never process.env.
+const SHELL_EGRESS_DEAD_PROXY = 'http://127.0.0.1:1';
+const SHELL_EGRESS_PROXY_VARS = ['HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'FTP_PROXY', 'RSYNC_PROXY'];
+export function applyShellEgressPolicy(env) {
+    if (!env || typeof env !== 'object') return env;
+    if (String(process.env.MIXDOG_FEATURE_WEB_SEARCH ?? '') !== '0') return env;
+    for (const name of SHELL_EGRESS_PROXY_VARS) {
+        env[name] = SHELL_EGRESS_DEAD_PROXY;
+        env[name.toLowerCase()] = SHELL_EGRESS_DEAD_PROXY;
+    }
+    env.NO_PROXY = 'localhost,127.0.0.1,::1';
+    env.no_proxy = env.NO_PROXY;
+    return env;
+}
+
+function _continueScrubLoaderVars(env) {
     // Wildcard sweep: the exact-name list covers the common loader vars but
     // the DYLD_/LD_ families have many siblings (DYLD_FRAMEWORK_PATH,
     // DYLD_FALLBACK_LIBRARY_PATH, LD_AUDIT, LD_BIND_NOW, …). Delete every

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.10",
+  "version": "0.1.11",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.10/mixdog-graph-darwin-arm64",
-      "sha256": "f73d25d6136c4776e38c79de7b6caa84b345c75a9a73a7696a88dd326c27041a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.11/mixdog-graph-darwin-arm64",
+      "sha256": "b606149747aa4106f3648d07d16b014f4c7c4b47d5b526eb29832aa3dba01180"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.10/mixdog-graph-darwin-x64",
-      "sha256": "62e3a5643b952507223f0a776ca2fdbeaa64a0dde4249c917bcf69c73f42904a"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.11/mixdog-graph-darwin-x64",
+      "sha256": "196f10b3d4216995efc41a96ab38c09c0e27676b14f459e34e30990bb35f2c68"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.10/mixdog-graph-linux-arm64",
-      "sha256": "7b145406391fb9d231e3ac561fe894a257f00e39571d879756310109f2b77630"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.11/mixdog-graph-linux-arm64",
+      "sha256": "70a1e0c591db4a3a96070cf490c412186f84e9897690307935679a55ae8f69b8"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.10/mixdog-graph-linux-x64",
-      "sha256": "fc55bcec32f832b0e85a6cb9ebc908e4e9aae3a664b060442eef4d17a4e4ed14"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.11/mixdog-graph-linux-x64",
+      "sha256": "0936a3dc6d9ee4a1e97fe57f1ac5f1f62db89435cc199c6303c9fce3e1f29f05"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.10/mixdog-graph-win32-x64.exe",
-      "sha256": "5f4fc781ce2867367d86063c5729d43bcfb0d71cc18226191d46957046ceeb1b"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.11/mixdog-graph-win32-x64.exe",
+      "sha256": "8d63891c2e15c13f894023f59994a45e54f64cca72c7098cc09069dce700bd43"
     }
   }
 }