mixdog 1.4.0 → 1.4.2

package/src/session-runtime/services/agent-tool/model-select.mjs

@@ -1,9 +1,10 @@
 // One-off model selection for a spawn the user explicitly pinned to a model.
 // The agent's preset route stays the default; this only runs when `model` is
-// passed. The query is matched against the live provider catalog — exact id,
-// then exact display name, then every query word — and a catalog miss retries
-// once on a refreshed catalog. One match runs; several or none fail with
-// candidates instead of substituting another model.
+// passed. The query is matched against the quick/cached provider catalog —
+// literal id, then normalized id, then exact display name, then every query
+// word — and a catalog miss retries once on a catalog refreshed for the
+// requested provider (concurrent misses share that refresh). One match runs;
+// several or none fail with candidates instead of substituting another model.
 import { clean } from './helpers.mjs';
 
 const CANDIDATE_LIMIT = 8;
@@ -20,7 +21,7 @@ const terms = (value) =>
     .filter(Boolean);
 const label = (row) => `${row.provider}/${row.id}`;
 
-function providerRows(rows, provider) {
+export function providerRows(rows, provider) {
   if (!provider) return rows;
   const wanted = norm(provider);
   const exact = rows.filter((row) => norm(row.provider) === wanted);
@@ -33,6 +34,8 @@ function matchModels(rows, query) {
   // Nothing to match on ("???"): `[].every` would accept every row.
   if (!words.length) return [];
   const tiers = [
+    // A literal id wins over its normalized look-alikes (`foo-bar` vs `foo_bar`).
+    (row) => row.id === query,
     (row) => norm(row.id) === wanted,
     (row) => norm(row.display) === wanted,
     (row) => words.every((word) => `${norm(row.id)} ${norm(row.display)}`.includes(word)),
@@ -49,6 +52,34 @@ function candidates(rows) {
   return rows.length > CANDIDATE_LIMIT ? `${shown}, … (${rows.length} total)` : shown;
 }
 
+// A quick read answered from the loaded catalog marks every row complete.
+// Otherwise a hit stands only when it is a literal id of the exact provider the
+// caller named, which the full catalog would pick the same way.
+function quickAnswerHolds(rows, hits, model, provider) {
+  if (rows.length > 0 && rows.every((row) => row.catalogComplete === true)) return true;
+  const wanted = norm(provider);
+  return hits.length > 0 && wanted !== '' && hits.every((row) => row.id === model && norm(row.provider) === wanted);
+}
+
+// The forced refresh in flight per catalog reader and provider scope: concurrent
+// misses share it instead of each refreshing.
+const refreshing = new WeakMap();
+
+// One forced refresh, scoped to the requested provider when one is given.
+function refreshedRows(listProviderModels, provider) {
+  if (!refreshing.has(listProviderModels)) refreshing.set(listProviderModels, new Map());
+  const inflight = refreshing.get(listProviderModels);
+  const scope = norm(provider);
+  if (!inflight.has(scope)) {
+    const request = listProviderModels({ force: true, ...(provider ? { provider } : {}) });
+    inflight.set(
+      scope,
+      request.finally(() => inflight.delete(scope))
+    );
+  }
+  return inflight.get(scope);
+}
+
 /** Resolve args.provider/args.model to one exact catalog route. Without a
  *  catalog (headless/daemon surfaces) exact provider + model pass through. */
 export async function resolveRequestedModel(args, listProviderModels) {
@@ -64,10 +95,20 @@ export async function resolveRequestedModel(args, listProviderModels) {
     if (!terms(model).length) throw new Error(`agent spawn: model "${model}" for provider "${provider}" not found`);
     return args;
   }
-  let pool = providerRows(await listProviderModels(), provider);
+  // The quick/cached catalog answers first. A loaded catalog is final, so its
+  // hit never waits on a provider; an incomplete one (cold or partial) may
+  // lack the model that wins, or one that makes the name ambiguous, so only a
+  // literal id inside an exact, explicitly named provider is taken from it.
+  // Anything else waits for the full catalog.
+  const quickRows = await listProviderModels({ quick: true });
+  let pool = providerRows(quickRows, provider);
   let hits = matchModels(pool, model);
+  if (!quickAnswerHolds(quickRows, hits, model, provider)) {
+    pool = providerRows(await listProviderModels(), provider);
+    hits = matchModels(pool, model);
+  }
   if (!hits.length) {
-    pool = providerRows(await listProviderModels({ force: true }), provider);
+    pool = providerRows(await refreshedRows(listProviderModels, provider), provider);
     hits = matchModels(pool, model);
   }
   if (hits.length === 1) return { ...args, provider: hits[0].provider, model: hits[0].id };

package/src/session-runtime/services/agent-tool/render.mjs

@@ -1,5 +1,7 @@
 // Pure result-rendering and finish-classification helpers.
 import { oneLine } from '../../../runtime/shared/clean.mjs';
+import { isActiveWorkerRow } from './job-views/agent-list.mjs';
+import { isTerminalJobStatus } from './job-views/session-progress.mjs';
 import { compactIso, elapsedFromStamps, stripFinalAnswerWrapper } from './helpers.mjs';
 
 // A worker that gets truncated mid-synthesis or produces an empty terminal
@@ -32,25 +34,77 @@ export function abnormalEmptyFinishError(result, agent) {
   }
 }
 
-// The /agents roster: worker rows then task rows.
-function renderRoster(value) {
+const ROSTER_TAIL = 5;
+const ROSTER_MATCH_CAP = 25;
+
+function workerLine(worker) {
+  const status = worker.status || 'idle';
+  const stage = worker.worker_stage || worker.stage;
+  const progress = oneLine(worker.last_progress);
+  const summary = progress.length > 60 ? `${progress.slice(0, 59)}…` : progress;
+  return `- ${worker.tag}  ${status}${stage && stage !== status ? `/${stage}` : ''}${summary ? `  ${summary}` : ''}`;
+}
+
+function jobLine(job) {
+  const error = job.status === 'failed' ? oneLine(job.error) : '';
+  return `- ${job.task_id}  ${job.type}  ${job.status}  ${job.tag || '-'}${error ? ` error=${error}` : ''}`;
+}
+
+const stamp = (row) => String(row.updatedAt || row.lastUsedAt || row.finishedAt || row.startedAt || '');
+
+// Inactive rows: newest first (stable for rows without stamps).
+const newestFirst = (rows) => rows.slice().sort((a, b) => stamp(b).localeCompare(stamp(a)));
+
+// Inactive rows collapse to a count plus a short tail. A `tag` filter lists the
+// matching inactive rows (bounded) so a specific one can still be found.
+function inactiveSection(label, rows, render, tagOf, filter) {
+  if (rows.length === 0) return [];
+  const needle = filter.toLowerCase();
+  const matched = needle
+    ? rows.filter((row) =>
+        String(tagOf(row) ?? '')
+          .toLowerCase()
+          .includes(needle)
+      )
+    : null;
+  const shown = newestFirst(matched ?? rows).slice(0, matched ? ROSTER_MATCH_CAP : ROSTER_TAIL);
+  const shownFilter = filter.replace(/\s+/g, ' ');
+  const head = matched
+    ? `${label}: ${rows.length} (${matched.length} match tag "${shownFilter}", showing ${shown.length})`
+    : `${label}: ${rows.length} (latest ${shown.length}; pass tag=<text> to find one)`;
+  // Bulleted: a non-bullet line would make the list read as an authored response.
+  return [`- ${head}`, ...shown.map(render)];
+}
+
+// The /agents roster: active workers and running tasks in full; idle/closed
+// workers and finished tasks as counts with a bounded tail.
+function renderRoster(value, filter = '') {
   const workers = Array.isArray(value.workers) ? value.workers : [];
   const jobs = Array.isArray(value.jobs) ? value.jobs : [];
   const lines = [`agents: ${workers.length} · tasks: ${jobs.length}`];
+  const isActive = (worker) => Boolean(worker.awaitingUser) || isActiveWorkerRow(worker);
+  const isRunning = (job) => !isTerminalJobStatus(job.status);
   // Keep list bullets: agent cards distinguish these rows from authored responses.
-  for (const worker of workers) {
-    const status = worker.status || 'idle';
-    const stage = worker.worker_stage || worker.stage;
-    const progress = oneLine(worker.last_progress);
-    const summary = progress.length > 60 ? `${progress.slice(0, 59)}…` : progress;
-    lines.push(
-      `- ${worker.tag}  ${status}${stage && stage !== status ? `/${stage}` : ''}${summary ? `  ${summary}` : ''}`
-    );
-  }
-  for (const job of jobs) {
-    const error = job.status === 'failed' ? oneLine(job.error) : '';
-    lines.push(`- ${job.task_id}  ${job.type}  ${job.status}  ${job.tag || '-'}${error ? ` error=${error}` : ''}`);
-  }
+  lines.push(...workers.filter(isActive).map(workerLine));
+  lines.push(...jobs.filter(isRunning).map(jobLine));
+  lines.push(
+    ...inactiveSection(
+      'idle/closed agents',
+      workers.filter((w) => !isActive(w)),
+      workerLine,
+      (w) => w.tag,
+      filter
+    )
+  );
+  lines.push(
+    ...inactiveSection(
+      'finished tasks',
+      jobs.filter((j) => !isRunning(j)),
+      jobLine,
+      (j) => j.tag || j.task_id,
+      filter
+    )
+  );
   if (workers.length === 0 && jobs.length === 0) lines.push('(no agents or tasks)');
   return lines.join('\n');
 }
@@ -151,11 +205,11 @@ function renderContent(value) {
   return `${header}\n${stripFinalAnswerWrapper(value.content)}`;
 }
 
-export function renderResult(value, { includeDiagnostics = false } = {}) {
+export function renderResult(value, { includeDiagnostics = false, listFilter = '' } = {}) {
   if (value === undefined || value === null) return '';
   if (typeof value === 'string') return value;
   if (value && typeof value === 'object') {
-    if (Array.isArray(value.workers) || Array.isArray(value.jobs)) return renderRoster(value);
+    if (Array.isArray(value.workers) || Array.isArray(value.jobs)) return renderRoster(value, listFilter);
     // close-flow results carry `closed` plus task_id: render the close outcome.
     // close-flow results carry `closed` plus task_id: render the close outcome.
     if (value.closed !== undefined) return renderClosed(value);

package/src/session-runtime/services/agent-tool/send-flow.mjs

@@ -1,5 +1,6 @@
 import {
   isAgentProgressWatchdogAbortError,
+  noteStoppedShellJobsOnError,
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
@@ -20,6 +21,7 @@ import { handoffContent } from '../../handoff-attachments.mjs';
 import { rebindDelegation } from '../../../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import { settledWorkerStatus } from './worker-index/row-liveness.mjs';
 import { whileTurnDispatched } from '../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+import { takeStoppedShellJobs } from '../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 
 function workerResultIdentity({ session, tag, sessionId }) {
   return { tag, sessionId, agent: session.agent || null, provider: session.provider, model: session.model };
@@ -92,7 +94,12 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
     // the watchdog sweep re-stamps turnStartedAt at each turn boundary.
     const watchdogPolicy = resolveAgentWatchdogPolicy(
       sendAgent,
-      spawnFlow.agentWatchdogOverrides({ agent: sendAgent, provider: session.provider, model: session.model })
+      spawnFlow.agentWatchdogOverrides({
+        agent: sendAgent,
+        provider: session.provider,
+        model: session.model,
+        ...(session.modelParameters ? { modelParameters: session.modelParameters } : {}),
+      })
     );
     const watchdog = spawnFlow.startProgressIdleWatchdog(sessionId, watchdogPolicy, sendAgent, {
       onTurnStart: spawnFlow.turnStartStamper(session, tag),
@@ -146,7 +153,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         finalStatus = 'idle';
         const value = {
           ...workerResultIdentity({ session, tag, sessionId }),
-          content: watchdogStoppedHandoff(error, partial),
+          content: watchdogStoppedHandoff(error, partial, await takeStoppedShellJobs(sessionId)),
           stallAbort: true,
         };
         if (job) job._terminalResultValue = value;
@@ -154,6 +161,7 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         return value;
       }
       finalStatus = 'error';
+      noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(sessionId));
       reconcileJobStreamStalled(job, error);
       throw error;
     } finally {

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-prep.mjs

@@ -77,8 +77,8 @@ export function createSpawnPreparer({
    *  first-response deadline and the provider's first-response budget for the
    *  routed model (headers, and first output), handed to
    *  resolveAgentWatchdogPolicy. A provider on the shared window names none. */
-  function agentWatchdogOverrides({ agent, provider, model }) {
-    const budget = getProvider(provider)?.firstResponseBudget?.(model);
+  function agentWatchdogOverrides({ agent, provider, model, modelParameters }) {
+    const budget = getProvider(provider)?.firstResponseBudget?.(model, { modelParameters });
     return {
       firstResponseTimeoutMs: readAgentFirstResponseTimeoutMs(agent, dataDir, STANDALONE_SOURCE_ROOT) ?? undefined,
       providerFirstByteTimeoutMs: budget?.transportMs,
@@ -145,7 +145,12 @@ export function createSpawnPreparer({
       prompt: plan.prompt,
       watchdogPolicy: resolveAgentWatchdogPolicy(
         plan.agent,
-        agentWatchdogOverrides({ agent: plan.agent, provider: plan.preset.provider, model: plan.preset.model })
+        agentWatchdogOverrides({
+          agent: plan.agent,
+          provider: plan.preset.provider,
+          model: plan.preset.model,
+          modelParameters: plan.preset.modelParameters,
+        })
       ),
     };
   }

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-run.mjs

@@ -16,6 +16,7 @@ import { abnormalEmptyFinishError } from '../render.mjs';
 import { createProgressWatchdogRegistry } from '../../agent-watchdog-registry.mjs';
 import {
   isAgentProgressWatchdogAbortError,
+  noteStoppedShellJobsOnError,
   resolveHandoffMessageStartIndex,
   turnPartialHandoff,
   watchdogPartialHandoffFromError,
@@ -27,6 +28,7 @@ import { presetDescriptor } from './spawn-prep.mjs';
 import { workerStageForStatus } from '../worker-rows.mjs';
 import { handoffContent } from '../../../handoff-attachments.mjs';
 import { whileTurnDispatched } from '../../../../runtime/agent/orchestrator/session/manager/runtime-state.mjs';
+import { takeStoppedShellJobs } from '../../../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -209,7 +211,7 @@ export function createSpawnRunner({
           tag,
           sessionId: session.id,
           ...presetDescriptor(agent, preset, presetName),
-          content: watchdogStoppedHandoff(error, partial),
+          content: watchdogStoppedHandoff(error, partial, await takeStoppedShellJobs(session.id)),
           stallAbort: true,
         };
         if (job) job._terminalResultValue = value;
@@ -217,6 +219,7 @@ export function createSpawnRunner({
         return value;
       }
       finalStatus = 'error';
+      noteStoppedShellJobsOnError(error, await takeStoppedShellJobs(session.id));
       reconcileJobStreamStalled(job, error);
       throw error;
     } finally {

package/src/session-runtime/services/agent-tool/spawn-preset.mjs

@@ -1,4 +1,5 @@
 import { configuredAgentRouteCandidates } from '../../../runtime/shared/agent-route-config.mjs';
+import { executionFallbacks } from '../../../runtime/shared/model-route-chain.mjs';
 import {
   agentPresetName,
   clean,
@@ -29,8 +30,11 @@ export function resolveAgentSpawnPreset(config, args = {}) {
   const agentName = normalizeAgentName(args.agent);
   // The agent's stored route: config.agents, or a store bot's own folder.
   const candidates = !clean(args.preset) ? configuredAgentRouteCandidates(config, agentName) : [];
-  const agentRoute = candidates.map((candidate) => normalizeAgentRoute(candidate)).find(Boolean) || null;
-  const storedFallbacks = candidates.find((candidate) => normalizeAgentRoute(candidate))?.fallbacks;
+  const storedCandidate = candidates.find((candidate) => normalizeAgentRoute(candidate));
+  const agentRoute = storedCandidate ? normalizeAgentRoute(storedCandidate) : null;
+  const storedFallbacks = agentRoute
+    ? executionFallbacks({ ...agentRoute, fallbacks: storedCandidate.fallbacks })
+    : undefined;
   // Where the spawned session reads its fallback chain at each hop
   // (route-fallback-chain.mjs): this agent's route, else Main's.
   const fallbackSource = { agent: agentName };

package/src/session-runtime/services/agent-tool/tool-def.mjs

@@ -28,7 +28,7 @@ export const AGENT_TOOL = {
     agentHidden: false,
   },
   description:
-    'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Wait for completion notifications; use status/read only for manual recovery. Close finished agents yourself.',
+    'Run scoped agent work as background tasks. spawn/send return task_id immediately. Reuse one tag for one scope for its whole lifetime; give distinct tags only to independent scopes. Never mint a new tag because a session expired or was lost — same-tag spawn respawns it with the full brief. Completion notifications arrive automatically; use status/read only for manual recovery. Close finished agents yourself.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -36,21 +36,21 @@ export const AGENT_TOOL = {
         type: 'string',
         enum: ['spawn', 'send', 'list', 'close', 'cancel', 'status', 'read', 'cleanup'],
         description:
-          'Required action. New spawn requires agent and one of prompt/message/file; send requires tag and one of prompt/message/file; read/status/close/cancel require task_id or tag; list/cleanup require no target.',
+          'Required action. New spawn requires agent and one of prompt/message/file; send requires tag and one of prompt/message/file; read/status/close/cancel require task_id or tag; list/cleanup require no target. list shows active agents and running tasks in full; idle/closed agents and finished tasks are counts plus a short latest tail (list with tag=<text> shows matching ones: case-insensitive substring, at most 25 per section).',
       },
-      task_id: { type: 'string', description: 'Task ID returned by spawn/send; target for read/status/close/cancel.' },
+      task_id: { type: 'string', description: 'Task ID returned by spawn/send.' },
       agent: {
         type: 'string',
-        description: 'Workflow agent id. Required for a new spawn; same-tag reuse can inherit it.',
+        description: 'Workflow agent id; same-tag reuse can inherit it.',
       },
       tag: {
         type: 'string',
         description:
-          'Stable scope handle. Reuse the same tag for the same scope; never derive a variant by appending a number or suffix. send requires it, while spawn can generate one when omitted.',
+          'Stable scope handle; never derive a variant by appending a number or suffix. spawn generates one when omitted.',
       },
-      prompt: { type: 'string', description: 'Spawn task brief; also accepted for send.' },
-      message: { type: 'string', description: 'Send follow-up; also accepted for spawn.' },
-      file: { type: 'string', description: 'Path to task text; alternative to prompt/message for spawn/send.' },
+      prompt: { type: 'string', description: 'Spawn task brief.' },
+      message: { type: 'string', description: 'Send follow-up.' },
+      file: { type: 'string', description: 'Path to task text; used instead of prompt/message.' },
       cwd: { type: 'string', description: 'Project directory for a new or respawned agent.' },
       context: { type: 'string', description: 'Extra context for the spawn/send turn.' },
       attachments: {
@@ -63,7 +63,7 @@ export const AGENT_TOOL = {
       model: {
         type: 'string',
         description:
-          "Spawn only, and only when the user explicitly names a model: runs this one spawn on it instead of the agent's preset route, which stays the default (omit otherwise). Id, display name, or words of it; ambiguous or unknown names fail with candidates. The agent still supplies role and permissions.",
+          "Spawn only, and only when the user explicitly names a model: runs this one spawn on it instead of the agent's preset route. Id, display name, or words of it; ambiguous or unknown names fail with candidates. The agent still supplies role and permissions.",
       },
       provider: { type: 'string', description: 'Narrows model to one provider; requires model.' },
       effort: { type: 'string', description: 'Reasoning effort for an explicit model.' },

package/src/session-runtime/services/agent-watchdog-registry.mjs

@@ -2,6 +2,8 @@
 // One shared 1s timer sweeps every watched session, so a burst
 // of agents costs a single interval; the timer stops as soon as the last
 // watchdog is released. Abort policy itself lives in the runtime module.
+import { randomUUID } from 'node:crypto';
+import { armTurnTimeout } from '../../runtime/agent/orchestrator/session/manager/turn-reap.mjs';
 import {
   abortAgentProgressWatchdog,
   agentWatchdogPolicyActive,
@@ -23,6 +25,13 @@ export function getProgressWatchdogState(mgr, sessionId) {
   };
 }
 
+// This watchdog owns its timeout: arm the session's shell reap before the
+// abort propagates, unless the turn is already stopped (the guard skips it).
+function abortOnTimeout(controller, ctx) {
+  if (!controller?.signal?.aborted && ctx?.error) armTurnTimeout(ctx.sessionId);
+  abortAgentProgressWatchdog(controller, ctx);
+}
+
 export function createProgressWatchdogRegistry({ mgr }) {
   const watched = new Map();
   registrations.set(mgr, watched);
@@ -100,6 +109,15 @@ export function createProgressWatchdogRegistry({ mgr }) {
     const abortErr = snapshot ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy) : null;
     // No progress snapshot: fall back to the coarse last-progress timestamp so a
     // session that never reports structured progress can still stall out.
+    const observe = () => {
+      try {
+        return typeof mgr.getSessionProgressObservation === 'function'
+          ? mgr.getSessionProgressObservation(sessionId)
+          : null;
+      } catch {
+        return null;
+      }
+    };
     if (!abortErr && !snapshot) {
       // start() admits a manager that provides EITHER progress source, so this
       // fallback must not assume the coarse one exists: throwing here escaped
@@ -114,7 +132,7 @@ export function createProgressWatchdogRegistry({ mgr }) {
       }
       const last = reported || anchorTs;
       if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
-        abortAgentProgressWatchdog(controller, {
+        abortOnTimeout(controller, {
           sessionId,
           agent,
           error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
@@ -123,12 +141,14 @@ export function createProgressWatchdogRegistry({ mgr }) {
           anchorTs,
           lastProgressAt: reported,
           iteration,
+          observation: observe(),
+          registrationId: state.registrationId,
         });
       }
       return;
     }
     if (abortErr) {
-      abortAgentProgressWatchdog(controller, {
+      abortOnTimeout(controller, {
         sessionId,
         agent,
         error: abortErr,
@@ -137,6 +157,8 @@ export function createProgressWatchdogRegistry({ mgr }) {
         now,
         anchorTs,
         iteration,
+        observation: observe(),
+        registrationId: state.registrationId,
       });
     }
   }
@@ -151,14 +173,19 @@ export function createProgressWatchdogRegistry({ mgr }) {
           state.lastSuccessfulCheckAt = Date.now();
         } catch (error) {
           state.error = String(error?.message || error);
-          const elapsed = Date.now() - (state.lastSuccessfulCheckAt || state.anchorTs);
+          const compared = state.lastSuccessfulCheckAt
+            ? { at: state.lastSuccessfulCheckAt, field: 'last_successful_check_at' }
+            : { at: state.anchorTs, field: 'anchor_ts' };
+          const elapsed = Date.now() - compared.at;
           if (state.watchdogPolicy.idleStaleMs > 0 && elapsed > state.watchdogPolicy.idleStaleMs) {
-            abortAgentProgressWatchdog(state.controller, {
+            abortOnTimeout(state.controller, {
               sessionId: state.sessionId,
               agent: state.agent,
               error: new AgentStallAbortError(`agent progress checks failed: ${state.error}`),
               policy: state.watchdogPolicy,
               anchorTs: state.anchorTs,
+              comparedClock: compared,
+              registrationId: state.registrationId,
             });
           }
         }
@@ -177,6 +204,7 @@ export function createProgressWatchdogRegistry({ mgr }) {
         return null;
       if (typeof mgr.linkParentSignalToSession !== 'function') return null;
       const state = {
+        registrationId: randomUUID().slice(0, 8),
         sessionId,
         watchdogPolicy,
         agent,

package/src/session-runtime/services/channel-worker/daemon-spawn.mjs

@@ -7,6 +7,7 @@ import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { scrubLoaderVars } from '../../../runtime/agent/orchestrator/tools/env-scrub.mjs';
 import { withHeapCap } from '../../../runtime/shared/heap-cap.mjs';
+import { systemProxyHandoffEnv } from '../../../runtime/shared/llm/system-proxy.mjs';
 import { detachedSpawnOpts } from '../../../runtime/shared/spawn-flags.mjs';
 import { forkDaemonCandidate } from '../daemon-candidate.mjs';
 
@@ -24,6 +25,7 @@ export function daemonEnv({ rootDir, dataDir, runtimeDir, leadPid }) {
   scrubLoaderVars(env);
   return {
     ...env,
+    ...systemProxyHandoffEnv(),
     MIXDOG_ROOT: rootDir,
     MIXDOG_DATA_DIR: dataDir,
     MIXDOG_RUNTIME_ROOT: runtimeDir,

package/src/session-runtime/services/daemon-candidate.mjs

@@ -8,6 +8,7 @@
 // and attaches to whoever won. The resolved `summary()` describes this boot as
 // observed when called, for a caller that has to give up.
 import { fork } from 'node:child_process';
+import { withEnvProxy } from '../../runtime/shared/llm/http-agent.mjs';
 import { beginDaemonSpawnCapture } from './daemon-crash-capture.mjs';
 
 export function forkDaemonCandidate({
@@ -43,7 +44,9 @@ export function forkDaemonCandidate({
         cwd,
         execArgv,
         stdio: ['ignore', 'ignore', capture.stderrStdio, 'ipc'],
-        env,
+        // Proxy variables (the user's or the desktop's system proxy) need
+        // NODE_USE_ENV_PROXY to reach the daemon's fetch.
+        env: withEnvProxy(env),
         ...spawnOptions,
       });
     } catch (error) {

package/src/session-runtime/services/memory-runtime-proxy/daemon-spawn.mjs

@@ -4,6 +4,7 @@ import { dirname } from 'node:path';
 import { detachedSpawnOpts } from '../../../runtime/shared/spawn-flags.mjs';
 import { withHeapCap } from '../../../runtime/shared/heap-cap.mjs';
 import { resolveRuntimeRoot } from '../../../runtime/shared/runtime-root.mjs';
+import { systemProxyHandoffEnv } from '../../../runtime/shared/llm/system-proxy.mjs';
 import { scrubLoaderVars } from '../../../runtime/agent/orchestrator/tools/env-scrub.mjs';
 
 // Once a spawn crashes deterministically, short-circuit re-forks for this
@@ -33,6 +34,9 @@ function daemonEnv({ dataDir, idleTtlMs }) {
   scrubLoaderVars(env);
   return {
     ...env,
+    // The runtime and model downloads follow the system proxy this process
+    // settled; the memory process consumes the handoff at startup.
+    ...systemProxyHandoffEnv(),
     MIXDOG_DATA_DIR: dataDir,
     MIXDOG_RUNTIME_ROOT: resolveRuntimeRoot(),
     MIXDOG_WORKER_MODE: '1',

package/src/session-runtime/services/plugin-admin.mjs

@@ -8,6 +8,7 @@ import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 import { pluginManifest } from '../../runtime/shared/plugin-manifest.mjs';
 import { pluginMetadata } from '../../runtime/shared/plugin-metadata.mjs';
 import { clean } from '../../runtime/shared/clean.mjs';
+import { startGitSync } from '../../runtime/shared/git-launch.mjs';
 
 const REGISTRY_VERSION = 1;
 
@@ -125,12 +126,15 @@ function normalizeSource(input) {
 }
 
 function runGit(args, options = {}) {
-  const result = spawnSync('git', args, {
-    cwd: options.cwd,
-    encoding: 'utf8',
-    windowsHide: true,
-    timeout: options.timeout ?? 120000,
-  });
+  const result = startGitSync(null, (command, env) =>
+    spawnSync(command, args, {
+      cwd: options.cwd,
+      env,
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: options.timeout ?? 120000,
+    })
+  );
   if (result.status !== 0) {
     const detail = clean(result.stderr) || clean(result.stdout) || `git ${args.join(' ')} failed`;
     throw new Error(detail);