@yemi33/minions 0.1.2044 → 0.1.2046

package/engine/kb-sweep.js

@@ -23,6 +23,8 @@ const KB_SWEEP_STATE_PATH = path.join(ENGINE_DIR, 'kb-sweep-state.json');
 const KB_SWEEP_LOG_PATH = path.join(ENGINE_DIR, 'kb-sweep.log');
 const KB_SWEEP_RUNNER_PATH = path.join(__dirname, 'kb-sweep-runner.js');
 const SWEPT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const AUTO_SWEEP_INTERVAL_MS = 4 * 60 * 60 * 1000;
+const KB_SWEPT_PATH = path.join(ENGINE_DIR, 'kb-swept.json');
 const COMPRESS_THRESHOLD_BYTES = 5000;
 const LLM_BATCH_SIZE = 30;
 const NORMALIZE_CONCURRENCY = 5;
@@ -555,6 +557,127 @@ async function _runKbSweepImpl(opts = {}) {
   return summary;
 }
 
+/**
+ * Spawn the KB sweep runner (`engine/kb-sweep-runner.js`) as a detached child.
+ * Shared between dashboard's POST /api/knowledge/sweep handler and the engine
+ * tick's auto-sweep phase. Performs the same synchronous "starting" → "in-flight"
+ * CAS dance the dashboard handler used to do inline.
+ *
+ * Callers are responsible for the in-flight / stale-guard check BEFORE calling
+ * (so they can return distinct HTTP responses or log levels).
+ *
+ * @param {object} opts
+ * @param {string[]} [opts.pinnedKeys] - extra pinned KB keys to skip in the sweep
+ * @param {boolean}  [opts.dryRun]      - dry-run mode for the runner
+ * @param {string}   [opts.cwd=MINIONS_DIR] - working directory for the spawned runner
+ * @param {(level:string,msg:string)=>void} [opts.log] - logger (defaults to console)
+ * @returns {{ sweepToken:string, pid:number|null, bodyFile:string|null,
+ *             ok:boolean, error?:string }}
+ *           ok=false + error on synchronous spawn failure; the "starting" claim is
+ *           released so the caller can retry immediately.
+ */
+function spawnSweepRunnerDetached(opts = {}) {
+  const fsLocal = require('fs');
+  const { spawn: cpSpawn } = require('child_process');
+  const logFn = typeof opts.log === 'function'
+    ? opts.log
+    : (level, msg) => { (level === 'error' ? console.error : console.log)(`[kb-sweep] ${msg}`); };
+  const cwd = opts.cwd || require('./queries').MINIONS_DIR;
+  const startedAt = Date.now();
+  const sweepToken = `${startedAt}-${Math.random().toString(36).slice(2, 8)}`;
+
+  try {
+    safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify({
+      status: 'starting', startedAt, startedAtIso: new Date().toISOString(),
+      sweepToken, pid: null,
+    }));
+  } catch (e) {
+    logFn('error', `failed to write starting state: ${e.message}`);
+  }
+
+  let bodyFile = null;
+  const hasBody = (Array.isArray(opts.pinnedKeys) && opts.pinnedKeys.length > 0)
+    || opts.dryRun != null;
+  if (hasBody) {
+    bodyFile = path.join(ENGINE_DIR, `tmp-kb-sweep-body-${sweepToken}.json`);
+    try {
+      safeWrite(bodyFile, JSON.stringify({
+        pinnedKeys: Array.isArray(opts.pinnedKeys) ? opts.pinnedKeys : undefined,
+        dryRun: opts.dryRun != null ? !!opts.dryRun : undefined,
+      }));
+    } catch (e) {
+      logFn('error', `failed to write body-file ${bodyFile}: ${e.message}`);
+      bodyFile = null;
+    }
+  }
+
+  let logFdNum = null;
+  let stdio = ['ignore', 'ignore', 'ignore'];
+  try {
+    logFdNum = fsLocal.openSync(KB_SWEEP_LOG_PATH, 'a');
+    stdio = ['ignore', logFdNum, logFdNum];
+  } catch (e) {
+    logFn('error', `failed to open log ${KB_SWEEP_LOG_PATH}: ${e.message}`);
+  }
+
+  const spawnArgs = ['--sweep-token', sweepToken];
+  if (bodyFile) spawnArgs.push('--body-file', bodyFile);
+
+  let proc;
+  try {
+    proc = cpSpawn(process.execPath, [KB_SWEEP_RUNNER_PATH, ...spawnArgs], {
+      cwd, stdio, detached: true, windowsHide: true,
+      env: { ...process.env },
+    });
+  } catch (e) {
+    if (logFdNum != null) try { fsLocal.closeSync(logFdNum); } catch { /* ignore */ }
+    if (bodyFile) try { fsLocal.unlinkSync(bodyFile); } catch { /* ignore */ }
+    try { shared.safeUnlink(KB_SWEEP_STATE_PATH); } catch { /* ignore */ }
+    return { ok: false, error: `spawn failed: ${e.message}`, sweepToken, pid: null, bodyFile: null };
+  }
+  if (logFdNum != null) try { fsLocal.closeSync(logFdNum); } catch { /* ignore */ }
+
+  try {
+    const current = safeJson(KB_SWEEP_STATE_PATH);
+    if (current && current.status === 'starting' && current.sweepToken === sweepToken) {
+      safeWrite(KB_SWEEP_STATE_PATH, JSON.stringify({
+        status: 'in-flight', startedAt, startedAtIso: new Date().toISOString(),
+        sweepToken, pid: proc.pid,
+      }));
+    }
+  } catch { /* best-effort */ }
+
+  proc.unref();
+  return { ok: true, sweepToken, pid: proc.pid, bodyFile };
+}
+
+/**
+ * Decide whether the engine tick should auto-spawn a sweep right now.
+ * Pure function (reads disk, no side effects). Used by the tick's
+ * auto-sweep phase.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.now=Date.now()]                injectable clock (tests)
+ * @param {number} [opts.intervalMs=AUTO_SWEEP_INTERVAL_MS]
+ * @param {object} [opts.liveness]                      pre-computed liveness (optional)
+ * @returns {{ shouldSpawn:boolean, reason:string, lastCompletedAt:number|null }}
+ */
+function shouldAutoSweep(opts = {}) {
+  const now = Number(opts.now) || Date.now();
+  const intervalMs = Number(opts.intervalMs) || AUTO_SWEEP_INTERVAL_MS;
+  const liveness = opts.liveness || readSweepLiveness({ entryCount: opts.entryCount || 0, now });
+  if (liveness.inFlight && liveness.alive && !liveness.stale) {
+    return { shouldSpawn: false, reason: 'sweep-in-flight', lastCompletedAt: null };
+  }
+  const swept = safeJson(KB_SWEPT_PATH);
+  const sweptTs = swept && swept.timestamp ? Date.parse(swept.timestamp) : NaN;
+  const lastCompletedAt = Number.isFinite(sweptTs) ? sweptTs : null;
+  if (lastCompletedAt != null && (now - lastCompletedAt) < intervalMs) {
+    return { shouldSpawn: false, reason: 'within-interval', lastCompletedAt };
+  }
+  return { shouldSpawn: true, reason: lastCompletedAt == null ? 'no-prior-sweep' : 'interval-elapsed', lastCompletedAt };
+}
+
 /** Compute a dynamic stale-guard timeout based on KB size. */
 function staleGuardMs(entryCount) {
   // 30 minutes minimum, plus 1 second per entry (for the rewrite pass)
@@ -566,6 +689,10 @@ module.exports = {
   staleGuardMs,
   readSweepLiveness,
   reconcileSweepStateOnBoot,
+  spawnSweepRunnerDetached,
+  shouldAutoSweep,
+  AUTO_SWEEP_INTERVAL_MS,
+  KB_SWEPT_PATH,
   KB_SWEEP_STATE_PATH,
   KB_SWEEP_LOG_PATH,
   KB_SWEEP_RUNNER_PATH,

package/engine/lifecycle.js

@@ -595,6 +595,7 @@ function updateWorkItemStatus(meta, status, reason) {
         delete target.failReason;
         delete target.failedAt;
         delete target._retryCount;
+        delete target._retriesByAgent;
         target.completedAgents = Object.entries(target.agentResults)
           .filter(([, r]) => r.status === WI_STATUS.DONE)
           .map(([a]) => a);
@@ -611,6 +612,7 @@ function updateWorkItemStatus(meta, status, reason) {
         delete target.failReason;
         delete target.failedAt;
         delete target._retryCount;
+        delete target._retriesByAgent;
         // P-e0b4f7a5 — successful completion (including a phantom-retry
         // succeeding) clears the phantom markers so cleanup can reap the
         // worktree on the next sweep.
@@ -3218,6 +3220,14 @@ function _deferRetryWithCounter(meta, detection, counterField, maxCount, pending
         w._lastRetryAt = ts();
         w._lastRetryReason = reason;
         w._pendingReason = pendingReason;
+        // W-mpmwxn1j — only the standard PR-attachment / nonterminal counter
+        // (_retryCount) participates in per-agent reassignment. Phantom
+        // retries (runtime crashes before any work product) are not
+        // agent-specific failures, so we don't bump _retriesByAgent for them.
+        if (counterField === '_retryCount') {
+          const failedAgent = meta?._agentId || w.dispatched_to;
+          if (failedAgent) shared.bumpAgentRetryCount(w, failedAgent);
+        }
         // P-e0b4f7a5 — phantom-retry path stamps _phantomCompletion +
         // _phantomBranch so cleanup.js can preserve the worktree across the
         // re-dispatch window. Only set for the phantom counter; nonterminal
@@ -4018,6 +4028,10 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
               w._retryCount = retries + 1;
               w._lastRetryAt = ts();
               w._lastRetryReason = 'no review verdict';
+              // W-mpmwxn1j — bump per-agent counter so a reviewer who never
+              // emits a verdict gets reassigned after maxRetriesPerAgent hits.
+              const failedAgent = meta?._agentId || w.dispatched_to;
+              if (failedAgent) shared.bumpAgentRetryCount(w, failedAgent);
               delete w.dispatched_at;
               delete w.completedAt;
               delete w._pendingReason;
@@ -4125,6 +4139,10 @@ async function runPostCompletionHooks(dispatchItem, agentId, code, stdout, confi
             if (retries < ENGINE_DEFAULTS.maxRetries) {
               w.status = WI_STATUS.PENDING;
               w._retryCount = retries + 1;
+              // W-mpmwxn1j — bump per-agent counter so a planner that never
+              // writes the PRD gets reassigned after maxRetriesPerAgent hits.
+              const failedAgent = meta?._agentId || w.dispatched_to;
+              if (failedAgent) shared.bumpAgentRetryCount(w, failedAgent);
               delete w.dispatched_at;
               delete w.completedAt;
               log('warn', `plan-to-prd ${meta.item.id} completed without PRD file — auto-retry ${retries + 1}/${ENGINE_DEFAULTS.maxRetries}`);

package/engine/llm.js

@@ -82,6 +82,21 @@ function trackEngineUsage(category, usage) {
   _ensureFlushTimer();
 }
 
+// W-mpmwxni2000c25c7-b — silent-error regression counter. Every CC/doc-chat
+// error surfaced through the handlers bumps `_engine[category].errorsByCode[code]`
+// so /api/metrics reflects new error codes (cc-turn-timeout, empty-output, …)
+// without polluting cost/tokens. Counters flush on the same timer as
+// trackEngineUsage so the dashboard's fast-state mtime gate isn't bypassed.
+function trackEngineError(category, errorCode) {
+  if (!category || !errorCode) return;
+  if (category.startsWith('_test') || category.startsWith('test-')) return;
+  if (!_pendingMetrics.engine[category]) _pendingMetrics.engine[category] = _emptyEngineDelta();
+  const cat = _pendingMetrics.engine[category];
+  if (!cat.errorsByCode) cat.errorsByCode = Object.create(null);
+  cat.errorsByCode[errorCode] = (cat.errorsByCode[errorCode] || 0) + 1;
+  _ensureFlushTimer();
+}
+
 function flushMetricsBuffer() {
   const pending = _pendingMetrics;
   if (!Object.keys(pending.engine).length && !Object.keys(pending.daily).length) return;
@@ -106,6 +121,12 @@ function flushMetricsBuffer() {
           cat.totalDurationMs = (cat.totalDurationMs || 0) + delta.totalDurationMs;
           cat.timedCalls = (cat.timedCalls || 0) + delta.timedCalls;
         }
+        if (delta.errorsByCode) {
+          if (!cat.errorsByCode) cat.errorsByCode = {};
+          for (const [code, count] of Object.entries(delta.errorsByCode)) {
+            cat.errorsByCode[code] = (cat.errorsByCode[code] || 0) + count;
+          }
+        }
       }
       if (!metrics._daily) metrics._daily = {};
       for (const [day, delta] of Object.entries(pending.daily)) {
@@ -129,6 +150,12 @@ function flushMetricsBuffer() {
       c.inputTokens += delta.inputTokens; c.outputTokens += delta.outputTokens;
       c.cacheRead += delta.cacheRead; c.cacheCreation += delta.cacheCreation;
       c.totalDurationMs += delta.totalDurationMs; c.timedCalls += delta.timedCalls;
+      if (delta.errorsByCode) {
+        if (!c.errorsByCode) c.errorsByCode = Object.create(null);
+        for (const [code, count] of Object.entries(delta.errorsByCode)) {
+          c.errorsByCode[code] = (c.errorsByCode[code] || 0) + count;
+        }
+      }
     }
     for (const [day, delta] of Object.entries(pending.daily)) {
       if (!_pendingMetrics.daily[day]) _pendingMetrics.daily[day] = _emptyDailyDelta();
@@ -233,6 +260,8 @@ function _missingRuntimeResult(runtimeName, runtime, reason) {
     errorClass: shared.FAILURE_CLASS.CONFIG_ERROR,
     errorMessage: message,
     missingRuntime: true,
+    error: { message, code: shared.FAILURE_CLASS.CONFIG_ERROR, retriable: false },
+    ok: false,
   };
 }
 
@@ -245,7 +274,7 @@ function _resolvedCallResult(result) {
 function _resolveRuntimeNameFor(callOpts = {}) {
   let runtimeName = callOpts.cli;
   if (!runtimeName && callOpts.engineConfig) runtimeName = resolveCcCli(callOpts.engineConfig);
-  return runtimeName || 'claude';
+  return runtimeName || 'copilot';
 }
 
 function _runtimeUnavailableResult(callOpts = {}) {
@@ -566,7 +595,7 @@ function _createStreamAccumulator({
 
 function _resolveRuntimeFor(callOpts) {
   // Explicit `cli` opt wins; otherwise fall to `engineConfig` resolution;
-  // otherwise default to claude (the historical behavior).
+  // otherwise default to copilot (fleet default as of W-mpmwxkk40007c995).
   return resolveRuntime(_resolveRuntimeNameFor(callOpts));
 }
 
@@ -599,6 +628,52 @@ function _resolveRuntimeFeatureOpts({
 
 // ─── Core LLM Call ───────────────────────────────────────────────────────────
 
+// W-mpmwxni2000c25c7-b — typed-error envelope helper. callLLM /
+// callLLMStreaming attach `error: { message, code, retriable }` to every
+// failure resolution so dashboard CC/doc-chat handlers can surface a
+// structured 5xx JSON or SSE `event: error` instead of returning an empty
+// reply that hangs the UI. The shape mirrors the existing `runtime.parseError`
+// contract from sub-item (a) so adapter classifications (auth-failure,
+// context-limit, budget-exceeded, crash, model-unavailable) propagate
+// verbatim. Engine codes added here:
+//   - 'spawn-error'        runFile/proc.on('error') failure (binary missing,
+//                          EACCES, fork bomb, ...)
+//   - 'runtime-exit'       non-zero exit code with no parseError signal
+//   - 'empty-output'       zero exit but no parsed text — runtime returned
+//                          nothing useful (CLI bug or silent timeout)
+//   - 'unparseable-output' bytes streamed but accumulator extracted no text
+//                          (malformed JSONL or unknown event shape)
+//
+// Existing `errorClass` / `errorMessage` fields stay populated for callers
+// that haven't moved to the typed envelope yet.
+function _buildErrorEnvelope(errInfo, code, parsed, fallback) {
+  if (errInfo && errInfo.code) {
+    return { message: errInfo.message || fallback || 'LLM call failed', code: errInfo.code, retriable: errInfo.retriable !== false };
+  }
+  if (code !== 0 && code !== null) {
+    const stderrTail = parsed && parsed.stderr ? String(parsed.stderr).trim().split('\n').slice(-3).join(' | ').slice(0, 500) : '';
+    return {
+      message: stderrTail ? `Runtime exited with code ${code}: ${stderrTail}` : `Runtime exited with code ${code}`,
+      code: 'runtime-exit',
+      retriable: true,
+    };
+  }
+  if (parsed && parsed.text) return null;
+  const rawLen = parsed && parsed.raw ? String(parsed.raw).length : 0;
+  if (rawLen > 0) {
+    return {
+      message: 'Runtime produced output the adapter could not parse',
+      code: 'unparseable-output',
+      retriable: true,
+    };
+  }
+  return {
+    message: fallback || 'Runtime returned no output',
+    code: 'empty-output',
+    retriable: true,
+  };
+}
+
 function callLLM(promptText, sysPromptText, opts = {}) {
   const {
     timeout = 120000, label = 'llm', maxTurns = 1, allowedTools = '',
@@ -670,6 +745,7 @@ function callLLM(promptText, sysPromptText, opts = {}) {
       const errInfo = code !== 0
         ? runtime.parseError([parsed.raw, parsed.stderr].filter(Boolean).join('\n'))
         : { message: '', code: null, retriable: true };
+      const errorEnvelope = _buildErrorEnvelope(errInfo, code, parsed, null);
       resolve({
         text: parsed.text || '',
         usage,
@@ -681,6 +757,8 @@ function callLLM(promptText, sysPromptText, opts = {}) {
         runtime: runtime.name,
         errorClass: errInfo.code,
         errorMessage: errInfo.message || null,
+        error: errorEnvelope,
+        ok: !errorEnvelope,
       });
     };
 
@@ -704,6 +782,8 @@ function callLLM(promptText, sysPromptText, opts = {}) {
         text: '', usage: null, sessionId: null, code: 1,
         stderr: err.message, raw: '', toolUses: [],
         runtime: runtime.name, errorClass: null, errorMessage: null,
+        error: { message: `Runtime spawn failed: ${err.message}`, code: 'spawn-error', retriable: true },
+        ok: false,
       });
     });
   });
@@ -784,6 +864,7 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
       const errInfo = code !== 0
         ? runtime.parseError([parsed.raw, parsed.stderr].filter(Boolean).join('\n'))
         : { message: '', code: null, retriable: true };
+      const errorEnvelope = _buildErrorEnvelope(errInfo, code, parsed, null);
       resolve({
         text: parsed.text || '',
         usage,
@@ -795,6 +876,8 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
         runtime: runtime.name,
         errorClass: errInfo.code,
         errorMessage: errInfo.message || null,
+        error: errorEnvelope,
+        ok: !errorEnvelope,
       });
     };
 
@@ -818,6 +901,8 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
         text: '', usage: null, sessionId: null, code: 1,
         stderr: err.message, raw: '', toolUses: [],
         runtime: runtime.name, errorClass: null, errorMessage: null,
+        error: { message: `Runtime spawn failed: ${err.message}`, code: 'spawn-error', retriable: true },
+        ok: false,
       });
     });
   });
@@ -825,13 +910,74 @@ function callLLMStreaming(promptText, sysPromptText, opts = {}) {
   return promise;
 }
 
+// ─── CC turn watchdog ────────────────────────────────────────────────────────
+//
+// W-mpmwxni2000c25c7-b — wall-clock cap for a single CC/doc-chat turn. CC turns
+// are a higher-level concept than the per-LLM-call `timeout` opt: a turn can
+// internally retry (resume → fresh → final retry) and each retry has its own
+// per-call timer. Without a turn-level watchdog, a runtime stuck mid-stream
+// (no exit, no chunks, no errors) leaves the SSE handler waiting for the
+// per-call timer to fire and the user staring at the typing dots.
+//
+// Usage: `result = await withCcTurnTimeout({ timeoutMs, label, onAbortReady }, (registerAbort) => callerThatReturnsResultPromise(registerAbort))`.
+// The caller plumbs `registerAbort(abortFn)` into every nested LLM call's
+// `onAbortReady` so the watchdog can kill whichever attempt is in flight on
+// expiry. Returns the original result on success or a synthetic envelope
+// `{ text:'', error:{ code:'cc-turn-timeout', retriable:true } }` on expiry.
+async function withCcTurnTimeout({ timeoutMs, label = 'cc-turn', onAbortReady } = {}, callFn) {
+  if (!timeoutMs || timeoutMs <= 0) return callFn(onAbortReady || (() => {}));
+  let currentAbort = null;
+  let timedOut = false;
+  let timer = null;
+  const registerAbort = (abort) => {
+    currentAbort = abort;
+    if (onAbortReady) onAbortReady(abort);
+  };
+  const inflight = Promise.resolve().then(() => callFn(registerAbort));
+  const timeoutPromise = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      try { if (currentAbort) currentAbort(); } catch { /* swallow */ }
+      resolve(null);
+    }, timeoutMs);
+    // NOTE: do NOT unref this timer. If we did, Node would exit the event
+    // loop while waiting on the inflight promise (Promises themselves don't
+    // hold the loop open — only timers/I/O do). The race below clears the
+    // timer immediately on success, so a still-armed timer never leaks past
+    // the resolution.
+  });
+  const winner = await Promise.race([inflight, timeoutPromise]);
+  if (!timedOut) {
+    clearTimeout(timer);
+    return winner;
+  }
+  // Let the in-flight call settle so its cleanup (cleanupFiles/Dirs, kill
+  // sweeps) actually runs before we hand a synthetic envelope to the caller.
+  const settled = await inflight.catch((err) => ({
+    text: '', usage: null, sessionId: null, code: 1, stderr: String(err && err.message || err), raw: '', toolUses: [],
+  }));
+  const message = `CC turn ${label} timed out after ${timeoutMs}ms`;
+  return {
+    ...settled,
+    text: '',
+    code: settled?.code || 1,
+    errorClass: 'cc-turn-timeout',
+    errorMessage: message,
+    error: { message, code: 'cc-turn-timeout', retriable: true },
+    ok: false,
+  };
+}
+
 module.exports = {
   callLLM,
   callLLMStreaming,
   trackEngineUsage,
+  trackEngineError,
   flushMetricsBuffer,
+  withCcTurnTimeout,
   // Exposed for unit tests — engine code MUST use the runtime adapter contract.
   _buildSpawnAgentFlags,
+  _buildErrorEnvelope,
   _resolveBin,
   _resetBinCache,
   _resetMetricsBufferForTest,

package/engine/preflight.js

@@ -87,17 +87,17 @@ function findClaudeBinary() {
  * `shared.runtimeConfigWarnings` so unknown-CLI warnings and binary checks
  * always cover the same surface.
  *
- * Without a config (legacy callers), returns just `['claude']` — the
- * historical default.
+ * Without a config (legacy callers), returns just `['copilot']` — matches
+ * `ENGINE_DEFAULTS.defaultCli` (W-mpmwxkk40007c995).
  */
 function _distinctRuntimes(config) {
   const set = new Set();
   if (!config || typeof config !== 'object') {
-    set.add('claude');
+    set.add('copilot');
     return Array.from(set);
   }
   const engine = config.engine || {};
-  set.add(engine.defaultCli ? String(engine.defaultCli) : 'claude');
+  set.add(engine.defaultCli ? String(engine.defaultCli) : 'copilot');
   if (engine.ccCli) set.add(String(engine.ccCli));
   for (const agent of Object.values(config.agents || {})) {
     if (agent && agent.cli) set.add(String(agent.cli));
@@ -355,7 +355,7 @@ function _fleetSummaryResults(config) {
   const results = [];
   if (!config || typeof config !== 'object') return results;
   const engine = config.engine || {};
-  const defaultCli = engine.defaultCli ? String(engine.defaultCli) : 'claude';
+  const defaultCli = engine.defaultCli ? String(engine.defaultCli) : 'copilot';
   const defaultModel = engine.defaultModel ? String(engine.defaultModel) : '(runtime default)';
   results.push({ name: 'Fleet', ok: true, message: `defaultCli=${defaultCli}  defaultModel=${defaultModel}` });