mixdog 0.9.25 → 0.9.26

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

@@ -40,6 +40,38 @@ function _pathsOf(arg) {
 function _normPath(p) { return String(p).replace(/\\/g, '/').toLowerCase(); }
 function _baseName(p) { const s = _normPath(p); const i = s.lastIndexOf('/'); return i >= 0 ? s.slice(i + 1) : s; }
 function _dirName(p) { const s = _normPath(p); const i = s.lastIndexOf('/'); return i >= 0 ? s.slice(0, i) : ''; }
+// A path targets a specific file (not a directory scope) when its basename
+// carries a file extension — the signal that a grep was already file-scoped.
+function _isFileScopedPath(p) { return /\.[A-Za-z0-9]{1,12}$/.test(_baseName(p)); }
+// Grep context flag: -C/-A/-B count as context ONLY when > 0. An explicit
+// -C:0 / -A:0 / -B:0 is NO context (bare match lines).
+function _hasGrepContext(a) { return Number(a?.['-A']) > 0 || Number(a?.['-B']) > 0 || Number(a?.['-C']) > 0; }
+// Canonical path segments: normalize slashes/case, drop '.' and resolve '..'
+// so ./ and ../ variants collapse. Used by the abs/rel-tolerant path match.
+function _canonSegs(p) {
+    const out = [];
+    for (const seg of _normPath(p).split('/')) {
+        if (seg === '' || seg === '.') continue;
+        if (seg === '..') { if (out.length && out[out.length - 1] !== '..') out.pop(); else out.push('..'); continue; }
+        out.push(seg);
+    }
+    return out;
+}
+function _canonPath(p) { return _canonSegs(p).join('/'); }
+// abs/rel-tolerant same-file test: equal when one canonical path is a
+// segment-aligned suffix of the other (so C:/proj/src/x.mjs, src/x.mjs and
+// ./src/x.mjs all match). Basename equality is implied by the suffix compare.
+function _pathsMatch(a, b) {
+    if (!a || !b) return false;
+    const A = _canonSegs(a); const B = _canonSegs(b);
+    if (!A.length || !B.length) return false;
+    const long = A.length >= B.length ? A : B;
+    const short = A.length >= B.length ? B : A;
+    for (let i = 0; i < short.length; i += 1) {
+        if (long[long.length - short.length + i] !== short[i]) return false;
+    }
+    return true;
+}
 // Exact (normalized) same-file test — used where "related" is too loose.
 function _samePath(a, b) { return !!a && !!b && _normPath(a) === _normPath(b); }
 // Loose sibling/variant relation — cluster detector pairs this WITH token overlap.
@@ -148,6 +180,15 @@ export function createSteeringLadder(ctx) {
     // same-path regions in ONE call are the recommended batched form and are
     // never counted. Fires once per path per session.
     const _readWindowsByPath = new Map();
+    // Detector A state: prior turn's file-scoped grep paths that ran WITHOUT
+    // any -C/-B/-A context (a bare match-line grep on a specific file). Seeds
+    // the grep-no-context-then-read nudge for the next turn.
+    let _lastFileScopedGrepNoCtxPaths = null;
+    // Detector B state: per-path consecutive-read streak (canonical path ->
+    // count). Tracked as a Map so multi-file turns keep independent streaks
+    // ([A,B]->B->B fires on B). Files not read this turn are pruned; a path is
+    // dropped after it fires.
+    const _readStreaks = new Map();
 
     // Level-2 steering emitter shared by both ladder paths (single-call
     // level-1 streak and the independent all-read-only streak). Sets the latch
@@ -178,20 +219,37 @@ export function createSteeringLadder(ctx) {
             // Steering hint gate: at most ONE hint per turn (priority:
             // level-2 > grep/shell detectors > level-1).
             let _hintFiredThisTurn = hintAlreadyFired;
+            // Specific-detector predicates (A: grep-no-context then re-read; B:
+            // 3rd consecutive same-file read). Evaluated up front so the GENERIC
+            // level-1 batching nudge can defer to them (more specific wins),
+            // while the level-2 runaway escalation below still outranks them.
+            const _readCallsThisTurn = calls.filter((c) => c?.name === 'read');
+            const _aWouldFire = !!_lastFileScopedGrepNoCtxPaths
+                && _readCallsThisTurn.some((c) => _pathsOf(c?.arguments?.path)
+                    .some((p) => [..._lastFileScopedGrepNoCtxPaths].some((g) => _pathsMatch(p, g))));
+            let _bWouldFire = false;
+            for (const c of _readCallsThisTurn) {
+                for (const w of _readWindows(c)) {
+                    for (const [k, cnt] of _readStreaks) { if (cnt >= 2 && _pathsMatch(k, w.path)) { _bWouldFire = true; break; } }
+                    if (_bWouldFire) break;
+                }
+                if (_bWouldFire) break;
+            }
             // Missed-parallelism steering: 2+ consecutive turns of a single
             // read-only tool call suggest the model isn't batching independent
             // lookups. Nudge once, then reset (fires again after 2 more).
             if (calls.length === 1 && isEagerDispatchable(calls[0].name, tools)) {
                 _serialReadOnlyStreak += 1;
-                if (_serialReadOnlyStreak >= 2 && !_hintFiredThisTurn) {
+                // Escalation ladder (Step 1). Cumulative level-1 fires are tracked
+                // and NEVER reset. Once level-1 has fired >=3 times with ZERO edits,
+                // escalate to level-2 steering (latched once per 5 turns). The
+                // level-2 escalation always wins; the plain batching nudge instead
+                // DEFERS to the specific A/B detectors when either would fire.
+                const _canEscalate = (_level1FireCount + 1) >= 3 && editCount === 0 && (iterations - _level2LatchAtIteration) >= 5;
+                if (_serialReadOnlyStreak >= 2 && !_hintFiredThisTurn && (_canEscalate || (!_aWouldFire && !_bWouldFire))) {
                     _serialReadOnlyStreak = 0;
-                    // Escalation ladder (Step 1). Cumulative level-1 fires are
-                    // tracked and NEVER reset. Once level-1 has fired >=3 times with
-                    // ZERO edits, escalate to level-2 steering (blocked-report is a
-                    // valid completion) instead of the batching nudge — latched to at
-                    // most once per 5 turns.
                     _level1FireCount += 1;
-                    if (_level1FireCount >= 3 && editCount === 0 && (iterations - _level2LatchAtIteration) >= 5) {
+                    if (_canEscalate) {
                         _emitLevel2Steer();
                     } else {
                         pushSystemReminder('Last 2 turns each ran a single read-only tool. Batch independent lookups (read/grep/glob/code_graph) into ONE turn, or start editing if you have enough context.');
@@ -303,8 +361,10 @@ export function createSteeringLadder(ctx) {
                 const _next = new Set();
                 for (const c of _grepCalls) {
                     const a = c?.arguments || {};
-                    const _hasCtx = a['-A'] != null || a['-B'] != null || a['-C'] != null;
-                    const _isContent = a.output_mode === 'content' || a.output_mode === 'content_with_context' || _hasCtx;
+                    // Bare output_mode:'content' WITHOUT real context is routed to
+                    // Detector A (which gives the add-`-C` advice); this detector
+                    // only owns greps that actually returned context.
+                    const _isContent = _hasGrepContext(a) || a.output_mode === 'content_with_context';
                     const _pathsOnly = a.output_mode === 'files_with_matches' || a.output_mode === 'count';
                     const _capped = a.head_limit != null;
                     if (_isContent && !_pathsOnly && !_capped) {
@@ -313,6 +373,55 @@ export function createSteeringLadder(ctx) {
                 }
                 _lastGrepContentPaths = _next.size ? _next : null;
             }
+            // Detector A (fire): a file-scoped grep WITHOUT context last turn,
+            // then a read of that same file this turn. Fires ahead of the read-
+            // fragmentation / B detectors below; the generic level-1 nudge
+            // already deferred to it via _aWouldFire, while the level-2
+            // escalation above still outranks it. On pre-emption by an
+            // earlier hint, the pending set is kept (not cleared) so A can fire
+            // next turn.
+            let _aPending = false;
+            if (_lastFileScopedGrepNoCtxPaths) {
+                const _rp = [];
+                for (const c of _readCallsThisTurn) { for (const p of _pathsOf(c?.arguments?.path)) _rp.push(p); }
+                const _hit = _rp.find((p) => [..._lastFileScopedGrepNoCtxPaths].some((g) => _pathsMatch(p, g)));
+                if (_hit) {
+                    if (!_hintFiredThisTurn) {
+                        pushSystemReminder(`You grepped ${_baseName(_hit)} last turn then re-opened it — request context with -C on file-scoped grep so the match window is already on screen.`);
+                        try {
+                            appendAgentTrace({
+                                sessionId,
+                                iteration: iterations,
+                                kind: 'steer',
+                                payload: { tag: 'grep_nocontext_reread', file: _baseName(_hit) },
+                                agent: sessionAgent || null,
+                            });
+                        } catch { /* best-effort */ }
+                        _hintFiredThisTurn = true;
+                        _lastFileScopedGrepNoCtxPaths = null;
+                    } else {
+                        _aPending = true; // pre-empted this turn — keep pending for next turn
+                    }
+                }
+            }
+            // Detector A (seed): record this turn's file-scoped greps that ran
+            // WITHOUT context so a same-file read next turn triggers the fire
+            // block above. When A was pre-empted this turn (_aPending) the
+            // existing pending set is kept rather than cleared.
+            if (!_aPending) {
+                const _next = new Set();
+                for (const c of _grepCalls) {
+                    const a = c?.arguments || {};
+                    // Exact complement of the content detector's seed: skip greps
+                    // that carried real context (positive -A/-B/-C) OR ran in
+                    // content_with_context mode — those belong to that detector.
+                    if (_hasGrepContext(a) || a.output_mode === 'content_with_context') continue;
+                    for (const p of _pathsOf(a.path)) {
+                        if (_isFileScopedPath(p)) _next.add(p);
+                    }
+                }
+                _lastFileScopedGrepNoCtxPaths = _next.size ? _next : null;
+            }
             // Detector: read fragmentation — 2nd+ single-window read into the
             // SAME file with offsets inside an 800-line span means the model is
             // paging small windows across turns instead of reading one wider
@@ -345,6 +454,50 @@ export function createSteeringLadder(ctx) {
                     }
                 }
             }
+            // Detector B: 3rd consecutive turn reading the SAME file (any
+            // window). Per-path streaks in a Map so multi-file turns keep
+            // independent counts ([A,B]->B->B fires on B). rel/abs spellings of
+            // one file collapse onto a single streak key; files not read this
+            // turn are pruned; a path is dropped after it fires.
+            {
+                // Resolve each read path to one streak key, merging rel/abs
+                // spellings against existing keys and keys already seen this turn.
+                const _touched = new Set();
+                for (const c of calls.filter((x) => x?.name === 'read')) {
+                    for (const w of _readWindows(c)) {
+                        let _key = null;
+                        for (const k of _readStreaks.keys()) { if (_pathsMatch(k, w.path)) { _key = k; break; } }
+                        if (!_key) { for (const k of _touched) { if (_pathsMatch(k, w.path)) { _key = k; break; } } }
+                        _touched.add(_key || _canonPath(w.path));
+                    }
+                }
+                // Prune streaks for files not read this turn (breaks consecutiveness).
+                for (const k of [..._readStreaks.keys()]) { if (!_touched.has(k)) _readStreaks.delete(k); }
+                // Increment each file read this turn (once per turn).
+                for (const k of _touched) {
+                    _readStreaks.set(k, (_readStreaks.get(k) || 0) + 1);
+                    if (_readStreaks.size > 32) _readStreaks.delete(_readStreaks.keys().next().value);
+                }
+                if (!_hintFiredThisTurn) {
+                    for (const [k, cnt] of _readStreaks) {
+                        if (cnt >= 3) {
+                            pushSystemReminder(`3rd window into ${_baseName(k)} — take the remaining span in ONE wide read (offset+limit) instead of paging.`);
+                            try {
+                                appendAgentTrace({
+                                    sessionId,
+                                    iteration: iterations,
+                                    kind: 'steer',
+                                    payload: { tag: 'consecutive_same_file_read', file: _baseName(k) },
+                                    agent: sessionAgent || null,
+                                });
+                            } catch { /* best-effort */ }
+                            _readStreaks.delete(k);
+                            _hintFiredThisTurn = true;
+                            break;
+                        }
+                    }
+                }
+            }
             // Detector: read-only shell (git status/log/diff --stat, ls/dir/cat/
             // type/Get-ChildItem) inspects state the dedicated tools cover.
             // Nudge toward them; never blocks execution.
@@ -366,6 +519,8 @@ export function createSteeringLadder(ctx) {
             _lastGrepContentPaths = null;
             _identGrepStreak = 0;
             _identGrepToken = null;
+            _lastFileScopedGrepNoCtxPaths = null;
+            _readStreaks.clear();
         },
     };
 }

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

@@ -106,3 +106,48 @@ function _restoreCompactedBodies(tcVal, origVal, key) {
     }
     return tcVal;
 }
+
+// Marker prefix emitted by compactStoredToolArgString for every compacted
+// body/long arg (`[mixdog compacted <key>: <N> chars, sha256:…]`). Both the
+// body-only form (marker alone) and the long form (marker + head/tail preview)
+// begin with this exact span.
+const COMPACTED_MARKER_PREFIX = '[mixdog compacted ';
+
+function _isCompactedPlaceholderString(v) {
+    return typeof v === 'string' && v.startsWith(COMPACTED_MARKER_PREFIX);
+}
+
+// Recursively drop every key whose stored value is a compacted-placeholder
+// string, at any depth (batch shapes like edits[].old_string carry nested
+// compacted bodies too). Non-placeholder values are kept verbatim.
+function _dropCompactedPlaceholders(val) {
+    if (Array.isArray(val)) return val.map((item) => _dropCompactedPlaceholders(item));
+    if (val && typeof val === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(val)) {
+            if (_isCompactedPlaceholderString(v)) continue; // drop the key entirely
+            out[k] = _dropCompactedPlaceholders(v);
+        }
+        return out;
+    }
+    return val;
+}
+
+// A SUCCESSFUL tool call's compacted body/long arg (patch / old_string /
+// new_string / content / rewrite / command / script) is never needed again —
+// the edit already applied. compactToolCallsForHistory (run at push time,
+// before the outcome is known) leaves a `[mixdog compacted …]` placeholder in
+// its place. For a success that placeholder persists in the stored assistant
+// tool_use and is transmitted back as a prior apply_patch INPUT, which the
+// model copies verbatim as new patch args — caught by the patch guard, but only
+// after a wasted turn. Drop those placeholder keys so no resubmittable
+// placeholder body survives in history. Failed calls take the opposite path
+// (restoreToolCallBodyForId expands to the full original); success and failure
+// are mutually exclusive per call id, so this never races the restore path.
+// Cache-safe: the caller runs this before the assistant message is transmitted.
+export function dropCompactedBodyArgsForId(assistantMsg, callId) {
+    if (!assistantMsg || !Array.isArray(assistantMsg.toolCalls) || !callId) return;
+    const tc = assistantMsg.toolCalls.find((t) => t && t.id === callId);
+    if (!tc || !tc.arguments || typeof tc.arguments !== 'object') return;
+    tc.arguments = _dropCompactedPlaceholders(tc.arguments);
+}

package/src/runtime/agent/orchestrator/session/manager/compaction-runner.mjs

@@ -157,6 +157,10 @@ async function runRecallFastTrackForSession(session, messages, opts = {}) {
             messages,
             cwd: session?.cwd,
             limit: hydrateLimit,
+            // Clear/manual-compact path: these rows are about to be summarized
+            // away, so skip the bounded 15s synchronous embedding-flush wait —
+            // kick the flush fire-and-forget (dense-search immediacy is moot here).
+            embedWait: false,
         }, callerCtx, memoryTimeoutMs);
     } catch (err) {
         // Ingest failed (dead/timed-out memory runtime). The transcript is NOT

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

@@ -30,7 +30,7 @@ import { preDispatchDenyForSession } from './loop/pre-dispatch-deny.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
 import { crossTurnSignature, crossTurnDedupStub, isEditProgressTool } from './loop/completion-guards.mjs';
 import { getToolKind, isEagerDispatchable, parseNativeToolSearchPayload } from './loop/tool-helpers.mjs';
-import { restoreToolCallBodyForId } from './loop/stored-tool-args.mjs';
+import { restoreToolCallBodyForId, dropCompactedBodyArgsForId } from './loop/stored-tool-args.mjs';
 
 export async function processToolBatch(ctx) {
     const {
@@ -586,6 +586,17 @@ export async function processToolBatch(ctx) {
                     toolKind: 'error',
                 });
             }
+            // Successful call: its compacted body/long args are never needed
+            // again. Drop any `[mixdog compacted …]` placeholder from the stored
+            // assistant tool_use so a prior apply_patch INPUT never surfaces a
+            // resubmittable placeholder patch body the model copies back verbatim
+            // (the patch guard catches it, but only after a wasted turn). Gated on
+            // full success + clean post-processing; the failed/post-fail paths run
+            // restoreToolCallBodyForId instead (mutually exclusive per call id).
+            // Cache-safe: assistantTurnMsg is not transmitted until the next send.
+            if (_postProcessOk && _executeOk && _resultKind === 'normal' && call?.id) {
+                dropCompactedBodyArgsForId(assistantTurnMsg, call.id);
+            }
             // Soft-cancel after each tool: if close landed during execution,
             // discard the rest of the batch and skip the next provider.send.
             throwIfAborted();

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

@@ -19,6 +19,7 @@ import {
     getBackgroundTask,
 } from '../../../../shared/background-tasks.mjs';
 import { startChildGuardian } from '../../../../shared/child-guardian.mjs';
+import { detachedSpawnOpts } from '../../../../shared/spawn-flags.mjs';
 import {
     getShellJobsDir,
     shellJobStdoutPath,
@@ -828,9 +829,8 @@ function _startBackgroundShellJobImpl({ command, timeoutMs, workDir, mergeStderr
     const child = spawn(shell, [wrappedTempPath], {
         cwd: workDir,
         env: scrubLoaderVars(scrubProviderSecrets({ ...spawnEnv })),
-        detached: true,
         stdio: 'ignore',
-        windowsHide: true,
+        ...detachedSpawnOpts,
     });
     startChildGuardian({
         childPid: child.pid,

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

@@ -129,15 +129,19 @@ export function wrapPowerShellWithCwdProbe(command, stateFile) {
     // a failing native call $LASTEXITCODE holds its real code (case3 → 7).
     //
     // The `if (-not $?)` check MUST be the first statement after the command;
-    // any intervening statement resets $?. Terminating errors (`throw`) skip to
-    // catch → $__ec = 1. The cwd probe runs in finally regardless, and we exit
+    // any intervening statement resets $?. Terminating errors (`throw`,
+    // `-ErrorAction Stop`, .NET exceptions) skip to catch → $__ec = 1. A
+    // *caught* terminating error is NOT auto-written to the error stream, so
+    // without re-emitting it the caller only sees `[exit code: 1] (no output)`.
+    // Re-surface the ErrorRecord on stderr so the failure cause reaches the
+    // result envelope. The cwd probe runs in finally regardless, and we exit
     // with $__ec so the probe never masks the observed code.
     return '$global:LASTEXITCODE = 0\n'
         + '$__ec = 0\n'
         + 'try {\n'
         + `${command}\n`
         + '  if (-not $?) { $__ec = if ($LASTEXITCODE) { $LASTEXITCODE } else { 1 } }\n'
-        + '} catch { $__ec = 1 }\n'
+        + '} catch { [Console]::Error.WriteLine(($_ | Out-String).Trim()); $__ec = 1 }\n'
         + `finally { (Get-Location).Path | Out-File -Encoding utf8 ${qFile} }\n`
         + 'exit $__ec';
 }

package/src/runtime/channels/lib/config.mjs

@@ -3,7 +3,7 @@ import { join } from "path";
 import { DiscordBackend } from "../backends/discord.mjs";
 import { TelegramBackend } from "../backends/telegram.mjs";
 import { readSection, updateSection, CONFIG_PATH as MIXDOG_CONFIG_PATH, getDiscordToken, getTelegramToken, diagnoseDiscordTokenValue } from "../../shared/config.mjs";
-import { listSchedules } from "../../shared/schedules-store.mjs";
+import { listSchedules } from "../../shared/schedules-db.mjs";
 import { resolvePluginData } from "../../shared/plugin-paths.mjs";
 const DATA_DIR = resolvePluginData();
 const CONFIG_FILE = MIXDOG_CONFIG_PATH;
@@ -63,19 +63,21 @@ function resolveChannelId(raw = {}, backend = "discord") {
   return "";
 }
 
-function loadConfig() {
+async function loadConfig() {
   try {
     let raw = readSection("channels");
     raw = raw && typeof raw === "object" ? raw : {};
-    // Schedules live in the Mixdog data dir under `schedules/<name>/` (single
-    // source of truth). The legacy `raw.schedules.items` / `raw.nonInteractive`
-    // / `raw.interactive` arrays in mixdog-config.json are no longer read.
-    const scheduleEntries = listSchedules().filter((s) => s.enabled !== false);
-    // Channel-presence routing (no `type` field): an entry WITH a channel is
-    // dispatched directly to that channel; an entry WITHOUT a channel is
-    // injected into the current (Lead) session. Mirrors the webhook model.
-    raw.nonInteractive = scheduleEntries.filter((i) => !!i.channel);
-    raw.interactive = scheduleEntries.filter((i) => !i.channel);
+    // Schedules are the PG `scheduler.schedules` table (single source of
+    // truth). The legacy SCHEDULE.md store and the `raw.schedules.items` /
+    // `raw.nonInteractive` / `raw.interactive` arrays in mixdog-config.json
+    // are no longer read. Done one-shots are dropped so they never re-arm.
+    const scheduleEntries = (await listSchedules())
+      .filter((s) => s.enabled !== false && s.status !== "done");
+    // `target` drives routing: 'channel' → non-interactive dispatch to the
+    // schedule's channel_id; 'session' → inject into the current (Lead)
+    // session. Mirrors the webhook model.
+    raw.nonInteractive = scheduleEntries.filter((s) => s.target === "channel");
+    raw.interactive = scheduleEntries.filter((s) => s.target === "session");
     const accessChannels = { ...raw.access?.channels ?? {} };
     // voice config lives at the top level of mixdog-config.json (peer of
     // channels), so readSection("channels") never sees it. Pull it explicitly.

package/src/runtime/channels/lib/memory-client.mjs

@@ -4,6 +4,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { createStandaloneMemoryRuntime } from '../../../standalone/memory-runtime-proxy.mjs'
+import { readServicePort, markServiceUnreachable, isConnRefuseError } from '../../shared/service-discovery.mjs'
 
 const RUNTIME_ROOT = process.env.MIXDOG_RUNTIME_ROOT
   ? path.resolve(process.env.MIXDOG_RUNTIME_ROOT)
@@ -60,9 +61,28 @@ function isConnRefusedLike(err) {
     || /ECONNREFUSED|missing memory_port|memory-service timeout/i.test(msg)
 }
 
+// A discovery advert validates only the owner pid, which can be a recycled pid
+// living on an unrelated process while its advertised port is dead. This client
+// has no separate /health probe, so on a connect-level failure we distrust the
+// port: mark it unreachable (readServicePort then skips it → legacy fallback)
+// and drop the port cache so the next getMemoryPort re-resolves.
+function _distrustMemoryPort(port, err) {
+  // Connection-level failures ONLY. A 'memory-service timeout' means the daemon
+  // is slow-but-alive — distrusting it would false-route to legacy/buffer.
+  if (port && isConnRefuseError(err)) {
+    markServiceUnreachable('memory', port)
+    _portCache = null
+  }
+}
+
 async function getMemoryPort() {
   const now = Date.now()
   if (_portCache && (now - _portCache.ts) < 5_000) return _portCache.port
+  // Prefer the single-writer discovery advert (discovery/memory.json), which
+  // validates the owner pid is alive. Fall back to the legacy
+  // active-instance.json memory_port field for cross-version compat.
+  const advertPort = readServicePort('memory', { requirePid: false })
+  if (advertPort) { _portCache = { port: advertPort, mtime: 0, ts: now }; return advertPort }
   try {
     const stat = await fs.promises.stat(ACTIVE_INSTANCE_FILE)
     const mtime = stat.mtimeMs
@@ -115,8 +135,8 @@ async function memoryFetch(method, endpoint, body = null, timeoutMs = 10_000, {
         resolve(parsed)
       })
     })
-    req.on('error', reject)
-    req.on('timeout', () => { req.destroy(); reject(new Error('memory-service timeout')) })
+    req.on('error', err => { _distrustMemoryPort(port, err); reject(err) })
+    req.on('timeout', () => { req.destroy(); const err = new Error('memory-service timeout'); _distrustMemoryPort(port, err); reject(err) })
     if (payload) req.write(payload)
     req.end()
   })

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

@@ -407,7 +407,7 @@ async function refreshBridgeOwnership(options = {}) {
 async function reloadRuntimeConfig() {
   const previousBackend = getBackend();
   const previousBackendName = previousBackend?.name || "";
-  setConfig(loadConfig());
+  setConfig(await loadConfig());
   scheduler.reloadConfig(
     getConfig().nonInteractive ?? [],
     getConfig().interactive ?? [],