mixdog 1.3.5 → 1.4.0

package/src/runtime/agent/orchestrator/config.mjs

@@ -41,6 +41,10 @@ import {
   removeRetiredAgentFields,
 } from './config-storage.mjs';
 import { oauthCredentialProbeState, isOAuthProviderAvailable } from './providers/oauth-credential-probes.mjs';
+import {
+  DEFAULT_HEARTBEAT_INTERVAL_MINUTES,
+  normalizeHeartbeatIntervalMinutes,
+} from '../../shared/heartbeat-interval.mjs';
 import { normalizeDeveloperConfig } from '../../shared/developer-options.mjs';
 import { normalizeWorktreeSettings } from '../../shared/worktrees/settings.mjs';
 import { normalizePluginMcpIntents } from './runtime-core/plugin-mcp.mjs';
@@ -295,8 +299,13 @@ export function loadConfig(options = {}) {
         recap: recapConfig,
         // The model may title the session (session tool, action=rename); default on.
         aiSessionTitles: raw.aiSessionTitles !== false,
-        // Mixy's 2-hourly heartbeat check (session-runtime/mixy-heartbeat.mjs); default on.
+        // Mixy's heartbeat check (session-runtime/mixy-heartbeat.mjs); default on.
         heartbeat: raw.heartbeat !== false,
+        // Minutes between its checks, one of a fixed set (shared/heartbeat-interval.mjs);
+        // anything else reads as the default.
+        heartbeatIntervalMinutes: normalizeHeartbeatIntervalMinutes(raw.heartbeatIntervalMinutes),
+        // Prompt-cache warming (session/cache-warm.mjs); default on.
+        promptCacheWarming: raw?.promptCacheWarming !== false,
         // Bots may leave an emoji reaction on the user's message (react tool); default on.
         reactions: raw.reactions !== false,
         // Bots page layout (order, hidden groups, pins, retention) and the shared
@@ -351,6 +360,7 @@ export function loadConfig(options = {}) {
     shell: {},
     update: {},
     recap: { enabled: true },
+    promptCacheWarming: true,
     worktree: normalizeWorktreeSettings(null),
     developer: {},
     modules: {},
@@ -482,8 +492,14 @@ function buildAgentSaveBuilder(config) {
     else delete next.aiSessionTitles;
     if (config.heartbeat === false) next.heartbeat = false;
     else delete next.heartbeat;
+    // Only a non-default choice is stored.
+    const heartbeatMinutes = normalizeHeartbeatIntervalMinutes(config.heartbeatIntervalMinutes);
+    if (heartbeatMinutes !== DEFAULT_HEARTBEAT_INTERVAL_MINUTES) next.heartbeatIntervalMinutes = heartbeatMinutes;
+    else delete next.heartbeatIntervalMinutes;
     if (config.reactions === false) next.reactions = false;
     else delete next.reactions;
+    if (config.promptCacheWarming === false) next.promptCacheWarming = false;
+    else delete next.promptCacheWarming;
     if (Array.isArray(config.botOrder) && config.botOrder.length) next.botOrder = [...config.botOrder];
     else delete next.botOrder;
     if (config.leadAvatar && typeof config.leadAvatar === 'object') next.leadAvatar = { ...config.leadAvatar };

package/src/runtime/agent/orchestrator/context/collect.mjs

@@ -1,6 +1,7 @@
 export {
   applyInitialDeferredToolManifestToBp2,
   buildDeferredToolManifest,
+  resetBp2StableContext,
   stripDeferredToolManifestBlock,
 } from './deferred-tools.mjs';
 export {
@@ -11,11 +12,13 @@ export {
   collectPromptSkillsCached,
   collectSkills,
   collectSkillsCached,
+  currentSkillDelivery,
   filterSkillsExcludingDisabled,
   invalidateSkillsCache,
   isSkillDisabled,
   loadSkillResource,
   skillBodyPresentInSession,
+  skillLoadRefusal,
   skillMissingFeature,
   skillOutsideScope,
   skillEnabledFlags,

package/src/runtime/agent/orchestrator/context/deferred-tools.mjs

@@ -1,7 +1,11 @@
-// Deferred-pool and MCP-instruction manifests injected into BP2.
-import { accountOfInstructions } from '../../../shared/connector-accounts.mjs';
+// Deferred-pool manifest injected into BP2. MCP server instruction bodies are
+// not injected: a server's one-line entry is its when-to-use trigger (accounts
+// one line per server), and its instructions arrive with its tools
+// on load_tool. The <mcp-instructions> block is still recognized so older
+// prompts can shed it.
 import { connectorTrigger } from '../../../shared/connector-triggers.mjs';
 import { parseMcpToolName, titleCaseMcpServer } from '../../../shared/tool-primitives.mjs';
+import { SKILL_TRIGGER_LISTING_MAX } from '../../../shared/skill-document.mjs';
 import { isToolBridgeEnabled, TOOL_BRIDGE_GUIDANCE } from '../runtime-core/tool-exposure.mjs';
 
 export function compactPromptManifestText(value, max = 250) {
@@ -24,13 +28,24 @@ const MCP_INSTRUCTIONS_BLOCK_RE = /(\n\n---\n*)?<mcp-instructions>[\s\S]*?<\/mcp
 // Tool and MCP server names enter the manifests only as plain identifiers
 // (no markup can be smuggled into the prompt through a name).
 const MANIFEST_NAME_SAFE_RE = /^[A-Za-z0-9_.:-]+$/;
-const MCP_INSTRUCTION_MAX_CHARS = 600;
 
 function sanitizeManifestName(name) {
   const text = String(name || '').trim();
   return MANIFEST_NAME_SAFE_RE.test(text) ? text : '';
 }
 
+const MCP_INSTRUCTION_MAX_CHARS = 600;
+
+/** A server's instruction text without markup, capped at MCP_INSTRUCTION_MAX_CHARS. */
+export function sanitizeMcpInstructionText(text, max = MCP_INSTRUCTION_MAX_CHARS) {
+  const stripped = String(text || '')
+    .replace(/[<>]/g, '')
+    .trim();
+  if (!stripped) return '';
+  const cap = Math.max(1, Number(max) || MCP_INSTRUCTION_MAX_CHARS);
+  return stripped.length > cap ? `${stripped.slice(0, Math.max(1, cap - 3))}...` : stripped;
+}
+
 function skillRoutedToolNames(messages) {
   const names = new Set();
   for (const message of Array.isArray(messages) ? messages : []) {
@@ -63,7 +78,8 @@ function hasDeferredToolManifestBlock(text) {
  * wire tools). Each entry is either a bare name string or `{ name, description }`;
  * output lines are `- name: description` (description omitted when absent),
  * mirroring the available-skills manifest so the model calls deferred tools
- * directly. Descriptions are compacted and stripped of `<`/`>`.
+ * directly. Descriptions are compacted to the skill listing's trigger cap
+ * (skill-document.mjs SKILL_TRIGGER_LISTING_MAX) and stripped of `<`/`>`.
  * Empty pool → '' (caller omits the block).
  */
 export function buildDeferredToolManifest(entries) {
@@ -77,7 +93,7 @@ export function buildDeferredToolManifest(entries) {
     const description =
       typeof entry === 'string'
         ? ''
-        : compactPromptManifestText(String(entry?.description || '').replace(/[<>]/g, ''), 100);
+        : compactPromptManifestText(String(entry?.description || '').replace(/[<>]/g, ''), SKILL_TRIGGER_LISTING_MAX);
     list.push({ name, description });
   }
   if (!list.length) return '';
@@ -90,49 +106,6 @@ export function buildDeferredToolManifest(entries) {
   ].join('\n');
 }
 
-function sanitizeMcpInstructionText(text, max = MCP_INSTRUCTION_MAX_CHARS) {
-  const stripped = String(text || '')
-    .replace(/[<>]/g, '')
-    .trim();
-  if (!stripped) return '';
-  const cap = Math.max(1, Number(max) || MCP_INSTRUCTION_MAX_CHARS);
-  return stripped.length > cap ? `${stripped.slice(0, Math.max(1, cap - 3))}...` : stripped;
-}
-
-/**
- * Per-server MCP initialize instructions for deferred-pool tools only.
- * Empty when no instructions or no matching deferred MCP tools → omit block.
- * Emits ONLY the server heading + instruction body: tool names are never
- * listed — <available-deferred-tools> names each server once (mcp__<server>).
- */
-function buildMcpInstructionsManifest(mcpServerInstructions, poolNames, catalog = []) {
-  const map = mcpServerInstructions && typeof mcpServerInstructions === 'object' ? mcpServerInstructions : {};
-  const pool = [
-    ...new Set((Array.isArray(poolNames) ? poolNames : []).map((name) => sanitizeManifestName(name)).filter(Boolean)),
-  ];
-  // Tool definitions carry their server (shortened names cannot be parsed).
-  const byName = new Map();
-  for (const tool of Array.isArray(catalog) ? catalog : []) {
-    const name = String(tool?.name || '').trim();
-    if (name && !byName.has(name)) byName.set(name, tool);
-  }
-  const deferredServers = new Set();
-  for (const name of pool) {
-    const server = parseMcpToolName(byName.get(name) || name)?.server;
-    if (server) deferredServers.add(server);
-  }
-  const servers = [...deferredServers]
-    .filter((server) => sanitizeManifestName(server) && sanitizeMcpInstructionText(map[server]))
-    .sort((a, b) => a.localeCompare(b));
-  if (!servers.length) return '';
-  const lines = ['<mcp-instructions>'];
-  for (const server of servers) {
-    lines.push(`## ${sanitizeManifestName(server)}`, sanitizeMcpInstructionText(map[server]));
-  }
-  lines.push('</mcp-instructions>');
-  return lines.join('\n');
-}
-
 export function stripDeferredToolManifestBlock(text) {
   return String(text || '')
     .replace(DEFERRED_TOOLS_BLOCK_RE, '')
@@ -144,9 +117,8 @@ export function stripDeferredToolManifestBlock(text) {
 // Rebuild path: replace the FIRST previously-injected <available-deferred-tools>
 // block (with its leading `---` separator) with the fresh manifest IN PLACE, so
 // the block keeps its original position and no sibling BP2 block (skills
-// manifest, agent rules, …) is reordered or dropped. The fresh manifest already
-// carries the mcp-instructions companion, so any pre-existing standalone one is
-// removed first to avoid duplication.
+// manifest, agent rules, …) is reordered or dropped. A legacy <mcp-instructions>
+// block left by older sessions is removed first.
 function rebuildDeferredToolManifestBlock(text, manifest) {
   let out = String(text || '').replace(MCP_INSTRUCTIONS_BLOCK_RE, '');
   let replaced = false;
@@ -183,24 +155,50 @@ const firstSentence = (text) => {
   return (flat.split(/(?<=[.!?])\s/, 1)[0] || flat).replace(/[.!?]+$/, '');
 };
 
-// A catalog connector's curated trigger; else the server's MCP instructions;
-// else its tools' leading descriptions (name order); else its name. Derived
-// lines are compacted to at most 100 characters, ellipsis included.
+// A catalog connector's curated when-to-use trigger; else the first sentence
+// of the server's MCP instructions; else its tools' leading descriptions (name
+// order); else its name. Never the account: that is part of the instruction
+// text delivered when the server's tools are loaded. Derived lines are
+// compacted to at most 98 characters, ellipsis included.
 function mcpServerTrigger(server, tools, instructions) {
-  // A multi-account connector's server names its account (connector-accounts.mjs).
-  const account = accountOfInstructions(instructions?.[server]);
   const curated = connectorTrigger(server);
-  if (curated) return account ? `${curated} Account: ${account}` : curated;
-  const instruction = String(instructions?.[server] || '').replace(/[<>]/g, '');
+  if (curated) return curated;
+  // The account sentence ("Account: <address>. …", connector-accounts.mjs) is
+  // not a use line; it reaches the model with the loaded server's instructions.
+  const instruction = String(instructions?.[server] || '')
+    .replace(/[<>]/g, '')
+    .replace(/^\s*Account: \S+?\.\s+/, '');
   const described = [...tools]
     .sort((a, b) => String(a?.name || '').localeCompare(String(b?.name || '')))
     .map((tool) => firstSentence(String(tool?.description || '').replace(/[<>]/g, '')))
     .filter(Boolean)
     .join('; ');
-  const derived = instruction.trim() ? instruction : described;
+  const derived = firstSentence(instruction) || described;
   return derived ? compactPromptManifestText(derived, 98) : `${titleCaseMcpServer(server)} MCP server tools.`;
 }
 
+// `mcp__<server>` as the manifest names it, or '' for an unsafe server name.
+export const mcpServerManifestLabel = (server) => sanitizeManifestName(mcpServerLineName(server));
+
+/**
+ * One `{ label: 'mcp__<server>', trigger }` line per server of `servers` (Map
+ * server → its tools). The BP2 manifest and the deferred-tool delta both
+ * render these; a server with an unsafe name gets none.
+ */
+export function mcpServerLines(servers, instructions) {
+  const lines = [];
+  for (const [server, tools] of servers) {
+    const label = mcpServerManifestLabel(server);
+    if (!label) continue;
+    const trigger = compactPromptManifestText(
+      String(mcpServerTrigger(server, tools, instructions)).replace(/[<>]/g, ''),
+      SKILL_TRIGGER_LISTING_MAX
+    );
+    lines.push({ label, trigger });
+  }
+  return lines;
+}
+
 function deferredManifestEntries(session, pool) {
   const byName = catalogByName(session);
   const skillRoutedNames = skillRoutedToolNames(session.messages);
@@ -221,11 +219,8 @@ function deferredManifestEntries(session, pool) {
       description: skillRoutedNames.has(key) ? '' : String(tool?.trigger || tool?.description || ''),
     });
   }
-  for (const [server, tools] of servers) {
-    entries.push({
-      name: mcpServerLineName(server),
-      description: mcpServerTrigger(server, tools, session.mcpServerInstructions),
-    });
+  for (const line of mcpServerLines(servers, session.mcpServerInstructions)) {
+    entries.push({ name: line.label, description: line.trigger });
   }
   return entries;
 }
@@ -241,7 +236,7 @@ export function listedDeferredToolNames(session, poolNames, rendered) {
 }
 
 function composeDeferredBp2Manifest(session, pool) {
-  // Bridge exposure gets the native roster and MCP instructions (the pool is
+  // Bridge exposure gets the native roster (the pool is
   // already limited to what the session's policy lets it run), followed by
   // the static bridge guidance. A tool-free bridge session gets nothing.
   const bridge = isToolBridgeEnabled(session);
@@ -249,8 +244,6 @@ function composeDeferredBp2Manifest(session, pool) {
   const parts = [];
   const deferredManifest = buildDeferredToolManifest(deferredManifestEntries(session, pool));
   if (deferredManifest) parts.push(deferredManifest);
-  const mcpManifest = buildMcpInstructionsManifest(session.mcpServerInstructions, pool, session.deferredToolCatalog);
-  if (mcpManifest) parts.push(mcpManifest);
   if (bridge) parts.push(TOOL_BRIDGE_GUIDANCE);
   return parts.join('\n\n');
 }
@@ -292,6 +285,18 @@ function resolveDeferredBp2Index(session) {
   return idx;
 }
 
+/**
+ * Give BP2 `stableContext` (profile meta + skill manifest) and no deferred
+ * manifest. The caller re-applies that manifest
+ * (applyInitialDeferredToolManifestToBp2 with `rebuild`), which appends it
+ * after the stable part exactly as session creation laid it out.
+ */
+export function resetBp2StableContext(session, stableContext) {
+  if (!Array.isArray(session?.messages)) return;
+  const idx = resolveDeferredBp2Index(session);
+  if (idx >= 0) setSystemContent(session, idx, String(stableContext || ''));
+}
+
 function writeDeferredManifestAt(session, idx, manifest, rebuild) {
   for (let i = 0; i < session.messages.length; i++) {
     if (i === idx || session.messages[i]?.role !== 'system' || typeof session.messages[i].content !== 'string')

package/src/runtime/agent/orchestrator/context/skill-catalog.mjs

@@ -304,6 +304,31 @@ export function skillOutsideScopeError(name) {
   return `Error: skill "${name}" is not available in this project (its project scope excludes the current folder)`;
 }
 
+/** Why the Skill tool refuses `name` at `cwd` now (missing feature, switched
+ *  off, outside the project scope), or null when nothing refuses it. `config`
+ *  and `skills` let a batch of checks share one config read and one scan. */
+export function skillLoadRefusal(name, cwd, config = null, skills = null) {
+  const missing = skillMissingFeature(name, config, skills);
+  if (missing) {
+    return `Error: skill "${name}" needs the ${missing} built-in feature, which is not installed or is switched off in Extensions → Plugin → Built-in`;
+  }
+  if (isSkillDisabled(name, config, skills)) return `Error: skill "${name}" is disabled`;
+  if (skillOutsideScope(name, cwd, config, skills)) return skillOutsideScopeError(name);
+  return null;
+}
+
+/**
+ * What the Skill tool would deliver for `name` at `cwd` now: the injected
+ * `<skill>` body and the resource it came from, or null when the skill no
+ * longer loads there (refused by skillLoadRefusal, or removed).
+ */
+export function currentSkillDelivery(name, cwd, config = null, skills = null) {
+  if (skillLoadRefusal(name, cwd, config, skills)) return null;
+  const resource = loadSkillResource(name, cwd);
+  if (!resource) return null;
+  return { body: buildSkillResultEnvelope(name, resource.content, resource.dir), resource };
+}
+
 /**
  * Skills a session may see: not switched off, feature available, and — when
  * `cwd` is given — inside the skill's (or its plugin's) project scope. Without
@@ -348,11 +373,16 @@ const _skillsCache = new Map();
 // every plain-file gate path are stat'ed on every call as before.
 const _ROOT_WATCH_LIMIT = 64;
 const _rootWatches = new Map(); // root -> { watcher, dirty, text, settled }
+// Bumped by every closed root watch; part of each cached SKILL.md text stamp.
+let _skillTextGeneration = 0;
 
 function _closeRootWatch(root) {
   const watch = _rootWatches.get(root);
   if (!watch) return;
   _rootWatches.delete(root);
+  // Any change under a skill root (or a lost watcher, or an invalidation)
+  // makes the next load re-read SKILL.md text, whatever the file stamps say.
+  _skillTextGeneration += 1;
   try {
     watch.watcher.close();
   } catch {
@@ -452,6 +482,26 @@ export function skillExecutionDir(dir, source) {
   return String(dir).replace(/([\\/])runtime\.asar(?=[\\/]|$)/, '$1runtime.asar.unpacked');
 }
 
+// SKILL.md text per catalog entry, with the stamp it was read at: the
+// file's own mtime and size (any depth) plus the skills watcher generation
+// (an edit that keeps both, e.g. inside one timestamp tick).
+const _skillFileText = new WeakMap();
+
+function skillFileText(skill) {
+  let stamp;
+  try {
+    const stat = statSync(skill.filePath);
+    stamp = `${_skillTextGeneration}:${stat.mtimeMs}:${stat.size}`;
+  } catch {
+    return null;
+  }
+  const cached = _skillFileText.get(skill);
+  if (cached?.stamp === stamp) return cached.text;
+  const text = readSafe(skill.filePath);
+  _skillFileText.set(skill, { stamp, text });
+  return text;
+}
+
 /**
  * Load full skill content plus its on-disk directory (for base-dir + ${MIXDOG_SKILL_DIR};
  * ${MIXDOG_SKILL_NODE} is resolved at render time in buildSkillResultEnvelope).
@@ -462,7 +512,10 @@ export function loadSkillResource(name, cwd) {
   const skills = collectSkillsCached(cwd);
   const skill = skills.find((s) => s.name === skillName);
   if (!skill) return null;
-  const content = readSafe(skill.filePath);
+  // The catalog's freshness signature does not see every nested SKILL.md, so
+  // the text follows the file itself: one stat per load, re-read only when
+  // that file's own mtime or size moved.
+  const content = skillFileText(skill);
   if (content == null) return null;
   try {
     return {

package/src/runtime/agent/orchestrator/mcp/agent-connectors.mjs

@@ -203,7 +203,7 @@ export function readProjectConnectorsFile(path) {
   });
 }
 
-export function projectConnectorPolicies(dataDir = resolvePluginData()) {
+function projectConnectorPolicies(dataDir = resolvePluginData()) {
   return cachedRead(join(dataDir, PROJECT_CONNECTORS_FILE), readProjectConnectorsFile);
 }
 
@@ -219,7 +219,7 @@ export function connectorToolPermission(policy, toolOrName) {
   return policy?.tools?.[mcp.server]?.[mcp.tool] || connectorToolDefault(serverConnector(mcp.server), mcp.tool);
 }
 
-const PERMISSION_RANK = Object.freeze({ disabled: 0, needs_approval: 1, auto: 2 });
+export const PERMISSION_RANK = Object.freeze({ disabled: 0, needs_approval: 1, auto: 2 });
 export const NO_WIDEN_MESSAGE = 'This change would widen what the bot may do without asking; make it on the desktop.';
 
 /** Whether replacing the stored policy `before` (a stored value, a parsed
@@ -229,7 +229,7 @@ export const NO_WIDEN_MESSAGE = 'This change would widen what the bot may do wit
  *  default, which is `needs_approval` for a catalog connector's high-risk
  *  tools and `auto` otherwise). A legacy allow list or an unreadable policy is
  *  not compared: it counts as widening. */
-export function connectorPolicyWidens(before, after) {
+function connectorPolicyWidens(before, after) {
   let old;
   try {
     old = before == null ? { off: [], tools: {} } : parseConnectorPolicy(before);