mixdog 0.9.19 → 0.9.20

package/scripts/tool-smoke.mjs

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { __applyStandaloneToolDefaultsForTest, __renderToolSearchForTest, compactToolSearchDescription, defaultDeferredToolNames, SKILL_TOOL, TOOL_SEARCH_TOOL } from '../src/mixdog-session-runtime.mjs';
+import { applyInitialDeferredToolManifestToBp1, buildDeferredToolManifest } from '../src/runtime/agent/orchestrator/context/collect.mjs';
 import { buildExplorerPrompt, EXPLORE_TOOL, MAX_FANOUT_QUERIES, normalizeExploreQueries } from '../src/standalone/explore-tool.mjs';
 import { AGENT_TOOL, createStandaloneAgent } from '../src/standalone/agent-tool.mjs';
 import { parseHeadlessRoleCommand } from '../src/app.mjs';
@@ -644,6 +645,72 @@ if (!/^Error[\s:[]/.test(String(stalePatchOut)) || !/apply_patch/i.test(String(s
   throw new Error(`apply_patch stale context must return an Error result, not throw or pass:\n${stalePatchOut}`);
 }
 
+// Malformed-but-unambiguous patch openings must be absorbed (dry-run, so no
+// write). Each targets the same known-good smoke.mjs line the cases above use.
+const smokeBody = `@@
+-process.stdout.write('smoke passed ✓\\n');
++process.stdout.write('smoke passed ok\\n');
+*** End Patch
+`;
+const absorbCases = [
+  ['leading blank lines', `\n\n*** Begin Patch\n*** Update File: scripts/smoke.mjs\n${smokeBody}`],
+  ['decorated begin header', `*** Begin Patch (V4A) ***\n*** Update File: scripts/smoke.mjs\n${smokeBody}`],
+  ['bare file path opening', `*** Begin Patch\nscripts/smoke.mjs\n${smokeBody}`],
+  ['File: prefixed opening', `*** Begin Patch\nFile: scripts/smoke.mjs\n${smokeBody}`],
+  ['unified body in envelope', `*** Begin Patch\n--- scripts/smoke.mjs\n+++ scripts/smoke.mjs\n${smokeBody}`],
+];
+for (const [label, patch] of absorbCases) {
+  const out = await executePatchTool('apply_patch', { base_path: root, dry_run: true, fuzzy: false, patch }, root);
+  assertOk(`apply_patch absorbs ${label}`, out, /checked|validated|dry|OK/i);
+}
+
+const ambiguousPatchOut = await executePatchTool('apply_patch', {
+  base_path: root,
+  dry_run: true,
+  fuzzy: false,
+  patch: `*** Begin Patch\nthis line is not a valid opening\n${smokeBody}`,
+}, root);
+if (!/^Error[\s:[]/.test(String(ambiguousPatchOut)) || !/before a file header|V4A/i.test(String(ambiguousPatchOut))) {
+  throw new Error(`apply_patch must keep erroring on genuinely ambiguous openings:\n${ambiguousPatchOut}`);
+}
+
+// Unified-looking first body line but real V4A file sections appear later: the
+// envelope must NOT be stripped to unified — it stays ambiguous and errors.
+const mixedPatchOut = await executePatchTool('apply_patch', {
+  base_path: root,
+  dry_run: true,
+  fuzzy: false,
+  patch: `*** Begin Patch\n--- scripts/smoke.mjs\n*** Update File: scripts/smoke.mjs\n${smokeBody}`,
+}, root);
+if (!/^Error[\s:[]/.test(String(mixedPatchOut)) || !/before a file header|V4A/i.test(String(mixedPatchOut))) {
+  throw new Error(`apply_patch must keep erroring on mixed unified/V4A openings:\n${mixedPatchOut}`);
+}
+
+// Compacted-history placeholder guard: EVERY [mixdog compacted …] variant must
+// be rejected with the corrective message BEFORE format dispatch/salvage, both
+// as the first line and standalone mid-body (after a *** Begin Patch header).
+const compactedGuardCases = [
+  ['legacy key: prefix', '[mixdog compacted patch: 4096 chars, sha256:deadbeefdeadbeef]\n*** Begin Patch\n*** Update File: a.txt\n+x\n*** End Patch\n'],
+  ['variant key form', '[mixdog compacted patch v4a, sha256:deadbeefdeadbeef]\n*** Begin Patch\n*** Update File: a.txt\n+x\n*** End Patch\n'],
+  ['no chars/sha detail', '[mixdog compacted old_string]\n'],
+  ['mid-body standalone', '*** Begin Patch\n*** Update File: a.txt\n[mixdog compacted patch v4a, sha256:deadbeefdeadbeef]\n*** End Patch\n'],
+];
+for (const [label, patch] of compactedGuardCases) {
+  const out = await executePatchTool('apply_patch', { base_path: root, dry_run: true, fuzzy: false, patch }, root);
+  if (!/^Error[\s:[]/.test(String(out)) || !/compacted-history placeholder/i.test(String(out))) {
+    throw new Error(`apply_patch must reject compacted placeholder (${label}):\n${out}`);
+  }
+}
+// A legit unified edit whose body content mentions the literal text on a diff
+// line (+/-/space) must still parse — the guard only trips on non-diff lines.
+const compactedFalsePositiveOut = await executePatchTool('apply_patch', {
+  base_path: root,
+  dry_run: true,
+  fuzzy: false,
+  patch: `*** Begin Patch\n*** Add File: compacted-note.txt\n+[mixdog compacted patch: 10 chars, sha256:abc]\n*** End Patch\n`,
+}, root);
+assertOk('apply_patch keeps diff-line placeholder text', compactedFalsePositiveOut, /checked|validated|dry|OK/i);
+
 const shellOutPromise = executeBuiltinTool('shell', {
   command: 'node --version',
   cwd: root,
@@ -1485,7 +1552,10 @@ setInternalToolsProvider({
       const resumed = await resumeSession(session.id, 'full');
       const resumedTools = (resumed?.tools || []).map((tool) => tool?.name).filter(Boolean);
       const expected = expectedForHiddenAgent(permission, schemaAllowedTools);
-      if (expected && (JSON.stringify(tools) !== JSON.stringify(expected) || JSON.stringify(resumedTools) !== JSON.stringify(expected))) {
+      // Order-insensitive: the session tool surface follows catalog order, while
+      // schemaAllowedTools declares an allow-set; only set equality is contractual.
+      const asSet = (list) => JSON.stringify(list.slice().sort());
+      if (expected && (asSet(tools) !== asSet(expected) || asSet(resumedTools) !== asSet(expected))) {
         throw new Error(`hidden agent ${agent} schema mismatch: expected=${expected.join(', ')} tools=${tools.join(', ')} resumed=${resumedTools.join(', ')}`);
       }
       const leaked = tools.filter((name) => hiddenBadTools.has(name) && !(expected || []).includes(name));
@@ -1644,15 +1714,25 @@ if (/line\/context/i.test(JSON.stringify(readTool?.inputSchema || {}))) {
   // session's provider/model in place, or a mid-conversation model/provider
   // switch silently forces a full prompt-cache rewrite (seen as a
   // promptΔ spike + cache_ratio=0% turn in session-bench).
-  const runtimeSrc = readFileSync(resolve(root, 'src/mixdog-session-runtime.mjs'), 'utf8');
+  // God-file splits move implementation into module dirs; scan facade + all
+  // split modules so these source-text guards survive refactors.
+  const readMjsSources = (rel) => {
+    const abs = resolve(root, rel);
+    if (rel.endsWith('.mjs')) return readFileSync(abs, 'utf8');
+    return readdirSync(abs, { recursive: true })
+      .filter((f) => String(f).endsWith('.mjs'))
+      .map((f) => readFileSync(resolve(abs, String(f)), 'utf8'))
+      .join('\n');
+  };
+  const runtimeSrc = [readMjsSources('src/mixdog-session-runtime.mjs'), readMjsSources('src/session-runtime')].join('\n');
   const setRouteBlock = runtimeSrc.match(/async setRoute\(next, options = \{\}\) \{[\s\S]*?\n    \},\n/)?.[0] || '';
   if (!/applyToCurrentSession = options\?\.applyToCurrentSession === true/.test(setRouteBlock)) {
     throw new Error('setRoute must default applyToCurrentSession to false (model changes apply to the next session only)');
   }
-  if (!/if \(!applyToCurrentSession\)/.test(setRouteBlock) || !/return route;/.test(setRouteBlock)) {
+  if (!/if \(!applyToCurrentSession\)/.test(setRouteBlock) || !/return (?:route|getRoute\(\));/.test(setRouteBlock)) {
     throw new Error('setRoute must early-return before touching the live session when applyToCurrentSession is false');
   }
-  const engineSrc = readFileSync(resolve(root, 'src/tui/engine.mjs'), 'utf8');
+  const engineSrc = [readMjsSources('src/tui/engine.mjs'), readMjsSources('src/tui/engine')].join('\n');
   if (/setRoute\(\{ model: m \}, \{ applyToCurrentSession: true \}\)/.test(engineSrc)) {
     throw new Error('TUI setModel must not force applyToCurrentSession:true (model changes must apply to the next session only)');
   }
@@ -1774,16 +1854,23 @@ const toolSearchSession = {
   deferredToolCatalog: smokeCatalog.slice(),
   deferredSelectedTools: [...fullDefaults],
 };
-const searchOnlyResult = JSON.parse(__renderToolSearchForTest({ query: 'shell' }, toolSearchSession, 'full'));
-for (const name of ['shell', 'task']) {
-  if (!searchOnlyResult.selected?.tools?.added?.includes(name)) {
-    throw new Error(`tool_search high-confidence query should auto-load ${name}: ${JSON.stringify(searchOnlyResult.selected)}`);
-  }
+// A plain query is a case-insensitive substring filter over name+description.
+// It lists matches only — it never auto-loads or ranks.
+const listQueryResult = JSON.parse(__renderToolSearchForTest({ query: 'shell' }, toolSearchSession, 'full'));
+if (listQueryResult.selected) {
+  throw new Error(`tool_search plain query must not auto-load: ${JSON.stringify(listQueryResult.selected)}`);
+}
+if (!listQueryResult.matches.some((row) => row.name === 'shell')) {
+  throw new Error(`tool_search plain query should list substring matches: ${JSON.stringify(listQueryResult.matches)}`);
 }
-if (!searchOnlyResult.activeTools.includes('shell') || !searchOnlyResult.activeTools.includes('task')) {
-  throw new Error(`tool_search query should activate legacy selected tools: ${searchOnlyResult.activeTools.join(',')}`);
+if (listQueryResult.activeTools.includes('shell') || (Array.isArray(listQueryResult.discoveredTools) && listQueryResult.discoveredTools.includes('shell'))) {
+  throw new Error(`tool_search plain query must not activate/discover tools: ${JSON.stringify(listQueryResult)}`);
 }
+// query "select:a,b" is the explicit query-side loader (aliases expand).
 const bulkSelectResult = JSON.parse(__renderToolSearchForTest({ query: 'select:shell,recall' }, toolSearchSession, 'full'));
+if (bulkSelectResult.selected?.mode !== 'select') {
+  throw new Error(`tool_search query-select must report select mode: ${JSON.stringify(bulkSelectResult.selected)}`);
+}
 for (const name of ['shell', 'task', 'recall']) {
   if (!bulkSelectResult.activeTools.includes(name)) {
     throw new Error(`tool_search bulk select missing ${name}: ${JSON.stringify(bulkSelectResult)}`);
@@ -1858,7 +1945,8 @@ if (nativeGrokPatchTool?.type !== 'function' || nativeGrokPatchTool?.format || n
 if (nativeGrokPatchTool.parameters?.properties?.patch?.type !== 'string') {
   throw new Error(`Grok native tool_search apply_patch must preserve patch JSON schema: ${JSON.stringify(nativeGrokPatchTool)}`);
 }
-const nativeRunQuerySession = {
+// Native query-select discovers (without mutating active schemas); aliases expand.
+const nativeSelectQuerySession = {
   tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name)),
   deferredToolCatalog: smokeCatalog.slice(),
   deferredSelectedTools: [...fullDefaults],
@@ -1866,16 +1954,20 @@ const nativeRunQuerySession = {
   deferredProviderMode: 'native',
   deferredNativeTools: true,
 };
-const nativeRunQueryResult = JSON.parse(__renderToolSearchForTest({ query: 'run tests' }, nativeRunQuerySession, 'full'));
-for (const name of ['shell', 'task']) {
-  if (!nativeRunQueryResult.discoveredTools.includes(name)) {
-    throw new Error(`native tool_search run/tests query should discover ${name}: ${JSON.stringify(nativeRunQueryResult)}`);
+const nativeSelectQueryResult = JSON.parse(__renderToolSearchForTest({ query: 'select:search' }, nativeSelectQuerySession, 'full'));
+for (const name of ['search', 'web_fetch']) {
+  if (!nativeSelectQueryResult.discoveredTools.includes(name)) {
+    throw new Error(`native tool_search query-select should discover ${name}: ${JSON.stringify(nativeSelectQueryResult)}`);
   }
 }
-if (nativeRunQueryResult.activeTools.includes('shell') || nativeRunQueryResult.activeTools.includes('task')) {
-  throw new Error(`native tool_search query must not mutate active schemas: ${JSON.stringify(nativeRunQueryResult)}`);
+if (nativeSelectQueryResult.activeTools.includes('search') || nativeSelectQueryResult.activeTools.includes('web_fetch')) {
+  throw new Error(`native tool_search must not mutate active schemas: ${JSON.stringify(nativeSelectQueryResult)}`);
+}
+if (!nativeSelectQueryResult.nativeToolSearch?.toolReferences?.includes('search')) {
+  throw new Error(`native query-select must return nativeToolSearch payload: ${JSON.stringify(nativeSelectQueryResult.nativeToolSearch)}`);
 }
-const nativeWebQuerySession = {
+// A plain query never auto-loads/discovers, even on native providers.
+const nativePlainQuerySession = {
   tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name)),
   deferredToolCatalog: smokeCatalog.slice(),
   deferredSelectedTools: [...fullDefaults],
@@ -1883,35 +1975,48 @@ const nativeWebQuerySession = {
   deferredProviderMode: 'native',
   deferredNativeTools: true,
 };
-const nativeWebQueryResult = JSON.parse(__renderToolSearchForTest({ query: 'web docs' }, nativeWebQuerySession, 'full'));
-for (const name of ['search', 'web_fetch']) {
-  if (!nativeWebQueryResult.discoveredTools.includes(name)) {
-    throw new Error(`native tool_search web/docs query should discover ${name}: ${JSON.stringify(nativeWebQueryResult)}`);
+for (const q of ['run tests', 'web docs', 'memory previous', 'status']) {
+  const r = JSON.parse(__renderToolSearchForTest({ query: q }, nativePlainQuerySession, 'full'));
+  if (r.selected || r.discoveredTools.length) {
+    throw new Error(`native tool_search plain query "${q}" must not auto-load/discover: ${JSON.stringify(r)}`);
   }
 }
-const nativeRecallQuerySession = {
-  tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name)),
-  deferredToolCatalog: smokeCatalog.slice(),
-  deferredSelectedTools: [...fullDefaults],
-  deferredDiscoveredTools: [],
-  deferredProviderMode: 'native',
-  deferredNativeTools: true,
+// Skill-style deferred manifest: `- name: description` lines, `<`/`>` sanitized,
+// bare names allowed, header instructs direct calls, empty pool → ''.
+const manifestText = buildDeferredToolManifest([
+  { name: 'shell', description: 'Run commands.' },
+  { name: 'search', description: 'Web <search> now.' },
+  'recall',
+]);
+if (!/<available-deferred-tools>/.test(manifestText) || !/- shell: Run commands\./.test(manifestText)) {
+  throw new Error(`deferred manifest must render "- name: description" lines: ${manifestText}`);
+}
+if (!/call any tool listed below directly/i.test(manifestText)) {
+  throw new Error(`deferred manifest must tell the model it can call listed tools directly: ${manifestText}`);
+}
+if (!/^- recall$/m.test(manifestText)) {
+  throw new Error(`deferred manifest must allow bare names without descriptions: ${manifestText}`);
+}
+if (/[<>]/.test(manifestText.replace(/<\/?available-deferred-tools>/g, ''))) {
+  throw new Error(`deferred manifest must sanitize angle brackets in descriptions: ${manifestText}`);
+}
+if (buildDeferredToolManifest([]) !== '') {
+  throw new Error('empty deferred pool must yield an empty manifest');
+}
+const bp1ManifestSession = {
+  messages: [{ role: 'system', content: 'BASE PROMPT' }],
+  deferredToolCatalog: [
+    { name: 'shell', description: 'Run commands.' },
+    { name: 'recall', description: 'Recall prior work.' },
+  ],
 };
-const nativeRecallQueryResult = JSON.parse(__renderToolSearchForTest({ query: 'memory previous' }, nativeRecallQuerySession, 'full'));
-if (!nativeRecallQueryResult.discoveredTools.includes('recall') || nativeRecallQueryResult.discoveredTools.includes('memory')) {
-  throw new Error(`native tool_search memory previous should discover recall only: ${JSON.stringify(nativeRecallQueryResult)}`);
+applyInitialDeferredToolManifestToBp1(bp1ManifestSession, ['shell', 'recall']);
+const bp1ManifestText = bp1ManifestSession.messages[0].content;
+if (!/- shell: Run commands\./.test(bp1ManifestText) || !/- recall: Recall prior work\./.test(bp1ManifestText)) {
+  throw new Error(`BP1 deferred manifest must carry catalog descriptions: ${bp1ManifestText}`);
 }
-const ambiguousStatusSession = {
-  tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name)),
-  deferredToolCatalog: smokeCatalog.slice(),
-  deferredSelectedTools: [...fullDefaults],
-  deferredDiscoveredTools: [],
-  deferredProviderMode: 'native',
-  deferredNativeTools: true,
-};
-const ambiguousStatusResult = JSON.parse(__renderToolSearchForTest({ query: 'status' }, ambiguousStatusSession, 'full'));
-if (ambiguousStatusResult.selected || ambiguousStatusResult.discoveredTools.length) {
-  throw new Error(`tool_search ambiguous status query must not auto-load: ${JSON.stringify(ambiguousStatusResult)}`);
+if (bp1ManifestSession.deferredToolBp1Applied !== true) {
+  throw new Error('BP1 deferred manifest injection must mark deferredToolBp1Applied');
 }
 const replyTool = CHANNEL_TOOL_DEFS.find((tool) => tool.name === 'reply');
 if (!/configured channel/i.test(replyTool?.description || '') || !/local .*paths/i.test(replyTool?.inputSchema?.properties?.files?.description || '')) {

package/src/help.mjs

@@ -1,6 +1,6 @@
 import { stdout } from 'node:process';
 
-/** Help text shared by `--help` and the `/help` slash command. */
+/** Help text printed by `--help`. */
 export const HELP_LINES = [
   'mixdog — standalone mixdog CLI/TUI coding agent.',
   '',
@@ -11,16 +11,13 @@ export const HELP_LINES = [
   '  mixdog --help',
   '',
   'Slash commands (inside mixdog):',
-  '  /help              show this help',
   '  /clear             reset the conversation and clear the screen',
   '  /compact           compact older conversation context',
   '  /model <name>      switch model/preset for subsequent turns',
   '  /OutputStyle [name] show or switch Lead output style',
   '  /providers         manage provider auth and local endpoints',
   '  /agents            show available workflow agents',
-  '  /agent             manage active agents and async tasks',
-  '  /mode <name>       switch tool surface: full | readonly',
-  '  /exit              quit',
+  '  /quit              quit (aliases: /exit, /q)',
   '',
   'History: use ↑ / ↓ to recall previous inputs.',
 ];

package/src/lib/mixdog-debug.cjs

@@ -36,6 +36,10 @@ const CANONICAL_PLUGIN_LOG_NAMES = new Set([
   'session-start-critical.log',
   'webhook.log',
   'perf.log',
+  'tool-events.log',
+  'memory-runtime-proxy.log',
+  'channels-worker-standalone.log',
+  'mixdog-tui.stderr.log',
 ]);
 
 /**
@@ -113,6 +117,12 @@ function rotateBoundedLog(filePath, maxBytes, keepBytes) {
   } catch { /* missing file ok */ }
 }
 
+// Shared bound for unbounded per-writer plugin logs (tool-events,
+// memory-runtime-proxy, channels-worker-standalone). Keep a tail so recent
+// context survives rotation while the file stays under the 10 MB cap.
+const PLUGIN_LOG_MAX_BYTES = 10 * 1024 * 1024;
+const PLUGIN_LOG_KEEP_BYTES = 2 * 1024 * 1024;
+
 /**
  * Ship-mode durable fail-open record (size-capped). No-op when line empty.
  */
@@ -131,4 +141,7 @@ module.exports = {
   pruneStalePluginDataLogSiblings,
   appendSessionStartCriticalLog,
   DEFAULT_STALE_LOG_SIBLING_MAX,
+  rotateBoundedLog,
+  PLUGIN_LOG_MAX_BYTES,
+  PLUGIN_LOG_KEEP_BYTES,
 };