mixdog 0.9.14 → 0.9.16

package/scripts/tui-frame-harness-shim.mjs

@@ -0,0 +1,32 @@
+// Mirror of vendor/ink/build/ink.js shouldClearTerminalForFrame, with the
+// Windows branch parameterized so the harness can probe both platforms without
+// relying on process.platform. Kept byte-faithful to the source predicate so
+// the harness reflects real clear decisions.
+export function shouldClearTerminalForFrameProbe({
+  isTty, viewportRows, previousViewportRows, previousOutputHeight,
+  nextOutputHeight, isUnmounting, isWindows,
+}) {
+  if (!isTty) return false;
+  const priorViewportRows = previousViewportRows ?? viewportRows;
+  const hadPreviousFrame = previousOutputHeight > 0;
+  const wasFullscreen = previousOutputHeight >= priorViewportRows;
+  const wasOverflowing = previousOutputHeight > priorViewportRows;
+  const isOverflowing = nextOutputHeight > viewportRows;
+  const isFullscreen = nextOutputHeight >= viewportRows;
+  const isLeavingFullscreen = wasFullscreen && nextOutputHeight < viewportRows;
+  const isShrinkingAtViewport = hadPreviousFrame &&
+    nextOutputHeight < previousOutputHeight &&
+    (wasFullscreen || isFullscreen || wasOverflowing || isOverflowing);
+  const shouldClearOnUnmount = isUnmounting && wasFullscreen;
+  const viewportResized = previousViewportRows != null && previousViewportRows !== viewportRows;
+  if (isWindows && (wasFullscreen || isFullscreen) &&
+      (viewportResized || isShrinkingAtViewport || isLeavingFullscreen)) {
+    return true;
+  }
+  return (
+    wasOverflowing ||
+    (isOverflowing && hadPreviousFrame) ||
+    isLeavingFullscreen ||
+    isShrinkingAtViewport ||
+    shouldClearOnUnmount);
+}

package/scripts/tui-frame-harness.mjs

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+/**
+ * scripts/tui-frame-harness.mjs — renderer-level frame-grid evidence harness.
+ *
+ * Drives vendor/ink log-update createIncremental(fakeStream) through the SAME
+ * wrapper logic ink.js renderInteractiveFrame() applies (fullscreen detect +
+ * trailing-newline normalization + shouldClearTerminalForFrame), replays the
+ * emitted ANSI into a minimal VT grid interpreter, and asserts the absolute row
+ * of a tracked marker line (the "prompt" / "statusline") across each frame.
+ *
+ * A deviant frame = the marker's absolute row changes for a single frame then
+ * snaps back. That is the one-row-low dip reported under Windows Terminal.
+ *
+ * Run: node scripts/tui-frame-harness.mjs
+ */
+// [harness] log-update reads process.platform/WT_SESSION AT IMPORT to pick its
+// Windows-safe absolute-cursor branch. Force WT_SESSION on BEFORE importing it
+// so POSIX/CI runs exercise the same branch WT users hit. Must precede the
+// dynamic import below.
+process.env.WT_SESSION = process.env.WT_SESSION || '1';
+const { default: logUpdate } = await import('../vendor/ink/build/log-update.js');
+const { shouldClearTerminalForFrameProbe } = await import('./tui-frame-harness-shim.mjs');
+const { default: ansiEscapes } = await import('ansi-escapes');
+
+// Fail loudly if the Windows-safe branch is NOT engaged: without it the harness
+// silently tests the wrong path and reports a false pass. Probe by driving a
+// fullscreen→one-short pair through a throwaway log and asserting the branch's
+// absolute cursorTo(0,y) addressing (not a relative cursorUp walk) is emitted.
+function assertWindowsBranchEngaged() {
+  const chunks = [];
+  const fs = { write: (s) => { chunks.push(s); return true; }, isTTY: true, columns: 20, rows: 4 };
+  const log = logUpdate.create(fs, { incremental: true });
+  log.sync('a\nb\nc\nd');            // 4 lines, fullscreen, no trailing nl
+  chunks.length = 0;
+  log('a\nX\nc\nd');                 // change one middle row, still fullscreen
+  const emitted = chunks.join('');
+  // Windows-safe branch uses absolute cursorTo(0, i) => CSI <row>;1H. The POSIX
+  // relative branch uses cursorUp / cursorNextLine (CSI A / E) with no ;1H rows.
+  const hasAbsolute = /\x1b\[\d+;1H/.test(emitted);
+  if (!hasAbsolute) {
+    console.error('tui-frame-harness: FAIL — log-update Windows-safe branch NOT engaged '
+      + '(WT_SESSION/platform did not force it at import). Emitted:', JSON.stringify(emitted));
+    process.exit(1);
+  }
+}
+assertWindowsBranchEngaged();
+
+// ---- Minimal VT grid interpreter -----------------------------------------
+// Supports the escapes log-update / ink emit: cursorTo(x[,y]), cursorUp/Down/
+// NextLine, eraseLine, eraseEndLine, eraseLines(n), clearTerminal, plain text,
+// newline, SGR (ignored for geometry), hide/show cursor (ignored).
+class VT {
+  constructor(rows, cols) {
+    this.rows = rows;
+    this.cols = cols;
+    this.grid = Array.from({ length: rows }, () => '');
+    this.cx = 0;
+    this.cy = 0;
+  }
+  _clampRow() { if (this.cy < 0) this.cy = 0; if (this.cy >= this.rows) this.cy = this.rows - 1; }
+  write(data) {
+    let i = 0;
+    while (i < data.length) {
+      const ch = data[i];
+      if (ch === '\u001B') {
+        // CSI
+        if (data[i + 1] === '[') {
+          let j = i + 2;
+          let params = '';
+          while (j < data.length && /[0-9;]/.test(data[j])) { params += data[j]; j++; }
+          const cmd = data[j];
+          const nums = params.split(';').map((p) => (p === '' ? undefined : Number(p)));
+          this._csi(cmd, nums, params);
+          i = j + 1;
+          continue;
+        }
+        // other escapes (e.g. \u001B[?25l already handled via '[' path); skip 2
+        i += 1;
+        continue;
+      }
+      if (ch === '\n') { this.cy += 1; this.cx = 0; this._clampRow(); i++; continue; }
+      if (ch === '\r') { this.cx = 0; i++; continue; }
+      // printable
+      this._clampRow();
+      const row = this.grid[this.cy];
+      const padded = row.length < this.cx ? row + ' '.repeat(this.cx - row.length) : row;
+      this.grid[this.cy] = padded.slice(0, this.cx) + ch + padded.slice(this.cx + 1);
+      this.cx += 1;
+      i++;
+    }
+  }
+  _csi(cmd, nums, params) {
+    const n = nums[0];
+    switch (cmd) {
+      case 'H': case 'f': { // cursor position (1-based row;col)
+        this.cy = (nums[0] ?? 1) - 1; this.cx = (nums[1] ?? 1) - 1; this._clampRow(); break;
+      }
+      case 'A': this.cy -= (n ?? 1); this._clampRow(); break; // up
+      case 'B': this.cy += (n ?? 1); this._clampRow(); break; // down
+      case 'C': this.cx += (n ?? 1); break; // forward
+      case 'D': this.cx -= (n ?? 1); if (this.cx < 0) this.cx = 0; break; // back
+      case 'E': this.cy += (n ?? 1); this.cx = 0; this._clampRow(); break; // next line
+      case 'F': this.cy -= (n ?? 1); this.cx = 0; this._clampRow(); break; // prev line
+      case 'G': this.cx = (n ?? 1) - 1; break; // column (cursorTo(x) → \u001B[(x+1)G)
+      case 'J': { // erase display; 2 = whole screen (clearTerminal uses 2J + H)
+        if (n === 2 || n === 3) { this.grid = Array.from({ length: this.rows }, () => ''); }
+        break;
+      }
+      case 'K': { // erase line (eraseEndLine=0/none; eraseLine full = 2K)
+        if (n === undefined || n === 0) { this.grid[this.cy] = this.grid[this.cy].slice(0, this.cx); }
+        else if (n === 1) { this.grid[this.cy] = ' '.repeat(this.cx) + this.grid[this.cy].slice(this.cx); }
+        else if (n === 2) { this.grid[this.cy] = ''; }
+        break;
+      }
+      // SGR (m), hide/show cursor (h/l), etc. — no geometry effect
+      default: break;
+    }
+  }
+  markerRow(marker) {
+    for (let r = 0; r < this.rows; r++) {
+      if (this.grid[r].includes(marker)) return r;
+    }
+    return -1;
+  }
+  dump() {
+    return this.grid.map((r, i) => `${String(i).padStart(2)}|${r}`).join('\n');
+  }
+}
+
+// ---- Wrapper mirroring ink.js renderInteractiveFrame ----------------------
+function makeDriver({ rows, cols, isWindows }) {
+  const chunks = [];
+  const fakeStream = { write: (s) => { chunks.push(s); return true; }, isTTY: true, columns: cols, rows };
+  // Force the incremental renderer's Windows branch by faking env/platform is
+  // out of scope here; log-update reads process.platform/WT_SESSION at import.
+  const log = logUpdate.create(fakeStream, { incremental: true });
+  const vt = new VT(rows, cols);
+  let lastOutput = '';
+  let lastOutputHeight = 0;
+  let lastViewportRows = rows;
+  let lastOneShortPadded = false;
+  const commit = (output) => {
+    chunks.length = 0;
+    // [FAITHFUL] outputHeight = output.get().height = Output.height = the
+    // Yoga-computed ROOT height (renderer.js L45). The App pins the outer
+    // column to height=resizeState.rows, so a steady frame reports height=rows.
+    // BUT when the App's row accounting is off by one for a single commit
+    // (a reclaimed panel/hint row not yet refilled), the root lays out at
+    // rows-1 and outputHeight==rows-1. Model the height as the caller states
+    // it via a marker: the frame string's real line count is authoritative
+    // here because we construct each frame to physically carry `heightRows`
+    // lines. So derive it from the string.
+    const lineCount = output.split('\n').length;
+    let outputHeight = output === '' ? 0 : lineCount;
+    // Mirror ink.js (post-fix): an exactly-one-row-short frame following a
+    // fullscreen frame is padded with a leading blank line so the bottom
+    // cluster stays at its steady rows and the fullscreen path stays engaged.
+    const wasFullscreenFrame = lastOutputHeight >= lastViewportRows && lastOutputHeight > 0;
+    // Mirror ink.js guard exactly: Windows-like only + one-commit transient.
+    const isExactlyOneRowShort = isWindows && outputHeight === rows - 1
+      && wasFullscreenFrame && !lastOneShortPadded;
+    if (isExactlyOneRowShort) {
+      output = '\n' + output;
+      outputHeight = rows;
+      lastOneShortPadded = true;
+    } else {
+      lastOneShortPadded = false;
+    }
+    const isFullscreen = outputHeight >= rows;
+    let outputToRender = isFullscreen ? output : output + '\n';
+    if (isFullscreen && outputToRender.endsWith('\n')) outputToRender += '\u001B[0m';
+    const clearDecision = shouldClearTerminalForFrameProbe({
+      isTty: true, viewportRows: rows, previousViewportRows: lastViewportRows,
+      previousOutputHeight: lastOutputHeight, nextOutputHeight: outputHeight,
+      isUnmounting: false, isWindows,
+    });
+    if (clearDecision) {
+      fakeStream.write('\u001B[0m' + ansiEscapes.clearTerminal + outputToRender);
+      log.sync(outputToRender);
+    } else {
+      log(outputToRender);
+    }
+    for (const c of chunks) vt.write(c);
+    lastOutput = output;
+    lastOutputHeight = outputHeight;
+    lastViewportRows = rows;
+    const trailingNL = outputToRender.endsWith('\n');
+    return { outputHeight, trailingNL, clearDecision, isFullscreen };
+  };
+  return { vt, commit };
+}
+
+// ---- Scenario builders ----------------------------------------------------
+// Build an App-like frame with the prompt+statusline ALWAYS pinned to the two
+// bottom-most non-blank rows (matching App.jsx: the bottom bar never moves).
+// The App keeps total painted rows == viewport by ceding transcript rows to a
+// panel; so the prompt row is invariant whether or not the palette is open.
+// The only thing that changes between commits is: does the serialized output
+// end on a blank row (→ trailing-newline flip, fs classification flip)?
+// `bottomBlank` models a frame whose LAST painted row is blank padding.
+// `shortByOne` = the root Yoga height is rows-1 for this commit (a reclaimed
+// row that the App's accounting has NOT yet refilled). This is the documented
+// deviant: outputHeight = rows-1 < viewportRows → ink.js takes output+'\n'
+// (NON-fullscreen branch) → log-update relative cursorUp walk → one-row-low
+// dip under Windows Terminal. A steady frame (shortByOne=false) fills the
+// viewport, stays on the absolute cursorTo path, and is stable.
+function frame({ rows, cols, palette, shortByOne, heightRows }) {
+  // [FAITHFUL] App.jsx pins the bottom cluster with the outer full-height
+  // column (height=resizeState.rows) + flexShrink={0} on the bottom bar. So the
+  // Yoga root height is `rows` when accounting is correct. When a reclaimed row
+  // is momentarily unaccounted, the laid-out tree is `rows-1` tall for one
+  // commit — that is `shortByOne`. In that frame the WHOLE column (including
+  // the pinned bottom cluster) sits one physical row higher.
+  // heightRows (explicit) overrides shortByOne — lets a caller drive an
+  // arbitrary frame height (e.g. rows-3) to exercise the real leave-fullscreen
+  // shrink chain, which the boolean shortByOne cannot express.
+  const height = heightRows != null ? heightRows : (shortByOne ? rows - 1 : rows);
+  const statusRow = height - 1;
+  const promptRow = statusRow - 1;
+  const lines = [];
+  for (let r = 0; r < height; r++) {
+    if (r === statusRow) { lines.push('STATUSLINE'); continue; }
+    if (r === promptRow) { lines.push('PROMPT>'); continue; }
+    if (palette && r === promptRow - 1) { lines.push('SLASHPALETTE'); continue; }
+    lines.push(`t${r}`);
+  }
+  // Serialized string carries exactly `height` lines (no trailing newline).
+  return lines.join('\n');
+}
+
+function run() {
+  const rows = 40, cols = 120;
+  const isWindows = true;
+  console.log(`# renderer harness rows=${rows} cols=${cols} isWindows(assumed)=${isWindows}`);
+  console.log(`# NOTE: log-update Windows branch active iff process.platform===win32||WT_SESSION at import`);
+  console.log(`#       (set WT_SESSION=1 to force it on non-Windows)\n`);
+
+  // Each frame: { palette, shortByOne }. shortByOne=true is the ONE deviant
+  // commit where the App's row accounting leaves the laid-out tree one row
+  // short of the viewport (reclaimed panel/hint row not yet refilled).
+  const scenarios = [
+    { name: 'palette close, always viewport-filling (correct accounting)', seq: [
+      { palette: true,  shortByOne: false },
+      { palette: false, shortByOne: false },
+      { palette: false, shortByOne: false },
+    ]},
+    { name: 'palette close, close commit ONE ROW SHORT (deviant accounting)', seq: [
+      { palette: true,  shortByOne: false },
+      { palette: false, shortByOne: true  },  // reclaimed row unaccounted
+      { palette: false, shortByOne: false },
+    ]},
+    { name: 'prompt newline remove, transitional ONE ROW SHORT', seq: [
+      { palette: false, shortByOne: false },
+      { palette: false, shortByOne: true  },
+      { palette: false, shortByOne: false },
+    ]},
+    // Steady one-short: repeated rows-1 frames. The pad must fire ONCE then
+    // stop (lastOneShortPadded), so f2/f3 are NOT re-padded and settle at the
+    // rows-1 layout (prompt rows-3 / status rows-2) with correct clear
+    // decisions — no infinite downward shift.
+    { name: 'steady ONE ROW SHORT (repeated rows-1) — pad once, then stop', seq: [
+      { palette: false, shortByOne: false },
+      { palette: false, shortByOne: true  },
+      { palette: false, shortByOne: true  },
+      { palette: false, shortByOne: true  },
+    ]},
+    // Real leave-fullscreen shrink chain rows→rows-1→rows-3: after the padded
+    // rows-1 frame, a further shrink to rows-3 must reach the shrink/clear path
+    // (not be masked by a stale pad) and settle cleanly.
+    { name: 'real shrink chain fullscreen→rows-1→rows-3', seq: [
+      { palette: false, heightRows: 40 },
+      { palette: false, heightRows: 39 },
+      { palette: false, heightRows: 37 },
+      { palette: false, heightRows: 37 },
+    ]},
+  ];
+
+  let anyDeviant = false;
+  for (const sc of scenarios) {
+    const { vt, commit } = makeDriver({ rows, cols, isWindows });
+    const promptRows = [];
+    console.log(`## ${sc.name}`);
+    sc.seq.forEach((f, idx) => {
+      const out = frame({ rows, cols, palette: f.palette, shortByOne: f.shortByOne, heightRows: f.heightRows });
+      const info = commit(out);
+      const pRow = vt.markerRow('PROMPT>');
+      const sRow = vt.markerRow('STATUSLINE');
+      promptRows.push(pRow);
+      console.log(`  f${idx} short1=${f.shortByOne?1:0} h=${info.outputHeight} fs=${info.isFullscreen?1:0} trailNL=${info.trailingNL?1:0} clear=${info.clearDecision?1:0} promptRow=${pRow} statusRow=${sRow}`);
+    });
+    // Deviant = the prompt row BOUNCES (differs from the settled row for a
+    // transient frame then returns). A monotone shift to a new steady row
+    // (steady-one-short, real shrink) is NOT a bounce — check the LAST row is
+    // reached and held, and no interior frame differs from BOTH neighbors.
+    const settled = promptRows[promptRows.length - 1];
+    const bounce = promptRows.some((r, i) =>
+      i > 0 && i < promptRows.length - 1 &&
+      r >= 0 && r !== promptRows[i - 1] && r !== promptRows[i + 1]);
+    if (bounce) { anyDeviant = true; console.log(`  >> DEVIANT(bounce): prompt rows ${JSON.stringify(promptRows)} vs settled ${settled}`); }
+    console.log('');
+  }
+  if (!anyDeviant) console.log('# no deviant frame reproduced at renderer level for these scenarios');
+  process.exitCode = 0;
+}
+
+run();

package/src/agents/heavy-worker/AGENT.md

@@ -9,13 +9,12 @@ Bounded slices; smallest coherent change, not rewrite. Stop: unclear scope,
 growing blast radius, or Lead-only verification.
 
 EDIT-FIRST DISCIPLINE. Survey the slice with ONE batched read/grep round, then
-patch the first bounded piece — broad scope means edit incrementally, not read
-exhaustively. NEVER "one more confirming read": if an anchor is plausible, the
-next call is `apply_patch`. Repeated read-only turns without an edit = stalling;
-any runtime reminder is your cue to patch the piece you understand or report
-blocked — a blocked report is a valid completion. Self-check comes AFTER edits;
-deep verification is Lead's.
+patch the first bounded piece — edit incrementally, don't read exhaustively.
+NEVER "one more confirming read": a plausible anchor means the next call is
+`apply_patch`. Repeated read-only turns without an edit = stalling; on a
+runtime reminder, patch the piece you understand or report blocked — a valid
+completion. Self-check comes AFTER edits; deep verification is Lead's.
 
 Minimal checks + how-to-verify. Hand off outcome as fragments anchored to
-`file:line`; no narration, no report bloat.
+`file:line`; no narration or bloat.
 

package/src/agents/worker/AGENT.md

@@ -8,13 +8,12 @@ Scoped implementation agent.
 Smallest scoped change; no drive-by cleanup. Stop when done/blocked.
 
 EDIT-FIRST DISCIPLINE. Brief anchors (`file:line`) are pre-verified — trust and
-patch. No anchor: locate with AT MOST 1-2 reads, then edit. NEVER "one more
-confirming read": if you know the file and the change, the next call is
-`apply_patch`. Repeated read-only turns without an edit = stalling; any runtime
-reminder is your cue to patch now or return blocked with what's missing — a
-blocked report is a valid completion. Threshold is "plausible", not "proven";
+patch. No anchor: locate with AT MOST 1-2 reads, then edit — NEVER "one more
+confirming read"; if you know the file and the change, the next call is
+`apply_patch`. Repeated read-only turns without an edit = stalling; on a
+runtime reminder, patch now or return blocked with what's missing — a blocked
+report is a valid completion. Threshold is "plausible", not "proven";
 self-check comes AFTER the edit, and Lead/Reviewer own final verification.
 
-Hand off outcome as fragments anchored to `file:line`; no narration, no report
-bloat.
+Hand off outcome as fragments anchored to `file:line`; no narration or bloat.
 

package/src/lib/keychain-cjs.cjs

@@ -182,23 +182,40 @@ function loadKeytar() {
 function keytarSync(method, ...args) {
     loadKeytar(); // throws if not installed — before spawning child
     const { spawnSync } = require('child_process');
-    // Pass service/account/value via env to avoid shell injection entirely.
-    const env = {
-        ...process.env,
-        _KEYTAR_METHOD: method,
-        _KEYTAR_ARGS: JSON.stringify(args),
-    };
+    // Pass service/account/value via stdin (not env) to avoid shell injection
+    // and to keep secret values out of /proc/<pid>/environ on Linux.
+    // Build a minimal child env instead of spreading process.env: the parent
+    // may hold *_API_KEY secrets in its own environment, and those would
+    // otherwise be visible via /proc/<pid>/environ for the lifetime of this
+    // child. Only pass what PATH resolution / locale / the libsecret D-Bus
+    // session bridge actually need.
+    const passthroughKeys = [
+        'PATH', 'HOME', 'USER', 'LOGNAME',
+        'LANG', 'LC_ALL',
+        'TMPDIR', 'TMP', 'TEMP',
+        'DISPLAY', 'DBUS_SESSION_BUS_ADDRESS', 'XDG_RUNTIME_DIR', 'XDG_CURRENT_DESKTOP', 'XDG_DATA_DIRS',
+    ];
+    const env = { _KEYTAR_METHOD: method };
+    for (const key of passthroughKeys) {
+        if (process.env[key] !== undefined) env[key] = process.env[key];
+    }
     const script = [
         'const kt = require("keytar");',
         'const method = process.env._KEYTAR_METHOD;',
-        'const args = JSON.parse(process.env._KEYTAR_ARGS);',
-        'kt[method](...args)',
-        '  .then(v => { process.stdout.write(JSON.stringify({ ok: true, value: v })); })',
-        '  .catch(e => { process.stdout.write(JSON.stringify({ ok: false, error: e.message })); });',
+        'let input = "";',
+        'process.stdin.setEncoding("utf8");',
+        'process.stdin.on("data", (chunk) => { input += chunk; });',
+        'process.stdin.on("end", () => {',
+        '  const args = JSON.parse(input);',
+        '  kt[method](...args)',
+        '    .then(v => { process.stdout.write(JSON.stringify({ ok: true, value: v })); })',
+        '    .catch(e => { process.stdout.write(JSON.stringify({ ok: false, error: e.message })); });',
+        '});',
     ].join(' ');
     const r = spawnSync(process.execPath, ['-e', script], {
         env,
-        stdio: ['ignore', 'pipe', 'pipe'],
+        input: JSON.stringify(args),
+        stdio: ['pipe', 'pipe', 'pipe'],
         timeout: 5000,
         encoding: 'utf8',
         windowsHide: true,

package/src/lib/rules-builder.cjs

@@ -129,10 +129,10 @@ function buildProfilePreferencesContent(dataDir) {
   const profile = normalizeProfileConfig(readAgentConfig(dataDir).profile);
   const lines = [];
   if (profile.title) {
-    lines.push(`- Use "${profile.title}" when directly addressing the user (greetings, answers, questions). Do not repeat it in routine progress updates or pre-tool preambles.`);
+    lines.push(`- Use "${profile.title}" when directly addressing the user (greetings, answers, questions); do not repeat it in routine progress updates or pre-tool preambles.`);
   }
   const shell = process.platform === 'win32' ? 'powershell' : 'bash';
-  lines.push(`- Shell environment: ${shell}. When using shell, write commands and scripts in ${shell} syntax unless the user specifies otherwise. Keep commands, paths, symbols, and exact errors verbatim.`);
+  lines.push(`- Shell environment: ${shell}. Write shell commands and scripts in ${shell} syntax unless the user specifies otherwise; keep commands, paths, symbols, and exact errors verbatim.`);
   return lines.length ? `# Profile Preferences\n\n${lines.join('\n')}` : '';
 }
 
@@ -144,7 +144,7 @@ function buildLanguageSection(dataDir) {
     ? ` from system locale ${language.locale}`
     : '';
   const lines = [
-    `- Default user-facing response language${source}: ${language.prompt}. Use it for ALL user-facing prose, including pre-tool preambles, progress updates, questions, final reports, and notices. Every such message — even a single-line preamble before a tool call — MUST be written in ${language.prompt}, and in no other language. This overrides any tone implied by the output style. Switch languages only when the user writes in another language or explicitly asks you to.`,
+    `- Default user-facing response language${source}: ${language.prompt}. EVERY user-facing message — prose, pre-tool preambles (even single-line), progress updates, questions, final reports, notices — MUST be written in ${language.prompt} and no other language; this overrides any tone implied by the output style. Switch only when the user writes in another language or explicitly asks you to.`,
     `- Code identifiers, paths, commands, symbols, API names, and exact errors should remain in their original form.`,
   ];
   return `# Language\n\n${lines.join('\n')}`;
@@ -382,13 +382,9 @@ function buildAgentRoleContent({ PLUGIN_ROOT, profile = 'full' }) {
 function buildAgentRetrievalInjectionContent({ PLUGIN_ROOT }) {
   const AGENT_DIR = path.join(PLUGIN_ROOT, 'rules', 'agent');
   const core = readOptional(path.join(AGENT_DIR, '00-core.md'));
-  const parts = [
-    '# Tool Use',
-    '',
-    '- Batch independent read-only lookups in the same tool turn.',
-    '- Use code_graph for symbols/dependencies, grep for exact text, find/glob/list for files, and read only known paths/windows.',
-    '',
-  ];
+  // Full shared tool policy (01-tool.md) now ships via BP1 for retrieval
+  // roles too; no compact duplicate here.
+  const parts = [];
   if (core) parts.push(core.trim());
   parts.push('', '- Read-only retrieval role: do not edit files, run shell, or use git.');
   return parts.join('\n');

package/src/mixdog-session-runtime.mjs

@@ -3,6 +3,7 @@ import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
+import httpMod from 'node:http';
 import { ensureStandaloneEnvironment } from './standalone/seeds.mjs';
 import { createStandaloneAgent } from './standalone/agent-tool.mjs';
 import { isAgentOwner } from './runtime/agent/orchestrator/agent-owner.mjs';
@@ -167,6 +168,9 @@ import {
   normalizePluginMcpServerConfig,
   pluginManifest,
   pluginMcpServerName,
+  pluginRawMcpServers,
+  pluginMcpEnableScript,
+  resolveContainedPluginPath,
 } from './session-runtime/plugin-mcp.mjs';
 import {
   WORKFLOW_ROUTE_SLOTS,
@@ -395,6 +399,13 @@ export async function createMixdogSessionRuntime({
   ]);
   bootProfile('imports:ready', { ms: (performance.now() - importsStartedAt).toFixed(1) });
   const pluginDataDir = cfgMod.getPluginData();
+  // Re-wire the idle/tombstone sweep. startIdleCleanup() lost its caller in a
+  // refactor, so closed-session tombstones were never deleted after their 24h
+  // grace — the store grew unbounded (observed: 1.8k files / 114MB), which
+  // made summary-index rebuilds and per-save index rewrites stall boot for
+  // seconds. Timer is unref'd and first fires after CLEANUP_INITIAL_DELAY_MS
+  // (5min), so this adds zero boot-path cost.
+  try { mgr.startIdleCleanup?.(); } catch { /* cleanup is best-effort */ }
   const memoryRuntime = createStandaloneMemoryRuntime({
     entry: join(STANDALONE_ROOT, MEMORY_RUNTIME.replace(/^\.\//, '')),
     dataDir: pluginDataDir,
@@ -1531,11 +1542,42 @@ export async function createMixdogSessionRuntime({
     // published to active-instance.json by getMemoryModule().init(). Without
     // this, memory only starts on the first turn's getMemoryModule() call —
     // so early channel traffic finds no memory_port and gets buffered (or,
-    // pre-drainer, silently dropped). Fire-and-forget BEFORE channel claim so
-    // the port is (racing to be) live by the time the worker sends its first
-    // ingest.
-    try { void getMemoryModule().catch((error) => bootProfile('channels:memory-eager-init-failed', { error: error?.message || String(error) })); }
-    catch (error) { bootProfile('channels:memory-eager-init-failed', { error: error?.message || String(error) }); }
+    // pre-drainer, silently dropped). Runs BEFORE channel claim so the port is
+    // racing to be live by the time the worker sends its first ingest.
+    //
+    // Not fire-and-forget: init() only resolves the module handle, so a bare
+    // getMemoryModule() could return before /health reports ok — leaving early
+    // ingests to hit a not-yet-listening port. Await the proxy start() and then
+    // poll /health with a bounded retry so the daemon is provably reachable
+    // (or logged failed) rather than assumed-up. Still non-blocking to the
+    // caller: the whole probe is detached, but it internally awaits readiness.
+    void (async () => {
+      try {
+        const mod = await getMemoryModule();
+        const started = typeof mod?.start === 'function' ? await mod.start() : null;
+        const port = started?.port;
+        if (!port) { bootProfile('channels:memory-eager-init-failed', { error: 'no port from start()' }); return; }
+        for (let i = 0; i < 30; i++) {
+          try {
+            const ok = await new Promise((res) => {
+              const req = httpMod.request({ hostname: '127.0.0.1', port, path: '/health', timeout: 1500 }, (r) => {
+                let d = ''; r.on('data', (c) => { d += c; }); r.on('end', () => {
+                  try { res(JSON.parse(d)?.status === 'ok'); } catch { res(false); }
+                });
+              });
+              req.on('error', () => res(false));
+              req.on('timeout', () => { req.destroy(); res(false); });
+              req.end();
+            });
+            if (ok) { bootProfile('channels:memory-eager-init-ready', { port }); return; }
+          } catch {}
+          await new Promise((r) => setTimeout(r, 500));
+        }
+        bootProfile('channels:memory-eager-init-failed', { error: `health not ok after retries (port ${port})` });
+      } catch (error) {
+        bootProfile('channels:memory-eager-init-failed', { error: error?.message || String(error) });
+      }
+    })();
     // Publish this session's record + transcript file BEFORE the worker's
     // activate-time discovery polls, so output forwarding binds to this
     // terminal session immediately instead of waiting for the first turn.
@@ -1640,8 +1682,38 @@ export async function createMixdogSessionRuntime({
   // channel; see startRemote()/stopRemote() and the `/remote` toggle.
   // `remote.autoStart` in mixdog-config.json makes every session claim remote
   // at boot (same force-takeover semantics as `mixdog --remote` / `/remote`).
-  if (!remoteEnabled && config?.remote?.autoStart === true) remoteEnabled = true;
-  if (remoteEnabled) startRemote();
+  // The flag lives in the TOP-LEVEL `remote` section of mixdog-config.json
+  // (sibling of agent/ui/channels), not inside the agent section that
+  // cfgMod.loadConfig returns — read it via the shared whole-file reader.
+  // `config?.remote?.autoStart` is kept for back-compat with agent-section
+  // placement.
+  if (!remoteEnabled) {
+    try {
+      if (config?.remote?.autoStart === true
+        || sharedCfgMod?.readSection?.('remote')?.autoStart === true) {
+        remoteEnabled = true;
+      }
+    } catch { /* unreadable config never blocks boot */ }
+  }
+  // Boot-time remote start (autoStart or --remote) is DEFERRED past the TUI's
+  // first frame. startRemote() front-loads heavy work — memory daemon fork
+  // (PG + forced ONNX embed warmup in the child), eager session create, and
+  // the channel-worker fork — and running it inline here interleaves that
+  // CPU/disk load with engine boot, visibly delaying the first ink frame by
+  // seconds. The deferred timer reuses prewarmTimers.channelStartTimer so an
+  // early /remote (startRemote clears it), stopRemote(), and close() all
+  // cancel it through the existing clearTimeout paths. Runtime /remote calls
+  // still start immediately (user-initiated, UI already painted).
+  if (remoteEnabled) {
+    const remoteAutoStartDelayMs = envDelayMs('MIXDOG_REMOTE_AUTOSTART_DELAY_MS', 1_500, { min: 0, max: 60_000 });
+    bootProfile('channels:autostart-deferred', { delayMs: remoteAutoStartDelayMs });
+    prewarmTimers.channelStartTimer = setTimeout(() => {
+      prewarmTimers.channelStartTimer = null;
+      if (closeRequested || !remoteEnabled) return;
+      startRemote();
+    }, remoteAutoStartDelayMs);
+    prewarmTimers.channelStartTimer.unref?.();
+  }
 
   function contextStatusCacheKeyFor({ messages, tools }) {
     const compaction = session?.compaction || {};
@@ -2769,19 +2841,17 @@ export async function createMixdogSessionRuntime({
     },
     async enablePluginMcp(plugin = {}) {
       const root = clean(plugin.root);
-      const script = clean(plugin.mcpScript);
+      const script = pluginMcpEnableScript(root, plugin);
       if (!root || !script) throw new Error('plugin has no MCP script');
       const serverName = pluginMcpServerName(plugin);
       const nextConfig = { ...config };
-      if (script === '.mcp.json') {
-        const mcpJsonPath = join(root, script);
-        if (!existsSync(mcpJsonPath)) throw new Error(`plugin MCP manifest not found: ${mcpJsonPath}`);
-        const manifest = readJsonSafe(mcpJsonPath) || {};
-        const rawServers = manifest.mcpServers;
-        const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
-        if (!isPlainObject(rawServers)) throw new Error(`plugin .mcp.json missing mcpServers object: ${mcpJsonPath}`);
-        const keys = Object.keys(rawServers).filter((k) => isPlainObject(rawServers[k]));
-        if (!keys.length) throw new Error(`plugin .mcp.json has no mcpServers: ${mcpJsonPath}`);
+      const manifestMcp = pluginRawMcpServers(root, script);
+      if (manifestMcp) {
+        const { rawServers, mcpRoot } = manifestMcp;
+        const keys = Object.keys(rawServers).filter((k) => {
+          const v = rawServers[k];
+          return v !== null && typeof v === 'object' && !Array.isArray(v);
+        });
         const ownedPrefix = `${serverName}--`;
         const nextServers = {};
         for (const [k, v] of Object.entries(nextConfig.mcpServers || {})) {
@@ -2789,7 +2859,7 @@ export async function createMixdogSessionRuntime({
           nextServers[k] = v;
         }
         for (const serverKey of keys) {
-          const cfg = normalizePluginMcpServerConfig(rawServers[serverKey], root);
+          const cfg = normalizePluginMcpServerConfig(rawServers[serverKey], mcpRoot);
           cfg.env = {
             ...(cfg.env || {}),
             MIXDOG_PLUGIN_ROOT: root,
@@ -2800,8 +2870,8 @@ export async function createMixdogSessionRuntime({
         }
         nextConfig.mcpServers = nextServers;
       } else {
-        const scriptPath = join(root, script);
-        if (!existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${scriptPath}`);
+        const scriptPath = resolveContainedPluginPath(root, script);
+        if (!scriptPath || !existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${join(root, script)}`);
         nextConfig.mcpServers = {
           ...(nextConfig.mcpServers || {}),
           [serverName]: {