mixdog 0.9.62 → 0.9.64

package/scripts/ingest-pure-conversation-smoke.mjs

@@ -1,175 +0,0 @@
-#!/usr/bin/env node
-import { createRequire } from 'node:module'
-import {
-  normalizeIngestRole,
-  sessionMessageContent,
-  sessionMessageContentForIngest,
-  shouldExcludeIngestMessage,
-} from '../src/runtime/memory/lib/session-ingest.mjs'
-
-// cleanMemoryText is the SAME downstream cleaner the real ingest loop applies
-// (memory/index.mjs:795). text-utils.cjs is a dependency-free CJS module, so we
-// require it directly to mirror the pipeline without booting the MCP server.
-const require = createRequire(import.meta.url)
-const { cleanMemoryText } = require('../src/lib/text-utils.cjs')
-
-function assert(condition, message) {
-  if (!condition) throw new Error(message)
-}
-
-// Mirror memory/index.mjs ingestSessionMessages row handling for one message:
-//   role gate → exclusion predicate → ingest shaper → cleanMemoryText → trim.
-// Returns the persisted content string, or null when the row is NOT ingested.
-function ingestRow(m) {
-  const role = normalizeIngestRole(m.role)
-  if (!role) return null
-  if (shouldExcludeIngestMessage(m)) return null
-  const content = cleanMemoryText(sessionMessageContentForIngest(m))
-  if (!content || !content.trim()) return null
-  return content
-}
-
-const SUMMARY_PREFIX = 'A previous model worked on this task and produced the compacted handoff summary below. Build on the work already done and avoid duplicating it; treat the summary as authoritative context for continuing the task. You also retain the preserved recent turns that follow.'
-
-// ── Synthetic session.messages covering every audited case ──────────────────
-// (i) assistant prose + an `agent` toolCall (tool-call trace must be stripped).
-const asstWithTool = {
-  role: 'assistant',
-  content: 'Here is my plan for the refactor.',
-  toolCalls: [{ id: 'call_42', name: 'agent', arguments: '{"type":"send","text":"go"}' }],
-}
-// (ii) the real human turn carrying the full manager-style prefix envelope.
-const sessionBlock = '# Session\nCwd: C:/Project/mixdog\nModel: GPT-5 · HIGH'
-const prefixedUser = {
-  role: 'user',
-  content:
-    `${sessionBlock}\n\n` +
-    '# Additional context\nsome context body line one\nline two\n\n' +
-    '# Prefetch\nprefetched file snippet\n\n' +
-    '# Task\n\uC2E4\uC81C \uC9C8\uBB38',
-}
-// (iii) Reference files synthetic row.
-const referenceRow = { role: 'user', content: 'Reference files:\n- a.mjs\n- b.mjs' }
-// (iv) compaction summary row.
-const summaryRow = { role: 'user', content: `${SUMMARY_PREFIX}\nmessages=10 sha256=abcd roles=user:5` }
-// (v) protected-context `.` ack assistant row.
-const ackRow = { role: 'assistant', content: '.' }
-// (vi) internal runtime nudge user row.
-const nudgeRow = { role: 'user', content: '[mixdog-runtime] Your previous response was empty. Continue.' }
-// (vi-b) model-visible tool-completion wrapper row (mgr.enqueuePendingMessage
-// mirror of modelVisibleToolCompletionMessage — the transcript-watcher bug
-// this change fixes: these were previously persisted verbatim).
-const completionWrapperRow = {
-  role: 'user',
-  content:
-    'The async shell task task_123 has finished (completed) - review this result in your next step.\n\n' +
-    'Result:\n> background task\n> task_id: task_123\n> status: completed',
-}
-// (vi-c) UNQUOTED persisted form — taken from a real DB row. No `> ` prefix
-// on the Result body; isModelVisibleToolCompletionWrapper alone misses this
-// shape, so shouldExcludeIngestMessage falls back to the instruction-head
-// regex (isUnquotedToolCompletionHead).
-const unquotedCompletionRow = {
-  role: 'user',
-  content:
-    'The async shell task task_456 has finished (completed, exit 0) - review this result in your next step.\n' +
-    'Result:\nbackground task\ntask_id: task_456\nstatus: completed',
-}
-// (vii) normal human + normal assistant.
-const normalUser = { role: 'user', content: '\uC548\uB155' }
-const normalAsst = { role: 'assistant', content: '\uB124 \uC548\uB155\uD558\uC138\uC694' }
-
-const before = {
-  asstWithTool: sessionMessageContent(asstWithTool),
-  prefixedUser: prefixedUser.content,
-  referenceRow: referenceRow.content,
-  summaryRow: summaryRow.content,
-  ackRow: ackRow.content,
-  nudgeRow: nudgeRow.content,
-  completionWrapperRow: completionWrapperRow.content,
-  unquotedCompletionRow: unquotedCompletionRow.content,
-  normalUser: normalUser.content,
-  normalAsst: normalAsst.content,
-}
-
-const after = {
-  asstWithTool: ingestRow(asstWithTool),
-  prefixedUser: ingestRow(prefixedUser),
-  referenceRow: ingestRow(referenceRow),
-  summaryRow: ingestRow(summaryRow),
-  ackRow: ingestRow(ackRow),
-  nudgeRow: ingestRow(nudgeRow),
-  completionWrapperRow: ingestRow(completionWrapperRow),
-  unquotedCompletionRow: ingestRow(unquotedCompletionRow),
-  normalUser: ingestRow(normalUser),
-  normalAsst: ingestRow(normalAsst),
-}
-
-// (i) tool-call trace gone, prose kept.
-assert(before.asstWithTool.includes('[tool_call agent'), 'precondition: structured shaper inlines the tool_call trace')
-assert(after.asstWithTool && !after.asstWithTool.includes('[tool_call'), 'ingest must strip the tool_call trace')
-assert(after.asstWithTool.includes('Here is my plan for the refactor.'), 'assistant prose must survive')
-
-// (ii) prefixed user collapses to exactly the human prompt.
-assert(after.prefixedUser === '\uC2E4\uC81C \uC9C8\uBB38', `prefixed user must shape to "\uC2E4\uC81C \uC9C8\uBB38" (got: ${JSON.stringify(after.prefixedUser)})`)
-assert(!/# Session|Cwd:|Model:|Additional context|Prefetch|# Task/.test(after.prefixedUser), 'no prefix residue may remain')
-
-// (iii)-(vi) synthetic rows excluded.
-assert(after.referenceRow === null, 'Reference files row must be excluded')
-assert(after.summaryRow === null, 'SUMMARY_PREFIX row must be excluded')
-assert(after.ackRow === null, '`.` ack row must be excluded')
-assert(after.nudgeRow === null, '[mixdog-runtime] nudge row must be excluded')
-assert(after.completionWrapperRow === null, 'model-visible tool-completion wrapper row must be excluded')
-assert(after.unquotedCompletionRow === null, 'unquoted tool-completion wrapper row (real DB shape) must be excluded')
-
-// (vii) normal conversation survives intact.
-assert(after.normalUser === '\uC548\uB155', 'normal human text must survive intact')
-assert(after.normalAsst === '\uB124 \uC548\uB155\uD558\uC138\uC694', 'normal assistant text must survive intact')
-
-// Zero-loss guard: a human message that merely MENTIONS the markers mid-text is
-// NOT stripped (anchors only fire on the leading manager-produced prefix).
-const humanMentionsMarkers = { role: 'user', content: 'please write a # Task section and a # Prefetch note' }
-assert(ingestRow(humanMentionsMarkers) === 'please write a # Task section and a # Prefetch note', 'mid-text markers must not be stripped')
-
-// ── Edge: field-anchored `# Session` strip (zero-loss for human docs) ────────
-// A human doc that legitimately STARTS with a `# Session` heading followed by
-// free prose must NOT be wiped. The strip is field-anchored to the EXACT shape
-// buildSessionStartBlock emits (`# Session` then only Cwd/Model/Workflow lines).
-// Assert on the SHAPER directly so the check isolates the strip rule from
-// cleanMemoryText's normal markdown-header cleaning.
-const humanSessionDoc = { role: 'user', content: '# Session\n\uD504\uB85C\uC81D\uD2B8 \uD68C\uC758\uB85D\uC785\uB2C8\uB2E4\n\uB2E4\uC74C \uC548\uAC74' }
-assert(
-  sessionMessageContentForIngest(humanSessionDoc) === '# Session\n\uD504\uB85C\uC81D\uD2B8 \uD68C\uC758\uB85D\uC785\uB2C8\uB2E4\n\uB2E4\uC74C \uC548\uAC74',
-  'human doc starting with `# Session` heading must be preserved verbatim (not wiped)',
-)
-// And through the full ingest row it must still carry the human words (the lone
-// `# ` heading marker is stripped by normal markdown cleaning — not data loss).
-assert(/\uD504\uB85C\uC81D\uD2B8 \uD68C\uC758\uB85D\uC785\uB2C8\uB2E4/.test(ingestRow(humanSessionDoc) || ''), 'human session-doc words must survive ingest')
-
-// Injected real session block (Cwd/Model) still strips to the human prompt.
-const injectedCwdModel = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\n\n\uC2E4\uC81C\uC9C8\uBB38' }
-assert(sessionMessageContentForIngest(injectedCwdModel) === '\uC2E4\uC81C\uC9C8\uBB38', 'injected Cwd/Model session block must strip to the human prompt')
-
-// Injected real session block incl. Workflow line still strips.
-const injectedWorkflow = { role: 'user', content: '# Session\nCwd: /x\nModel: Y\nWorkflow: Default\n\nq' }
-assert(sessionMessageContentForIngest(injectedWorkflow) === 'q', 'injected Cwd/Model/Workflow session block must strip to the human prompt')
-
-const rows = [
-  ['(i) assistant + agent toolCall', before.asstWithTool, after.asstWithTool],
-  ['(ii) prefixed human turn', before.prefixedUser, after.prefixedUser],
-  ['(iii) Reference files', before.referenceRow, after.referenceRow],
-  ['(iv) SUMMARY_PREFIX', before.summaryRow, after.summaryRow],
-  ['(v) `.` ack', before.ackRow, after.ackRow],
-  ['(vi) [mixdog-runtime] nudge', before.nudgeRow, after.nudgeRow],
-  ['(vi-b) tool-completion wrapper', before.completionWrapperRow, after.completionWrapperRow],
-  ['(vi-c) unquoted tool-completion (real DB shape)', before.unquotedCompletionRow, after.unquotedCompletionRow],
-  ['(vii) normal human', before.normalUser, after.normalUser],
-  ['(vii) normal assistant', before.normalAsst, after.normalAsst],
-]
-process.stdout.write('before/after (EXCLUDED = row not ingested):\n')
-for (const [label, b, a] of rows) {
-  process.stdout.write(`  ${label}\n`)
-  process.stdout.write(`    before: ${JSON.stringify(b)}\n`)
-  process.stdout.write(`    after : ${a === null ? 'EXCLUDED' : JSON.stringify(a)}\n`)
-}
-process.stdout.write('\ningest pure-conversation smoke passed \u2713\n')

package/scripts/internal-comms-bench-test.mjs

@@ -1,226 +0,0 @@
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import test from 'node:test';
-
-import {
-  CHILD_RESULT_END,
-  CHILD_RESULT_START,
-  DEFAULT_LEAD_APPROVAL_PROMPT,
-  buildLiveLeadDriver,
-  leadModeExitCode,
-  parseLiveLeadResult,
-  runLiveLeadDelegation,
-  validateLeadRun,
-} from './internal-comms-bench.mjs';
-
-function writeRuntime(root, managerSource) {
-  const runtimePath = join(root, 'runtime.mjs');
-  const tracePath = join(root, 'agent-trace-io.mjs');
-  writeFileSync(runtimePath, managerSource);
-  writeFileSync(tracePath, 'export async function drainAgentTrace() {}\n');
-  return {
-    runtimeUrl: pathToFileURL(runtimePath).href,
-    traceUrl: pathToFileURL(tracePath).href,
-  };
-}
-
-function writeSandboxRuntime(root, marker) {
-  const runtimePath = join(root, 'mixdog-session-runtime.mjs');
-  const tracePath = join(root, 'runtime', 'agent', 'orchestrator', 'agent-trace-io.mjs');
-  mkdirSync(join(root, 'runtime', 'agent', 'orchestrator'), { recursive: true });
-  writeFileSync(runtimePath, `
-    import { writeFileSync } from 'node:fs';
-    export async function createMixdogSessionRuntime() {
-      writeFileSync(process.env.RUNTIME_MARKER_PATH, ${JSON.stringify(marker)});
-      return {
-        id: 'sess_default_resolution', sessionId: 'sess_default_resolution',
-        async setFast() {},
-        toolsStatus() { return { activeTools: ['agent'] }; },
-        onNotification() {},
-        agentStatus() { return { agentJobs: [] }; },
-        async ask() { return { result: { text: 'done' } }; },
-        async close() {},
-      };
-    }
-  `);
-  writeFileSync(tracePath, 'export async function drainAgentTrace() {}\n');
-}
-
-test('lead delegation resolves default runtime and trace imports from the variant plugin root', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-bench-test-'));
-  const pluginA = join(root, 'plugin-A');
-  const pluginB = join(root, 'plugin-B');
-  const markerPath = join(root, 'runtime-marker');
-  const priorMarkerPath = process.env.RUNTIME_MARKER_PATH;
-  try {
-    process.env.RUNTIME_MARKER_PATH = markerPath;
-    writeSandboxRuntime(pluginA, 'A');
-    writeSandboxRuntime(pluginB, 'B');
-    for (const [pluginRoot, expected] of [[pluginA, 'A'], [pluginB, 'B']]) {
-      const run = runLiveLeadDelegation({
-        pluginRoot,
-        dataDir: root,
-        taskCwd: root,
-        prompt: 'Use the variant runtime.',
-        provider: 'test-provider',
-        model: 'test-model',
-        fast: false,
-      });
-      assert.equal(run.ok, true, run.stderr || run.stdout);
-      assert.equal(readFileSync(markerPath, 'utf8'), expected);
-    }
-  } finally {
-    if (priorMarkerPath === undefined) delete process.env.RUNTIME_MARKER_PATH;
-    else process.env.RUNTIME_MARKER_PATH = priorMarkerPath;
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('lead driver plans before explicit approval, drains traces, and exits despite open handles', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-bench-test-'));
-  const promptsPath = join(root, 'prompts.jsonl');
-    const tracePath = join(root, 'trace-drained');
-    const activeToolsPath = join(root, 'active-tools.json');
-  try {
-    const runtimeUrls = writeRuntime(root, `
-      import { appendFileSync, writeFileSync } from 'node:fs';
-      let calls = 0;
-      let fastApplied = false;
-      setInterval(() => {}, 1000);
-      export async function createMixdogSessionRuntime() {
-        return {
-          id: 'sess_bench_test', sessionId: 'sess_bench_test',
-          async setFast(value) {
-            if (typeof value !== 'boolean') throw new Error('fast must be boolean');
-            fastApplied = true;
-            writeFileSync(process.env.FAST_PATH, JSON.stringify(value));
-          },
-          toolsStatus() {
-            writeFileSync(process.env.ACTIVE_TOOLS_PATH, JSON.stringify(['agent']));
-            return { activeTools: ['agent'] };
-          },
-          onNotification() {},
-          agentStatus() { return { agentJobs: [] }; },
-          async ask(prompt) {
-            if (!fastApplied) throw new Error('fast was not applied before prompting');
-            appendFileSync(process.env.PROMPTS_PATH, JSON.stringify(prompt) + '\\n');
-            calls += 1;
-            return { result: calls === 1 ? { text: 'plan' } : { text: 'completed {math.js:1}' } };
-          },
-          async close() { this.id = ''; this.sessionId = ''; },
-        };
-      }
-    `);
-    writeFileSync(join(root, 'agent-trace-io.mjs'), `
-      import { writeFileSync } from 'node:fs';
-      export async function drainAgentTrace() {
-        await new Promise((resolve) => setTimeout(resolve, 75));
-        writeFileSync(process.env.TRACE_PATH, 'drained');
-      }
-    `);
-    const driver = buildLiveLeadDriver({
-      ...runtimeUrls,
-      taskCwd: root,
-      prompt: 'Plan the benchmark task.',
-      provider: 'test-provider',
-      model: 'test-model',
-      fast: false,
-    });
-    const child = spawnSync(process.execPath, ['--input-type=module', '-e', driver], {
-      encoding: 'utf8',
-      env: { ...process.env, PROMPTS_PATH: promptsPath, ACTIVE_TOOLS_PATH: activeToolsPath, TRACE_PATH: tracePath, FAST_PATH: join(root, 'fast.json') },
-      timeout: 2000,
-    });
-
-    assert.equal(child.status, 0, child.stderr || child.stdout);
-    assert.deepEqual(
-      readFileSync(promptsPath, 'utf8').trim().split(/\r?\n/).map(JSON.parse),
-      ['Plan the benchmark task.', DEFAULT_LEAD_APPROVAL_PROMPT],
-    );
-    assert.deepEqual(JSON.parse(readFileSync(activeToolsPath, 'utf8')), ['agent']);
-    assert.equal(JSON.parse(readFileSync(join(root, 'fast.json'), 'utf8')), false);
-    assert.equal(readFileSync(tracePath, 'utf8'), 'drained');
-    assert.deepEqual(parseLiveLeadResult(child.stdout), {
-      text: 'completed {math.js:1}',
-      sessionId: 'sess_bench_test',
-    });
-    assert.match(child.stdout, new RegExp(`${CHILD_RESULT_START}.*${CHILD_RESULT_END}`));
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('lead validation rejects successful child output without worker and reviewer participation', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-bench-test-'));
-  try {
-    writeFileSync(join(root, 'math.js'), `export function mul(a, b) { return a * b; }\nexport function add(a, b) { return a + b; }\n`);
-    const split = {
-      byRole: {
-        lead: { usage_rows: 1 },
-        worker: { usage_rows: 0 },
-        reviewer: { usage_rows: 0 },
-        other: { usage_rows: 0 },
-      },
-      total: { usage_rows: 1 },
-    };
-    const validation = validateLeadRun({ taskCwd: root, run: { ok: true }, split });
-    assert.equal(validation.valid, false);
-    assert.deepEqual(validation.reasons, [
-      'worker participation/usage is missing',
-      'reviewer participation/usage is missing',
-    ]);
-    assert.equal(leadModeExitCode(
-      { A: [{ valid: false }], B: [{ valid: true }] },
-      { A: [], B: [split] },
-    ), 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});
-
-test('child failures retain stdout and stderr diagnostics and cannot succeed', () => {
-  const root = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-bench-test-'));
-  try {
-    const runtimeUrls = writeRuntime(root, `
-      export async function createMixdogSessionRuntime() {
-        return {
-          id: 'sess_bench_failure', sessionId: 'sess_bench_failure',
-          async setFast() {},
-          toolsStatus() { return { activeTools: ['agent'] }; },
-          onNotification() {},
-          agentStatus() { return { agentJobs: [] }; },
-          async ask() {
-            console.log('provider stdout {diagnostic}');
-            console.error('provider stderr {diagnostic}');
-            throw new Error('provider failure');
-          },
-          async close() {},
-        };
-      }
-    `);
-    const run = runLiveLeadDelegation({
-      pluginRoot: root,
-      dataDir: root,
-      taskCwd: root,
-      prompt: 'Plan the benchmark task.',
-      provider: 'test-provider',
-      model: 'test-model',
-      fast: false,
-      runtimeUrls,
-    });
-    assert.equal(run.ok, false);
-    assert.equal(run.sessionId, null);
-    assert.match(run.stdout, /provider stdout \{diagnostic\}/);
-    assert.match(run.stderr, /provider stderr \{diagnostic\}/);
-    assert.equal(leadModeExitCode(
-      { A: [{ valid: false }], B: [{ valid: false }] },
-      { A: [], B: [] },
-    ), 1);
-  } finally {
-    rmSync(root, { recursive: true, force: true });
-  }
-});