mixdog 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",
@@ -203,7 +203,6 @@
     "eslint-scope": "^9.1.2",
     "lucide-static": "^1.41.0"
   },
-  "main": "index.js",
   "directories": {
     "doc": "docs"
   },

package/scripts/release-paths.mjs

@@ -2,7 +2,7 @@
 // Single source of truth for CI/CD path selection.
 //
 // Consumers:
-//   - .github/workflows/release-gate.yml  → `node scripts/release-paths.mjs desktop-regex|runtime-regex`
+//   - .github/workflows/release-gate.yml  → `node scripts/release-paths.mjs desktop-regex|runtime-regex|patch-regex|history-regex|mobile-regex`
 //     (grep -E patterns selecting which incremental gates a change requires)
 //   - .github/workflows/deploy.yml        → `import { RELEASE_CRITICAL_PATHS }`
 //     (git diff paths whose change invalidates the previous release's
@@ -47,6 +47,24 @@ const PATCH_GATE_FILES = [
   ...GATE_SELECTION_SOURCES,
 ];
 
+// The shipped-definition history is generated from git history of the agent,
+// workflow, output-style and bundled-skill trees (scripts/build-shipped-history.mjs)
+// and committed under src/defaults/. Release re-checks it, so the gate checks
+// it first instead of letting a stale file fail the deploy late.
+const HISTORY_GATE_PREFIXES = ['src/agents/', 'src/workflows/', 'src/output-styles/', 'src/defaults/'];
+const HISTORY_GATE_FILES = [
+  'scripts/build-shipped-history.mjs',
+  'src/runtime/shared/shipped-definitions.mjs',
+  '.github/workflows/release-gate.yml',
+  ...GATE_SELECTION_SOURCES,
+];
+
+// The mobile release scripts (Python) carry unittest suites that no Node lane
+// discovers; they run when those scripts or the mobile workflows change.
+const MOBILE_GATE_PREFIXES = ['apps/mobile/scripts/'];
+const MOBILE_WORKFLOW_PATTERN = '\\.github/workflows/mobile-[^/]*\\.yml$';
+const MOBILE_GATE_FILES = ['.github/workflows/release-gate.yml', ...GATE_SELECTION_SOURCES];
+
 // deploy.yml plan: paths whose change since the published release tag marks
 // the default lane as unverified.
 export const RELEASE_CRITICAL_PATHS = ['native', 'scripts', 'src', ...PACKAGE_MANIFESTS];
@@ -77,14 +95,33 @@ export function patchGateRegex() {
   ].join('|')})`;
 }
 
+export function historyGateRegex() {
+  return `^(${[
+    ...HISTORY_GATE_PREFIXES.map(escapeRegex),
+    ...HISTORY_GATE_FILES.map((file) => `${escapeRegex(file)}$`),
+  ].join('|')})`;
+}
+
+export function mobileGateRegex() {
+  return `^(${[
+    ...MOBILE_GATE_PREFIXES.map(escapeRegex),
+    ...MOBILE_GATE_FILES.map((file) => `${escapeRegex(file)}$`),
+    MOBILE_WORKFLOW_PATTERN,
+  ].join('|')})`;
+}
+
 const mode = process.argv[2];
 if (mode) {
   if (mode === 'desktop-regex') process.stdout.write(`${desktopGateRegex()}\n`);
   else if (mode === 'runtime-regex') process.stdout.write(`${runtimeGateRegex()}\n`);
   else if (mode === 'patch-regex') process.stdout.write(`${patchGateRegex()}\n`);
+  else if (mode === 'history-regex') process.stdout.write(`${historyGateRegex()}\n`);
+  else if (mode === 'mobile-regex') process.stdout.write(`${mobileGateRegex()}\n`);
   else if (mode === 'critical-paths') process.stdout.write(`${RELEASE_CRITICAL_PATHS.join('\n')}\n`);
   else {
-    process.stderr.write(`unknown mode: ${mode} (expected desktop-regex|runtime-regex|patch-regex|critical-paths)\n`);
+    process.stderr.write(
+      `unknown mode: ${mode} (expected desktop-regex|runtime-regex|patch-regex|history-regex|mobile-regex|critical-paths)\n`
+    );
     process.exit(1);
   }
 }

package/src/headless-role.mjs

@@ -140,8 +140,8 @@ export async function runHeadlessRole({
 } = {}) {
   const cleanAgent = clean(agent);
   const cleanMessage = clean(message);
-  // Classic headless surface: web search and memory tools start OFF
-  // and opt back in per run (--web-search / --memory). An explicit
+  // Web search and memory start OFF. This call can pass webSearch or memory;
+  // exec accepts --web-search and rejects --memory. An explicit
   // MIXDOG_FEATURE_* value from the caller environment always wins.
   for (const [key, enabled] of [
     ['MIXDOG_FEATURE_WEB_SEARCH', webSearch],

package/src/lib/rules-builder.cjs

@@ -9,7 +9,6 @@
  *   - buildAgentRoleContent             — BP3: agent role/system rules
  *   - buildAgentRetrievalInjectionContent — BP3: narrow read-only retrieval role
  *   - buildLeadMetaContent              — BP2: Lead profile/settings context
- *   - buildInjectionContent             — legacy joined Lead session content
  *
  * 4-BP cache layout (composeSystemPrompt):
  *   BP1 = shared tool policy
@@ -400,27 +399,6 @@ function buildLeadLanguageContent({ DATA_DIR }) {
   return buildLanguageSection(DATA_DIR);
 }
 
-/**
- * Build the Lead injection content.
- */
-function buildInjectionContent({ PLUGIN_ROOT, DATA_DIR }) {
-  const parts = [];
-
-  const tool = buildSharedToolContent({ PLUGIN_ROOT });
-  if (tool) parts.push(tool);
-
-  const meta = buildLeadMetaContent({ PLUGIN_ROOT, DATA_DIR });
-  if (meta) parts.push(meta);
-
-  const role = buildLeadRoleContent({ PLUGIN_ROOT, DATA_DIR });
-  if (role) parts.push(role);
-
-  const language = buildLeadLanguageContent({ DATA_DIR });
-  if (language) parts.push(language);
-
-  return parts.join('\n\n');
-}
-
 function buildAgentRoleContent({ PLUGIN_ROOT, profile = 'full' }) {
   const AGENT_DIR = path.join(PLUGIN_ROOT, 'rules', 'agent');
   if (String(profile || 'full') === 'retrieval') {
@@ -455,7 +433,6 @@ module.exports = {
   buildLeadMetaContent,
   buildLeadLanguageContent,
   buildAgentRoleContent,
-  buildInjectionContent,
   buildAgentRetrievalInjectionContent,
   omitToolRoutes,
 };

package/src/rules/lead/LEAD.md

@@ -10,8 +10,8 @@
   never per-call narration or plan repeats.
 - Mid-task: a replacement supersedes, an addition folds in, a status question
   gets a brief answer while work continues.
-- Context is managed automatically: never propose stopping or stop on your own
-  judgment.
+- Context is managed automatically: never stop or propose stopping because of
+  context size.
 - Be a grounded, candid, and attentive collaborator: natural and respectful,
   without flattery, forced humor, mimicry, or stereotyping.
 <!-- tools: agent -->

package/src/runtime/agent/orchestrator/runtime-core/tool-defs.mjs

@@ -98,8 +98,7 @@ const admitted = (tools, names) => (tools || []).filter((tool) => names.includes
 
 /**
  * Assemble this runtime's tool definitions from the loaded tool-def modules.
- * Pure: callers resolve their own availability flags (skills env gate, channel
- * ownership) and pass the already-built goal/agent tool arrays.
+ * Pure: callers resolve their own availability flags (skills env gate) and pass the already-built goal/agent tool arrays.
  *
  * - `standaloneTools` is the model-facing set (also the deferred catalog base).
  * - `internalToolDefs` adds the `public: false` web-search tools: reachable
@@ -108,7 +107,6 @@ const admitted = (tools, names) => (tools || []).filter((tool) => names.includes
 export function collectStandaloneToolDefs({
   webSearchToolDefs,
   memoryToolDefs,
-  channelToolDefs,
   codeGraphToolDefs,
   browserToolDefs = [],
   computerToolDefs = [],
@@ -119,7 +117,6 @@ export function collectStandaloneToolDefs({
   setupToolDefs = [],
   goalTools = [],
   agentTools = [],
-  isChannelTool = () => false,
   skillToolEnabled = true,
 }) {
   const webSearchRuntimeTools = admitted(webSearchToolDefs?.TOOL_DEFS, WEB_SEARCH_RUNTIME_TOOLS);
@@ -129,7 +126,6 @@ export function collectStandaloneToolDefs({
     CWD_TOOL,
     ...webSearchRuntimeTools.filter((tool) => tool?.public !== false),
     ...admitted(memoryToolDefs?.TOOL_DEFS, MEMORY_RUNTIME_TOOLS),
-    ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => isChannelTool(tool?.name)),
     ...admitted(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS, CODE_GRAPH_RUNTIME_TOOLS),
     ...admitted(browserToolDefs, BROWSER_RUNTIME_TOOLS),
     ...admitted(computerToolDefs, COMPUTER_RUNTIME_TOOLS),

package/src/runtime/agent/orchestrator/session/context-utils.mjs

@@ -1,6 +1,13 @@
 import { createHash } from 'node:crypto';
 import { estimateTokens } from './token-estimate.mjs';
-import { beginIdentity, endIdentity, putJsonElement, putJsonString, putRaw, putShapeText } from './context-identity-writer.mjs';
+import {
+  beginIdentity,
+  endIdentity,
+  putJsonElement,
+  putJsonString,
+  putRaw,
+  putShapeText,
+} from './context-identity-writer.mjs';
 import { positiveInt } from '../../../shared/numbers.mjs';
 import { hasPlainPrototype } from '../../../shared/object.mjs';
 import { createContextFingerprinter } from './context-fingerprint.mjs';
@@ -39,19 +46,10 @@ export {
   resolveSessionCompactPolicy,
 } from './context-compaction-policy.mjs';
 
-// ---------------------------------------------------------------------------
-// Token estimation lives in ./token-estimate.mjs — a conservative
-// Unicode-aware heuristic. It is accurate ENOUGH because context pressure is
-// anchored on the provider usage baseline (the exact prompt-token count the
-// provider reports for the previous request) and the heuristic only prices the
-// delta appended since then. Measured across 5,552 real deltas the worst
-// underestimate was 2,985 tokens (1.5% of a 200K window) with a +6.5%
-// aggregate bias toward overcounting.
-//
-// providerTokenCalibration() below reconciles that estimate with actual
-// billing at the provider-aware aggregation boundary (compaction pressure /
-// context gauge), never inside the provider-agnostic per-message memo.
-// ---------------------------------------------------------------------------
+// providerTokenCalibration() below reconciles the ./token-estimate.mjs
+// heuristic with actual billing at the provider-aware aggregation boundary
+// (compaction pressure / context gauge), never inside the provider-agnostic
+// per-message memo.
 
 // Billed-prompt / estimate ratio per provider family. Env overrides let a
 // deployment recalibrate without a code change; values are clamped to a

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -1,9 +1,5 @@
 // src/runtime/agent/orchestrator/session/manager.mjs
-// Thin facade over the split session-manager modules in ./manager/. This file
-// re-exports the EXACT public surface the previous monolith exposed so every
-// importer (loop.mjs, loop/tool-exec.mjs, agent-dispatch.mjs, session-builder,
-// abort-lookup, statusline-agents, headless-role, session-runtime, and the
-// smoke scripts) keeps resolving its symbols through manager.mjs unchanged.
+// Thin facade over the split session-manager modules in ./manager/.
 //
 // Module map:
 //   manager/runtime-liveness.mjs       — in-memory stage/heartbeat + accessors

package/src/runtime/agent/orchestrator/session/read-dedup.mjs

@@ -1,5 +1,4 @@
 // Thin re-export facade — re-exports all cache symbols from their split modules.
-// Existing import paths keep working unchanged.
 export * from './cache/read-cache.mjs';
 export * from './cache/scoped-cache.mjs';
 export * from './cache/prefetch-cache.mjs';

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

@@ -1,15 +1,5 @@
 // Async one-shot shell runner.
 //
-// Replaces the legacy spawnSync path in builtin.mjs shell execution. The
-// improvements over spawnSync are:
-//   - native process-tree termination on timeout / abort.
-//   - automatic spill to $PLUGIN_DATA/shell-output/<taskId>.* once the
-//     in-memory buffers exceed SHELL_OUTPUT_INLINE_CAP bytes. The caller
-//     receives an outputFilePath marker the model can FileRead later
-//     instead of losing the tail past the inline cap.
-//   - external AbortSignal hookup so a session-scoped abort (ESC, new
-//     prompt) cancels in-flight bash work without orphaning the child.
-//
 // One run is an explicit state record (lib/shell-run-state.mjs) driven
 // through three phases: spawn (lib/shell-run-spawn.mjs), settle
 // (lib/shell-run-settle.mjs) and the auto-background promotion

package/src/runtime/channels/index.mjs

@@ -1,13 +1,9 @@
 // Thin facade for the channels worker runtime. The implementation was split
 // out into ./lib/worker-main.mjs plus focused lib/ modules; this file preserves
-// the exact public API and boot side-effects by re-exporting from worker-main.
+// the current worker API and boot side-effects by re-exporting from worker-main.
 // Kept as the channels worker entrypoint the daemon loads.
 export {
-  TOOL_DEFS,
   handleToolCall,
-  handleToolCallWithBridgeRetry,
-  init,
-  instructions,
   isChannelBridgeActive,
   isChannelsDegraded,
   start,

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

@@ -114,8 +114,7 @@ function getControlResponsePath(instanceId) {
 function getStopFlagPath(instanceId) {
   return join(RUNTIME_ROOT, `stop-${sanitize(instanceId)}.flag`);
 }
-// Pure metadata-advert read: ownership is the OS seat lock, so a leftover
-// advert is never evicted here. A transient read during an atomic rename may
+// Pure metadata-advert read. A transient read during an atomic rename may
 // yield empty/partial content: retry once after 50 ms before reporting the
 // advert as unreadable.
 function readActiveInstance() {
@@ -141,8 +140,6 @@ function buildActiveInstanceState(instanceId, meta) {
     supervisor_started_at: Date.now(),
     server_started_at: Date.now(),
     updatedAt: Date.now(),
-    turnEndFile: getTurnEndPath(instanceId),
-    statusFile: getStatusPath(instanceId),
     ...metaFields(meta),
   };
 }
@@ -193,26 +190,14 @@ function refreshActiveInstance(instanceId, meta, options) {
     (curRaw) => {
       const prevForPreserve = curRaw;
       const prev = activeInstanceStaleReason(curRaw) ? null : curRaw;
-      // CAS guard (opt-in via options.onlyIfOwned): heartbeat/refresh ticks
-      // check ownership OUTSIDE this lock, so a newer session can claim the
-      // seat between that check and this locked update. Without this re-read,
-      // the tick would overwrite the newer owner's instanceId (TOCTOU
-      // re-steal -> ownership ping-pong / double provider connections).
-      // Returning undefined aborts the update with no write. Explicit claims
-      // (boot, claimBridgeOwnership) omit the option and stay last-wins.
-      if (options?.onlyIfOwned && (!prev?.instanceId || prev.instanceId !== instanceId)) {
-        return undefined;
-      }
-      // CAS guard (opt-in via options.onlyIfVacant): auto-start claim-if-vacant.
-      // Abort the write when a live (non-stale) owner OTHER than us already holds
-      // the seat — an auto-start must never steal from a live owner. A stale/dead
-      // prior owner leaves prev=null above, so it does NOT block the claim; an
-      // absent seat (prev=null) is claimable too.
-      if (options?.onlyIfVacant && prev?.instanceId && prev.instanceId !== instanceId) {
-        return undefined;
-      }
       // Drop stale fields (pid/startedAt) written by older server versions.
-      const { pid: _legacyPid, startedAt: _legacyStartedAt, ...prevRest } = prev ?? {};
+      const {
+        pid: _legacyPid,
+        startedAt: _legacyStartedAt,
+        turnEndFile: _turnEndFile,
+        statusFile: _statusFile,
+        ...prevRest
+      } = prev ?? {};
       const identity = buildRuntimeIdentity();
       // server_started_at tracks the CURRENT server_pid's start time so the
       // dev-sync barrier can verify the CHILD's freshness (the supervisor's

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -82,12 +82,6 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
           };
           break;
         }
-        case 'rebind_current_transcript': {
-          // Transcript forwarding is retired with channel messaging: accept
-          // and no-op so legacy lead-side pushes never surface an error.
-          result = { content: [{ type: 'text', text: 'transcript rebind retired' }] };
-          break;
-        }
         // memory — handled by memory-service.mjs MCP
         default:
           result = {
@@ -105,13 +99,7 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
     return result;
   }
 
-  // IPC/HTTP wrapper: with channel messaging retired there is no transcript
-  // pre-flush or tool-log relay — plain dispatch.
-  async function handleToolCallWithBridgeRetry(toolName, args, signal) {
-    return handleToolCall(toolName, args, signal);
-  }
-
-  return { handleToolCall, handleToolCallWithBridgeRetry };
+  return { handleToolCall };
 }
 
 export { createToolDispatch };

package/src/runtime/channels/lib/worker-ipc.mjs

@@ -14,7 +14,7 @@ export function runWorkerIpc({
   getProvider: _getProvider,
   getConfig: _getConfig,
   handleMemoryCallResponse,
-  handleToolCallWithBridgeRetry,
+  handleToolCall,
   bootProfile,
 }) {
   const sendToParent = (message) =>
@@ -94,7 +94,7 @@ export function runWorkerIpc({
       _inFlightChannelCalls.set(msg.callId, ac);
       let result;
       try {
-        result = await handleToolCallWithBridgeRetry(msg.name, msg.args || {}, ac.signal);
+        result = await handleToolCall(msg.name, msg.args || {}, ac.signal);
       } finally {
         _inFlightChannelCalls.delete(msg.callId);
       }

package/src/runtime/channels/lib/worker-main.mjs

@@ -4,7 +4,6 @@ import { createRequire } from 'node:module';
 import { loadConfig, createProvider, DATA_DIR } from './config.mjs';
 import { resolveVoiceRuntime } from './voice-runtime-fetcher.mjs';
 import { whisperThreadCount } from './voice-transcription.mjs';
-import { TOOL_DEFS } from '../tool-defs.mjs';
 import { ensureReady, stopVoiceWhisperServer } from './whisper-server.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../../shared/runtime-root.mjs';
 import { Scheduler } from './scheduler.mjs';
@@ -102,7 +101,6 @@ runWorkerBootstrap({
   pruneStalePluginDataLogSiblings,
   DEFAULT_STALE_LOG_SIBLING_MAX,
 });
-const INSTRUCTIONS = '';
 
 // ── Parent notification helper ───────────────────────────────────────
 // This worker has no MCP transport of its own. All notifications flow
@@ -129,10 +127,7 @@ let _reloadDebounce = null;
 const STATUS_FILE = getStatusPath(INSTANCE_ID);
 const statusState = new JsonStateFile(STATUS_FILE, {});
 statusState.ensure();
-const scheduler = new Scheduler(
-  config.nonInteractive ?? [],
-  config.interactive ?? []
-);
+const scheduler = new Scheduler(config.nonInteractive ?? [], config.interactive ?? []);
 // Schedules fire as visible sessions; the session runner belongs to the
 // session-runtime layer, so this worker entry injects it (lazy, like webhooks).
 scheduler.setScheduleRunner(async (schedule, opts) => {
@@ -250,19 +245,12 @@ function wireEventQueueHandlers(eventQueue) {
   // re-read at probe time so a stale-connected flag cannot mask a lost seat.
   eventQueue.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
 }
-// Inbound messaging, provider interaction handlers, and channel voice-message
-// transcription are DELETED with Discord/Telegram (user decision: PWA replaces
-// channels). The headless provider emits no events, so nothing wires here.
-// Tool dispatch in worker mode goes through the IPC `call` handler at the
-// bottom of this file (parent's `callWorker` → `handleToolCall`). There is no
-// orphan worker-level MCP Server: the parent (server.mjs) owns the single
-// connected transport and routes CallTool through the IPC `call` path.
 // ── Worker/HTTP tool-call dispatch ──────────────────────────────────────────
 // Runtime lifecycle dispatch only (activate_channel_bridge / reload_config):
 // threaded as a lifecycle bag of lazy getters so the module reads live
 // file-level references at call time. Used by the HTTP MCP CallTool path and
 // the worker IPC `call` handler at the bottom of this file.
-const { handleToolCall, handleToolCallWithBridgeRetry } = createToolDispatch({
+const { handleToolCall } = createToolDispatch({
   isChannelsDegraded,
   lifecycle: {
     getChannelBridgeActive: () => channelBridgeActive,
@@ -277,14 +265,6 @@ const { handleToolCall, handleToolCallWithBridgeRetry } = createToolDispatch({
     reloadRuntimeConfig,
   },
 });
-async function init(_sharedMcp) {
-  // _sharedMcp is no longer used. Notifications now flow via IPC to the parent
-  // (sendNotifyToParent above). The parameter is retained for backward
-  // compatibility with any caller that still passes a Server reference.
-  scheduler.setInjectHandler((channelId, name, content, options) => {
-    injectAndRecord(channelId, name, content, options);
-  });
-}
 function ensureConfigWatcher() {
   if (_configWatcher) return;
   try {
@@ -374,19 +354,9 @@ if (_isWorkerMode && process.send && process.env.MIXDOG_DAEMON_HOST !== '1') {
     getProvider: () => provider,
     getConfig: () => config,
     handleMemoryCallResponse,
-    handleToolCallWithBridgeRetry,
+    handleToolCall,
     bootProfile,
   });
 }
 
-export {
-  TOOL_DEFS,
-  handleToolCall,
-  handleToolCallWithBridgeRetry,
-  init,
-  INSTRUCTIONS as instructions,
-  isChannelBridgeActive,
-  isChannelsDegraded,
-  start,
-  stop,
-};
+export { handleToolCall, isChannelBridgeActive, isChannelsDegraded, start, stop };

package/src/runtime/shared/semver.d.mts

@@ -0,0 +1 @@
+export function compareSemver(a: string, b: string): number;

package/src/runtime/shared/semver.mjs

@@ -0,0 +1,57 @@
+// SemVer 2.0.0 precedence (§11), dependency-free so both Node and the desktop
+// renderer can use it. A leading `v` is tolerated, build metadata is ignored,
+// and a missing or non-numeric core part reads as 0.
+
+/** Parse a semver-ish string into { parts:[maj,min,patch], prerelease:[ids] }. */
+function parseSemver(value) {
+  const text = String(value || '')
+    .trim()
+    .replace(/^v/i, '')
+    .split('+')[0];
+  const dash = text.indexOf('-');
+  const core = dash === -1 ? text : text.slice(0, dash);
+  const parts = core.split('.').map((n) => {
+    const num = Number.parseInt(n, 10);
+    return Number.isFinite(num) ? num : 0;
+  });
+  while (parts.length < 3) parts.push(0);
+  return { parts, prerelease: dash === -1 ? [] : text.slice(dash + 1).split('.') };
+}
+
+const NUMERIC = /^\d+$/;
+
+// Numeric identifiers compare numerically and rank below alphanumeric ones,
+// which compare in ASCII order.
+function compareIdentifiers(a, b) {
+  const aNumeric = NUMERIC.test(a);
+  const bNumeric = NUMERIC.test(b);
+  if (aNumeric && bNumeric) {
+    const diff = BigInt(a) - BigInt(b);
+    return diff === 0n ? 0 : diff > 0n ? 1 : -1;
+  }
+  if (aNumeric) return -1;
+  if (bNumeric) return 1;
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+
+/**
+ * Compare two semver strings: positive if `a` > `b`, negative if `a` < `b`,
+ * 0 if they have equal precedence. A prerelease ranks below its release, and
+ * of two prereleases sharing every identifier the shorter one is lower.
+ */
+export function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa.parts[i] || 0) - (pb.parts[i] || 0);
+    if (diff !== 0) return diff > 0 ? 1 : -1;
+  }
+  const aPre = pa.prerelease.length;
+  const bPre = pb.prerelease.length;
+  if (!aPre || !bPre) return aPre === bPre ? 0 : aPre ? -1 : 1;
+  for (let i = 0; i < Math.min(aPre, bPre); i++) {
+    const diff = compareIdentifiers(pa.prerelease[i], pb.prerelease[i]);
+    if (diff !== 0) return diff;
+  }
+  return Math.sign(aPre - bPre);
+}

package/src/runtime/shared/tool-surface.mjs

@@ -1,6 +1,6 @@
 // ── Facade: tool-surface primitives + result summaries are re-exported from
-// their cohesive modules so every existing importer resolves unchanged. This
-// file keeps the display-name / arg-summary and aggregate-card clusters.
+// their cohesive modules. This file keeps the display-name / arg-summary and
+// aggregate-card clusters.
 import {
   DEFAULT_SUMMARY_MAX,
   AGENT_SURFACE_BRIEF_MAX,

package/src/runtime/shared/update-checker.mjs

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { writeJsonAtomicSync } from './atomic-file.mjs';
 import { readJsonSafe } from './json-file.mjs';
 import { resolvePluginData } from './plugin-paths.mjs';
+import { compareSemver } from './semver.mjs';
 
 const PACKAGE_NAME = 'mixdog';
 const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
@@ -84,37 +85,7 @@ function writeCache(dataDir, payload) {
   }
 }
 
-/** Parse a semver-ish string into { parts:[maj,min,patch], prerelease }. */
-function parseSemver(value) {
-  const text = String(value || '')
-    .trim()
-    .replace(/^v/i, '');
-  const [core, ...preParts] = text.split('-');
-  const parts = core.split('.').map((n) => {
-    const num = Number.parseInt(n, 10);
-    return Number.isFinite(num) ? num : 0;
-  });
-  while (parts.length < 3) parts.push(0);
-  return { parts, prerelease: preParts.join('-') };
-}
-
-/**
- * Compare two semver strings. Returns positive if `a` > `b`, negative if
- * `a` < `b`, 0 if equal. A version with a prerelease tag is considered
- * lower than the same core version without one (standard semver rule).
- */
-export function compareSemver(a, b) {
-  const pa = parseSemver(a);
-  const pb = parseSemver(b);
-  for (let i = 0; i < 3; i++) {
-    const diff = (pa.parts[i] || 0) - (pb.parts[i] || 0);
-    if (diff !== 0) return diff;
-  }
-  if (pa.prerelease && !pb.prerelease) return -1;
-  if (!pa.prerelease && pb.prerelease) return 1;
-  if (pa.prerelease !== pb.prerelease) return pa.prerelease < pb.prerelease ? -1 : 1;
-  return 0;
-}
+export { compareSemver };
 
 export function isNewerVersion(latest, current) {
   if (!latest || !current) return false;

package/src/session-runtime/boot/begin.mjs

@@ -74,7 +74,6 @@ export async function loadModules(boot) {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   } = await loadRuntimeModules();
   const {
@@ -103,7 +102,6 @@ export async function loadModules(boot) {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
     recapEnabledFn,
     memoryToolsEnabledFn,

package/src/session-runtime/boot/tools.mjs

@@ -27,7 +27,10 @@ import { createRoutedAgentTool } from '../agent-tool-routing.mjs';
 import { createGoalRuntime } from '../../runtime/agent/orchestrator/runtime-core/goal-runtime.mjs';
 import { collectStandaloneToolDefs } from '../../runtime/agent/orchestrator/runtime-core/tool-defs.mjs';
 import { createToolSurface } from '../tool-surface.mjs';
-import { contextStatusForSession, createContextStatus } from '../../runtime/agent/orchestrator/runtime-core/context-status.mjs';
+import {
+  contextStatusForSession,
+  createContextStatus,
+} from '../../runtime/agent/orchestrator/runtime-core/context-status.mjs';
 import { createInternalToolExecutor } from '../internal-tool-executor.mjs';
 import { STANDALONE_ROOT, STANDALONE_DATA_DIR } from '../runtime-paths.mjs';
 import { dataDirOf, workflowHelpers } from './shared.mjs';
@@ -141,12 +144,11 @@ function wireChannels(boot) {
 // Tool definitions, then the lead tool surface (workflow-gated agent tool,
 // pre-session preview, deferred replay) from tool-surface.mjs.
 function wireToolSurface(boot) {
-  const { rt, cfgMod, mgr, goalRuntime, agentTool, channels, featureDisallowedTools } = boot;
+  const { rt, cfgMod, mgr, goalRuntime, agentTool, featureDisallowedTools } = boot;
   const toolsStartedAt = performance.now();
   const { standaloneTools, internalToolDefs, agentToolNames } = collectStandaloneToolDefs({
     webSearchToolDefs: boot.webSearchToolDefs,
     memoryToolDefs: boot.memoryToolDefs,
-    channelToolDefs: boot.channelToolDefs,
     codeGraphToolDefs: boot.codeGraphToolDefs,
     browserToolDefs: BROWSER_BRIDGE_TOOL_DEFS,
     computerToolDefs: COMPUTER_BRIDGE_TOOL_DEFS,
@@ -157,7 +159,6 @@ function wireToolSurface(boot) {
     setupToolDefs: SETUP_TOOL_DEFS,
     goalTools: goalRuntime.tools,
     agentTools: agentTool.tools,
-    isChannelTool: (name) => channels.isChannelTool(name),
     skillToolEnabled: !envFlag('MIXDOG_DISABLE_SKILLS'),
   });
   bootProfile('tools:ready', { ms: (performance.now() - toolsStartedAt).toFixed(1), count: standaloneTools.length });

package/src/session-runtime/resource-mcp-api.mjs

@@ -113,10 +113,14 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     },
     async saveMcpServer(input = {}) {
       const servers = mcpServersOf(getConfig());
-      const originalName = clean(input.originalName) || clean(input.name);
-      if (originalName && !Object.hasOwn(servers, originalName)) {
-        throw new Error(`MCP server not configured: ${originalName}`);
+      // An explicit originalName must exist; a bare name edits a matching
+      // server and otherwise creates a new one.
+      const explicitOriginal = clean(input.originalName);
+      if (explicitOriginal && !Object.hasOwn(servers, explicitOriginal)) {
+        throw new Error(`MCP server not configured: ${explicitOriginal}`);
       }
+      const bareName = clean(input.name);
+      const originalName = explicitOriginal || (Object.hasOwn(servers, bareName) ? bareName : '');
       const existing = originalName ? servers[originalName] : {};
       const normalizedInput = normalizeMcpServerInput(mergedServerInput(input, existing, originalName));
       const name = originalName && clean(input.name) === originalName ? originalName : normalizedInput.name;

package/src/session-runtime/runtime-bootstrap.mjs

@@ -10,7 +10,6 @@ import {
   RUNTIME,
   WEB_SEARCH_TOOL_DEFS,
   MEMORY_TOOL_DEFS,
-  CHANNEL_TOOL_DEFS,
   CODE_GRAPH_TOOL_DEFS,
   STATUSLINE_SESSION_ROUTES,
   STANDALONE_ROOT,
@@ -49,7 +48,6 @@ export async function loadRuntimeModules() {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   ] = await Promise.all([
     profiledImport('config', `${RUNTIME}/config.mjs`),
@@ -62,7 +60,6 @@ export async function loadRuntimeModules() {
     profiledImport('status-routes', STATUSLINE_SESSION_ROUTES, { optional: true }),
     profiledImport('web-search-tool-defs', WEB_SEARCH_TOOL_DEFS, { optional: true }),
     profiledImport('memory-tool-defs', MEMORY_TOOL_DEFS, { optional: true }),
-    profiledImport('channel-tool-defs', CHANNEL_TOOL_DEFS, { optional: true }),
     profiledImport('code-graph-tool-defs', CODE_GRAPH_TOOL_DEFS, { optional: true }),
   ]);
   bootProfile('imports:ready', { ms: (performance.now() - startedAt).toFixed(1) });
@@ -88,7 +85,6 @@ export async function loadRuntimeModules() {
     statusRoutes,
     webSearchToolDefs,
     memoryToolDefs,
-    channelToolDefs,
     codeGraphToolDefs,
   };
 }

package/src/session-runtime/runtime-paths.mjs

@@ -6,7 +6,6 @@ export const RUNTIME = '../runtime/agent/orchestrator';
 export const WEB_SEARCH_RUNTIME = '../runtime/web-search/index.mjs';
 export const WEB_SEARCH_TOOL_DEFS = '../runtime/web-search/tool-defs.mjs';
 export const MEMORY_TOOL_DEFS = '../runtime/memory/tool-defs.mjs';
-export const CHANNEL_TOOL_DEFS = '../runtime/channels/tool-defs.mjs';
 export const CODE_GRAPH_TOOL_DEFS = '../runtime/agent/orchestrator/tools/code-graph-tool-defs.mjs';
 export const CODE_GRAPH_RUNTIME = '../runtime/agent/orchestrator/tools/code-graph.mjs';
 export const STATUSLINE_SESSION_ROUTES = '../vendor/statusline/src/gateway/session-routes.mjs';

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

@@ -18,7 +18,7 @@ import { daemonEnv, spawnDaemonCandidate } from './channel-worker/daemon-spawn.m
 
 export { pruneStaleChannelClientHeartbeats };
 
-const CHANNEL_TOOLS = new Set(['activate_channel_bridge', 'reload_config', 'rebind_current_transcript']);
+const CHANNEL_TOOLS = new Set(['activate_channel_bridge', 'reload_config']);
 const CALL_RETRIES = 3;
 
 function logLine(path, line) {

package/src/session-runtime/settings-profile-api.mjs

@@ -1,6 +1,13 @@
 // Onboarding, the user profile (/profile) and the disabled-skill list. Methods
 // reference `this.*` so cross-member calls resolve against the facade object
 // these are spread into.
+import {
+  mergeStarterGuide,
+  requiredStarterGuideState,
+  storedStarterGuide,
+  withStarterGuideOnCompletion,
+} from './starter-guide-state.mjs';
+
 export function createProfileSettings({
   getConfig,
   adoptConfig,
@@ -19,21 +26,39 @@ export function createProfileSettings({
         version: nextConfig?.onboarding?.version || 0,
         default: nextConfig?.default || null,
         workflowRoutes: summarizeWorkflowRoutes(nextConfig),
+        starterGuide: storedStarterGuide(nextConfig?.onboarding?.starterGuide),
       };
     },
+    // Persist the desktop "Getting started" guide state beside the onboarding
+    // flags so it survives a lost renderer localStorage. Malformed input is
+    // rejected; a valid save merges forward, so a stale one cannot reopen a
+    // closed guide or forget a visited step.
+    saveStarterGuideState(state) {
+      const next = requiredStarterGuideState(state);
+      const config = getConfig();
+      const onboarding = config.onboarding || {};
+      saveConfigAndAdopt({
+        ...config,
+        onboarding: {
+          ...onboarding,
+          starterGuide: mergeStarterGuide(storedStarterGuide(onboarding.starterGuide), next),
+        },
+      });
+      return this.getOnboardingStatus();
+    },
     // Mark onboarding as done WITHOUT touching routes/agents/provider. Used by
     // the TUI "skip" (Esc) path so the wizard doesn't reappear next launch,
     // while leaving any existing config routes untouched.
     skipOnboarding() {
       const config = getConfig();
       const nextConfig = { ...config };
-      nextConfig.onboarding = {
+      nextConfig.onboarding = withStarterGuideOnCompletion(config.onboarding, {
         ...(nextConfig.onboarding || {}),
         completed: true,
         version: ONBOARDING_VERSION,
         completedAt: new Date().toISOString(),
         skipped: true,
-      };
+      });
       saveConfigAndAdopt(nextConfig);
       return this.getOnboardingStatus();
     },

package/src/session-runtime/starter-guide-state.mjs

@@ -0,0 +1,62 @@
+// The desktop "Getting started" guide state, kept in the config beside the
+// onboarding flags (`onboarding.starterGuide`) so it outlives the renderer's
+// localStorage. The desktop IPC gate (ipc-validation.ts) mirrors the schema.
+export const STARTER_GUIDE_STEPS = Object.freeze(['provider', 'project', 'workflow', 'extensions', 'remote']);
+const STARTER_GUIDE_KEYS = new Set(['closed', 'welcomed', 'visited']);
+
+const plainObject = (value) => Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+
+/** The guide state of a user who has not answered it yet. */
+export function freshStarterGuide() {
+  return { closed: false, welcomed: false, visited: [] };
+}
+
+/** The stored copy, read tolerantly; null when there is none. */
+export function storedStarterGuide(value) {
+  if (!plainObject(value)) return null;
+  const visited = Array.isArray(value.visited) ? value.visited : [];
+  return {
+    closed: value.closed === true,
+    welcomed: value.welcomed === true,
+    visited: STARTER_GUIDE_STEPS.filter((step) => visited.includes(step)),
+  };
+}
+
+/** A save request, read strictly: anything off-schema is rejected, never coerced. */
+export function requiredStarterGuideState(value) {
+  if (!plainObject(value)) throw new TypeError('starter guide state must be an object.');
+  for (const key of Object.keys(value)) {
+    if (!STARTER_GUIDE_KEYS.has(key)) throw new TypeError(`starter guide state has an unknown field: ${key}.`);
+  }
+  if (typeof value.closed !== 'boolean' || typeof value.welcomed !== 'boolean') {
+    throw new TypeError('starter guide closed and welcomed must be booleans.');
+  }
+  if (
+    !Array.isArray(value.visited) ||
+    value.visited.length > STARTER_GUIDE_STEPS.length * 2 ||
+    value.visited.some((step) => !STARTER_GUIDE_STEPS.includes(step))
+  ) {
+    throw new TypeError('starter guide visited must list known steps.');
+  }
+  return storedStarterGuide(value);
+}
+
+/** Every field only moves forward: a stale save can add, never undo. */
+export function mergeStarterGuide(stored, next) {
+  const base = stored || freshStarterGuide();
+  return {
+    closed: base.closed || next.closed,
+    welcomed: base.welcomed || next.welcomed,
+    visited: STARTER_GUIDE_STEPS.filter((step) => base.visited.includes(step) || next.visited.includes(step)),
+  };
+}
+
+/**
+ * The onboarding section after a completion: a first completion starts the
+ * guide fresh, so an absent copy afterwards means a profile onboarded before
+ * the guide was persisted here.
+ */
+export function withStarterGuideOnCompletion(previous, onboarding) {
+  if (previous?.completed === true || storedStarterGuide(previous?.starterGuide)) return onboarding;
+  return { ...onboarding, starterGuide: freshStarterGuide() };
+}

package/src/session-runtime/workflow-agents-api/onboarding.mjs

@@ -12,6 +12,7 @@ import {
 } from '../../runtime/agent/orchestrator/runtime-core/workflow.mjs';
 import { ONBOARDING_VERSION } from '../quick-web-search-models.mjs';
 import { canonicalizeAgentRouteStorage } from '../../runtime/shared/agent-route-config.mjs';
+import { withStarterGuideOnCompletion } from '../starter-guide-state.mjs';
 import { resolveDataDir } from './shared.mjs';
 
 // Onboarding slot picks: lead → default preset, agent → worker route,
@@ -91,12 +92,12 @@ export function createOnboardingApi(deps) {
         ]);
         nextConfig.agents = applyAgentRouteInput(agentInput, draft.agentRoutes, configurableIds);
       }
-      nextConfig.onboarding = {
+      nextConfig.onboarding = withStarterGuideOnCompletion(config.onboarding, {
         ...(nextConfig.onboarding || {}),
         completed: true,
         version: ONBOARDING_VERSION,
         completedAt: new Date().toISOString(),
-      };
+      });
       if (payload.webSearchRoute) {
         const webSearchToSave = webSearchRouteToSave(payload.webSearchRoute);
         if (webSearchToSave) nextConfig.webSearchRoute = webSearchToSave;

package/src/standalone/channel-binding.mjs

@@ -2,8 +2,7 @@ import { readFileSync, rmSync } from 'node:fs';
 import { basename } from 'node:path';
 
 export const ACTIVATE_TOOL = 'activate_channel_bridge';
-export const REBIND_TOOL = 'rebind_current_transcript';
-export const BINDING_TOOLS = new Set([ACTIVATE_TOOL, REBIND_TOOL]);
+export const BINDING_TOOLS = new Set([ACTIVATE_TOOL]);
 
 export function remoteSessionIdFromBinding(name, args) {
   if (!BINDING_TOOLS.has(name) || !args || typeof args !== 'object') return null;

package/src/standalone/channel-transport/call-dispatch.mjs

@@ -2,7 +2,7 @@
  * call-dispatch.mjs — one /call of the channel transport: the fair lanes
  * (ordinary vs. control/binding), the callId idempotency cache, and the
  * binding-aware run that moves the UI control pointer / durable pin around a
- * manual Remote ON/OFF or transcript rebind and rolls it back on failure.
+ * manual Remote ON/OFF and rolls it back on failure.
  *
  * Shared transport state read/written here: clients, pointerToken,
  * remoteAcquired, stickyRemoteFrame, pinnedSessionId, closed.
@@ -11,7 +11,7 @@ import { createFairCallScheduler } from '../fair-call-scheduler.mjs';
 import { callSignature, callIdConflict, clientCallOwner } from '../rpc-call-identity.mjs';
 import { isPidAlive } from '../../runtime/shared/pid-liveness.mjs';
 import { positiveInt } from '../../runtime/shared/numbers.mjs';
-import { ACTIVATE_TOOL, REBIND_TOOL, BINDING_TOOLS, remoteSessionIdFromBinding } from '../channel-binding.mjs';
+import { ACTIVATE_TOOL, BINDING_TOOLS, remoteSessionIdFromBinding } from '../channel-binding.mjs';
 
 const CALL_CACHE_TTL_MS = 60_000;
 
@@ -52,10 +52,10 @@ export function createCallDispatch({
     const activationCall = name === ACTIVATE_TOOL;
     const activating = activationCall && args.active === true;
     const deactivating = activationCall && args.active === false;
-    const rebindCall = name === REBIND_TOOL;
     const bindingSessionId = remoteSessionIdFromBinding(name, args);
     // Auto/implicit activation is retired. A valid manual ON always carries
-    // its target session and explicitly overrides the old one.
+    // its target session and explicitly overrides the old one. Legacy automatic
+    // requests remain non-authoritative even when they include a session id.
     if (activating && (args.claimIfVacant === true || !bindingSessionId)) {
       return {
         content: [{ type: 'text', text: 'channel bridge claim skipped: manual ON required' }],
@@ -71,12 +71,6 @@ export function createCallDispatch({
         releaseSkipped: true,
       };
     }
-    if (rebindCall && !pinnedSessionMatch) {
-      return {
-        content: [{ type: 'text', text: 'transcript rebind skipped: session is not pinned' }],
-        rebindSkipped: true,
-      };
-    }
 
     const previousPointerToken = state.pointerToken;
     const previousRemoteSessionId = c.remoteSessionId || null;

package/src/standalone/daemon-channels-loader.mjs

@@ -46,14 +46,13 @@ export function createChannelsRuntimeLoader({ log, onLoaded = () => {}, setOwner
 
   async function handleCall(name, args, ctx) {
     const module = await ensure();
-    // Accepted owner controls refresh active-instance context. The transport
-    // admits rebind only for the current manual owner.
+    // Accepted owner controls refresh active-instance context.
     if (ctx && BINDING_TOOLS.has(name)) {
       try {
         setOwnerContext({ leadPid: ctx.leadPid, cwd: ctx.cwd });
       } catch {}
     }
-    return module.handleToolCallWithBridgeRetry(name, args || {});
+    return module.handleToolCall(name, args || {});
   }
 
   return { ensure, start, handleCall };

package/src/standalone/local-session-runtime.mjs

@@ -37,90 +37,14 @@ import { tuiDebug, nextId, createTranscriptSpillBuffer } from '../tui/session/tr
 
 const SESSION_RUNTIME_MODULE = '../mixdog-session-runtime.mjs';
 
-// The runtime graph is imported lazily, but that import (measured ~250ms) used
-// to land inside the FIRST session runtime creation, which desktop performs while it
-// holds its transition lock — so the user's first navigation paid for it. Hosts
-// can start it during their own idle startup instead; the promise is shared, so
-// the create path either awaits an in-flight preload or does the import itself.
+// Shared across create calls so concurrent session startups import the
+// runtime graph once.
 let sessionRuntimeModulePromise = null;
 function importSessionRuntimeModule() {
   sessionRuntimeModulePromise ??= import(SESSION_RUNTIME_MODULE);
   return sessionRuntimeModulePromise;
 }
 
-export function preloadSessionRuntimeModule() {
-  return importSessionRuntimeModule().catch(() => {
-    // A real load failure surfaces on the authoritative create path.
-    sessionRuntimeModulePromise = null;
-  });
-}
-
-let agentLoopPrewarmPromise = null;
-export function preloadAgentLoopRuntime() {
-  agentLoopPrewarmPromise ??= import('../runtime/agent/orchestrator/session/manager/runtime-loaders.mjs').then(
-    (module) => module.prewarmAgentLoop()
-  );
-  void agentLoopPrewarmPromise.catch(() => {
-    // Reservation-time prewarm retries through the same shared loader.
-    agentLoopPrewarmPromise = null;
-  });
-  return agentLoopPrewarmPromise;
-}
-
-// Memory-runtime attach (PG proxy + embed warmup) measured ~6.5s cold and is
-// the largest first-turn blocker: loadCoreMemoryContext races it with a 2s
-// cap, but a cold attach stalls the event loop hard enough that even that
-// timer fires seconds late (probe: core-memory settle at ~6.0s). Warm the
-// EXACT shared proxy instance the session create path resolves —
-// getStandaloneMemoryRuntime caches by entry+dataDir, so the first turn finds
-// it initialized. Honors the same MIXDOG_BOOT_CORE_MEMORY opt-out.
-let memoryRuntimePrewarmPromise = null;
-export function preloadMemoryRuntime() {
-  const bootFlag = String(process.env.MIXDOG_BOOT_CORE_MEMORY ?? '')
-    .trim()
-    .toLowerCase();
-  if (bootFlag === '0' || bootFlag === 'false' || bootFlag === 'no' || bootFlag === 'off') {
-    return Promise.resolve();
-  }
-  memoryRuntimePrewarmPromise ??= (async () => {
-    const [{ getStandaloneMemoryRuntime }, { getPluginData }, { fileURLToPath }] = await Promise.all([
-      import('../session-runtime/services/memory-runtime-proxy.mjs'),
-      import('../runtime/agent/orchestrator/config.mjs'),
-      import('node:url'),
-    ]);
-    const runtime = getStandaloneMemoryRuntime({
-      entry: fileURLToPath(new URL('../runtime/memory/index.mjs', import.meta.url)),
-      dataDir: process.env.MIXDOG_DATA_DIR || getPluginData?.() || undefined,
-    });
-    await runtime.init();
-  })();
-  void memoryRuntimePrewarmPromise.catch(() => {
-    // Opportunistic: loadCoreMemoryContext retries through the same proxy.
-    memoryRuntimePrewarmPromise = null;
-  });
-  return memoryRuntimePrewarmPromise;
-}
-
-// Windows keychain reads go through a DPAPI PowerShell host whose cold start
-// dominates a packaged boot (measured ~1.5s). The runtime batches every secret
-// into one call, but it only starts that batch when the runtime is created —
-// late enough that the first context switch waits on it. Hosts can start the
-// same batch while their window is still coming up.
-let keychainPrewarmPromise = null;
-export function preloadKeychainSecrets() {
-  keychainPrewarmPromise ??= (async () => {
-    try {
-      const { createRequire } = await import('node:module');
-      const require = createRequire(import.meta.url);
-      const keychain = require('../lib/keychain-cjs.cjs');
-      await keychain.prewarmSecrets?.();
-    } catch {
-      // Prewarm is opportunistic; the runtime still warms on its own path.
-    }
-  })();
-  return keychainPrewarmPromise;
-}
-
 const TOOL_APPROVAL_TIMEOUT_MS = (() => {
   const value = Number(process.env.MIXDOG_TOOL_APPROVAL_TIMEOUT_MS);
   return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;

package/src/standalone/session-protocol.mjs

@@ -189,6 +189,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setWebhookEnabled',
   'setWorkflow',
   'setOrchestrationMode',
+  'saveStarterGuideState',
   'skipOnboarding',
   'startMediaJob',
   'switchContext',

package/src/tui/session/session-api/extensions.mjs

@@ -14,15 +14,19 @@ export function createSessionExtensionsApi(bag) {
     resetStatsAndSyncContext,
     routeState,
   });
-  // One locked runtime mutation, then republish and announce it.
+  // One locked runtime mutation, then republish and announce it. A refused
+  // change throws so a caller never reports a skipped write as saved.
   const lockedChange = (call, notice) =>
-    withCommandLock(async (...args) => {
-      const result = await call(...args);
-      refreshRouteStats();
-      const [text, level = 'info'] = notice(result, ...args);
-      pushNotice(text, level);
-      return result;
-    });
+    withCommandLock(
+      async (...args) => {
+        const result = await call(...args);
+        refreshRouteStats();
+        const [text, level = 'info'] = notice(result, ...args);
+        pushNotice(text, level);
+        return result;
+      },
+      { busyError: 'Another command is still running; try again when it finishes.' }
+    );
   const pluginLabel = (result, plugin) => result?.plugin?.title || result?.plugin?.name || plugin?.name || plugin;
 
   return {

package/src/tui/session/session-api/integrations.mjs

@@ -68,6 +68,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       // Completed-marking only; no route/agent/provider writes.
       return runtime.skipOnboarding?.() || null;
     },
+    saveStarterGuideState: (state) => runtime.saveStarterGuideState?.(state) || null,
     completeOnboarding: withCommandLock(async (payload = {}) => {
       const result = await runtime.completeOnboarding?.(payload);
       refreshRouteStats();

package/src/tui/session/session-api/shared.mjs

@@ -5,15 +5,19 @@
  */
 export function createApiHelpers({ getState, set, resetStatsAndSyncContext, routeState, syncContextStats }) {
   /**
-   * Wrap a runtime call in the command lock: refused (→ `busyResult`) while
-   * another command holds commandBusy, otherwise held for the call's duration.
-   * `onRelease` runs after the lock drops (RPC replies read the published
-   * snapshot, not the mutable draft, so some callers flush there).
+   * Wrap a runtime call in the command lock: refused (→ `busyResult`, or a
+   * thrown `busyError` for callers that must not read a refusal as success)
+   * while another command holds commandBusy, otherwise held for the call's
+   * duration. `onRelease` runs after the lock drops (RPC replies read the
+   * published snapshot, not the mutable draft, so some callers flush there).
    */
   const withCommandLock =
-    (run, { busyResult = null, onRelease = null } = {}) =>
+    (run, { busyResult = null, busyError = '', onRelease = null } = {}) =>
     async (...args) => {
-      if (getState().commandBusy) return busyResult;
+      if (getState().commandBusy) {
+        if (busyError) throw new Error(busyError);
+        return busyResult;
+      }
       set({ commandBusy: true });
       try {
         return await run(...args);

package/src/runtime/channels/tool-defs.mjs

@@ -1,17 +0,0 @@
-export const TOOL_DEFS = [
-  // reply/fetch model-facing tools removed 2026-08: the output forwarder
-  // delivers session output to the channel and the inbound bridge injects
-  // incoming messages, so the model never needed to call them directly.
-  // memory and recall_memory tools are now provided by memory-service.mjs via MCP
-  // react/edit_message/download_attachment tools removed (no remaining
-  // callers); provider editMessage/downloadAttachment/react methods stay for
-  // internal use.
-  // schedule_status/trigger_schedule/schedule_control tools removed (no
-  // remaining callers). activate_channel_bridge/reload_config are NOT model-
-  // facing tools anymore (no TOOL_DEFS entry) but the underlying
-  // channels.execute('activate_channel_bridge'|'reload_config', ...) dispatch
-  // stays alive in index.mjs/channel-worker.mjs because
-  // mixdog-session-runtime.mjs calls them directly as internal Lead-only
-  // runtime plumbing (bridge-claim on start, config hot-reload) — see
-  // reloadChannelsSoon() and the remote-start bridge claim.
-];