mixdog 0.9.47 → 0.9.50

package/scripts/live-worker-smoke.mjs

@@ -19,6 +19,10 @@ const root = mkdtempSync(join(tmpdir(), 'mixdog-live-worker-'));
 const dataDir = join(root, '.mixdog-data');
 let activeAsks = 0;
 let maxActiveAsks = 0;
+let releaseBusyGate = null;
+let busySafetyTimer = null;
+let agentRunner = null;
+let runnerClosed = false;
 
 function assert(condition, message) {
   if (!condition) throw new Error(message);
@@ -28,6 +32,33 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function waitForBusyRelease() {
+  return new Promise((resolve) => {
+    const release = () => {
+      if (busySafetyTimer) clearTimeout(busySafetyTimer);
+      busySafetyTimer = null;
+      if (releaseBusyGate === release) releaseBusyGate = null;
+      resolve();
+    };
+    releaseBusyGate = release;
+    busySafetyTimer = setTimeout(release, 10_000);
+  });
+}
+
+function releaseBusyWorker() {
+  const release = releaseBusyGate;
+  releaseBusyGate = null;
+  if (busySafetyTimer) clearTimeout(busySafetyTimer);
+  busySafetyTimer = null;
+  release?.();
+}
+
+function closeAgentRunner() {
+  if (!agentRunner || runnerClosed) return;
+  runnerClosed = true;
+  agentRunner.closeAll('live-worker-smoke-end');
+}
+
 function taskId(text) {
   return String(text).match(/agent task: (\S+)/)?.[1] || null;
 }
@@ -45,13 +76,16 @@ async function main() {
     .split(/[.!?]\s+|;|,\s+(?=(?:but|however|yet)\b)/)
     .some((clause) => {
       const hasReview = /\b(review|reviewer|verification)\b/.test(clause);
-      const hasSkip = /\b(skip|skipping|skipped|omit|omits|omitting|omitted)\b/.test(clause) ||
+      const hasSkip = /\b(skip|skipping|skipped|skippable|omit|omits|omitting|omitted)\b/.test(clause) ||
         /\bwithout\s+(?:any\s+)?(?:a\s+)?(?:review|reviewer|verification)\b/.test(clause);
-      const negated = /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\b(?:skip|skipping|skipped|omit|omitting|omitted)\b/.test(clause) ||
-        /\b(?:skip|skipping|skipped|omit|omitting|omitted)\b[^;]{0,40}\b(?:not allowed|forbidden|prohibited)\b/.test(clause) ||
+      const weakRequirement = /\b(?:optional|unnecessary|not required|need not)\b/.test(clause);
+      const negated = /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\b(?:skip|skipping|skipped|skippable|omit|omitting|omitted)\b/.test(clause) ||
+        /\b(?:skip|skipping|skipped|skippable|omit|omitting|omitted)\b[^;]{0,40}\b(?:not allowed|forbidden|prohibited)\b/.test(clause) ||
         /\b(?:never|(?:must|shall|may)\s+not|can(?:not|'t)|do\s+not|don't|not)\b[^;]{0,40}\bwithout\s+(?:any\s+)?(?:a\s+)?(?:review|reviewer|verification)\b/.test(clause);
+      const negatedWeakRequirement = /\b(?:not|never)\s+(?:optional|unnecessary)\b/.test(clause);
       const exception = /\b(?:unless|except(?:\s+when)?|only\s+if)\b/.test(clause);
-      return hasReview && hasSkip && (!negated || exception);
+      return hasReview && ((hasSkip && (!negated || exception)) ||
+        (weakRequirement && (!negatedWeakRequirement || exception)));
     });
   for (const [phrase, expected] of [
     ['Never skip Reviewer verification', false],
@@ -63,16 +97,24 @@ async function main() {
     ['Never skip review only if low-risk', true],
     ['May omit review', true],
     ['Proceed without review', true],
+    ['Review is optional', true],
+    ['Review is unnecessary', true],
+    ['Review is not required', true],
+    ['Review is skippable for low-risk work', true],
+    ['Review is not optional', false],
+    ['Review is not unnecessary', false],
   ]) assert(reviewSkipViolation(phrase) === expected, `review-skip detector case failed: ${phrase}`);
   const skipsReview = reviewSkipViolation(workflow);
   assert(hasAll(lead, 'write-role agents self-verify', 'cross-scope verification', 'benches', 'all git', 'current project/workspace'), 'lead tool rules must preserve verification, git, and workspace ownership');
-  assert(hasAll(workflow, 'after approval', 'delegate', 'by default'), 'default workflow must delegate after approval');
-  assert(hasAll(workflow, 'coordinates', 'git', '1-edit', '1-check'), 'default workflow must limit Lead direct work');
-  assert(hasAll(workflow, 'implementation/research/debugging', 'matching agent'), 'default workflow must route other work to matching agents');
-  assert(hasAll(workflow, 'parallel', 'independent', 'every delegated implementation'), 'workflow rules must keep independent work parallel');
-  assert(hasAll(workflow, 'every delegated implementation', 'reviewer', 'lead integration', 'fix', 're-verify'), 'default workflow must require review and the fix loop');
+  assert(hasAll(workflow, 'before the user explicitly approves the latest plan', 'no edits, no state mutation, no delegation'), 'default workflow must require latest-plan approval before work');
+  assert(hasAll(workflow, 'on approval, fan out at maximum width', 'one agent per independent scope', 'all spawned in one turn'), 'default workflow must fan out independent scopes at maximum width');
+  assert(hasAll(workflow, 'simple, well-understood implementation goes to worker', 'complex or investigative implementation goes to heavy worker', 'lead itself edits only a local, one-turn configuration/git change', 'debugger only on a defect needing deep root-cause analysis or a bug surviving 2+ review/fix cycles'), 'default workflow must enforce role routing and Lead/Debugger limits');
+  assert(hasAll(workflow, 'every implementation gets its own reviewer, attached per scope', 'only the local lead-direct edits above are exempt', 'lead itself edits only a local, one-turn configuration/git change', 'keep the same reviewer through the fix loop', 'fix -> re-verify until clean', 'lead cross-verifies'), 'default workflow must require a Reviewer for every implementation except local Lead-direct one-turn config/git edits');
+  assert(hasAll(workflow, 'build, deploy, commit, and push happen only on an explicit user request', 'on direction change, pause and re-consult the user'), 'default workflow must require user authorization and re-consultation');
   assert(!skipsReview, 'default workflow must not permit delegated-review skips');
-  assert(hasAll(solo, 'never spawn', 'send', 'delegate', 'ask agents'), 'Solo workflow must forbid delegation');
+  assert(hasAll(solo, 'before the user explicitly approves the latest plan', 'read-only investigation and planning — no edits, no state mutation', 'a new or changed request resets planning; a scope change requires fresh approval'), 'Solo workflow must require latest-plan approval and reset it for request or scope changes');
+  assert(hasAll(solo, 'on approval, lead executes all work itself', 'never spawn, send, or delegate to agents', 'verify directly: check and fix until clean, or report the blocker'), 'Solo workflow must keep work with Lead, forbid delegation, and verify directly');
+  assert(hasAll(solo, 'build, deploy, commit, and push happen only on an explicit user request', 'on direction change, pause and re-consult the user'), 'Solo workflow must require user authorization and re-consultation');
   assert(/always start background tasks/i.test(AGENT_TOOL.description || '') && /distinct tags?/i.test(AGENT_TOOL.description || '') && /completion notification/i.test(AGENT_TOOL.description || ''), 'agent tool description must expose async parallel tags');
 
   mkdirSync(dataDir, { recursive: true });
@@ -112,7 +154,7 @@ async function main() {
     maxActiveAsks = Math.max(maxActiveAsks, activeAsks);
     try {
       if (/parallel slow/i.test(prompt)) await sleep(600);
-      if (/long busy/i.test(prompt)) await sleep(350);
+      if (/long busy/i.test(prompt)) await waitForBusyRelease();
       if (/write implementation/i.test(prompt)) {
         const out = await executePatchTool('apply_patch', {
           base_path: cwdOverride,
@@ -163,7 +205,7 @@ async function main() {
     getSessionLastProgressAt,
     askSession: fakeAskSession,
   };
-  const agentRunner = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+  agentRunner = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
 
   async function waitJob(out, pattern, label) {
     const id = taskId(out);
@@ -180,10 +222,11 @@ async function main() {
 
   async function waitAgentTag(tag, label) {
     for (let i = 0; i < 20; i += 1) {
-      if (listSessions().some((session) => session?.agentTag === tag && !session.closed)) return;
+      if (agentRunner.getStatus({ cwd: root }).workers
+        .some((worker) => worker?.tag === tag && worker.status === 'running')) return;
       await sleep(25);
     }
-    throw new Error(`${label} did not register agent tag ${tag}`);
+    throw new Error(`${label} did not start agent tag ${tag}`);
   }
 
   const spawnOut = await agentRunner.execute({
@@ -265,17 +308,26 @@ async function main() {
     message: 'follow-up while still busy',
   }, { invocationSource: 'model-tool', cwd: root });
   assert(/agent message queued/.test(queued), `busy send should queue, got ${queued}`);
+  releaseBusyWorker();
   await waitJob(busyOut, /ack worker/, 'busy worker');
 
   const missing = await agentRunner.execute({ type: 'read', task_id: 'task_missing_live_smoke' }, { invocationSource: 'model-tool', cwd: root });
   assert(/^Error[\s:[]/.test(missing), 'missing agent task should be Error result');
   assert(readFileSync(join(root, 'feature.txt'), 'utf8').includes('beta from worker'), 'final file missing worker edit');
-  agentRunner.closeAll('live-worker-smoke-end');
+  closeAgentRunner();
   process.stdout.write('live worker smoke passed\n');
 }
 
 try {
   await main();
 } finally {
-  rmSync(root, { recursive: true, force: true });
+  try {
+    releaseBusyWorker();
+  } finally {
+    try {
+      closeAgentRunner();
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }
 }

package/scripts/memory-core-input-test.mjs

@@ -5,16 +5,27 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { normalizeCoreInput } from '../src/runtime/memory/lib/core-memory-store.mjs'
 import { createMemoryActionHandlers } from '../src/runtime/memory/lib/memory-action-handlers.mjs'
+import { TOOL_DEFS as MEMORY_TOOL_DEFS } from '../src/runtime/memory/tool-defs.mjs'
+import { parseMemoryCandidateRows, parseMemoryCoreRows } from '../src/tui/app/input-parsers.mjs'
 
-test('core content aliases summary and derives a bounded element', () => {
+test('memory mutation schema omits category while recall keeps its internal filter', () => {
+  const memoryTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'memory')
+  const recallTool = MEMORY_TOOL_DEFS.find((tool) => tool.name === 'recall')
+  assert.equal(Object.hasOwn(memoryTool.inputSchema.properties, 'category'), false)
+  assert.doesNotMatch(memoryTool.description, /category/i)
+  assert.equal(Object.hasOwn(recallTool.inputSchema.properties, 'category'), true)
+})
+
+test('core content aliases summary, derives an element, and accepts no category', () => {
   const content = 'A durable preference that callers should receive concise answers.'
-  const input = normalizeCoreInput({ content, category: 'preference' }, {
+  const input = normalizeCoreInput({ content }, {
     requireElement: true,
     requireSummary: true,
-    requireCategory: true,
+    requireCategory: false,
   })
   assert.equal(input.summary, content)
   assert.equal(input.element, content.slice(0, 40))
+  assert.equal(input.category, 'fact')
   assert.deepEqual(input.errors, [])
 })
 
@@ -34,12 +45,11 @@ test('core add reports every invalid field and cwd project hint together', async
       cwd,
       element: 'x'.repeat(41),
       summary: 'y'.repeat(101),
-      category: 'unknown',
     })
     assert.equal(result.isError, true)
     assert.equal(
       result.text,
-      'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool (cwd suggests "owner/repo"); element too long (41/40 chars, remove 1); summary too long (101/100 chars, remove 1); invalid category "unknown". Valid: rule, constraint, decision, fact, goal, preference, task, issue',
+      'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool (cwd suggests "owner/repo"); element too long (41/40 chars, remove 1); summary too long (101/100 chars, remove 1)',
     )
   } finally {
     await rm(cwd, { recursive: true, force: true })
@@ -58,13 +68,11 @@ test('core add rejects blank project_id in the batched error', async () => {
     project_id: ' ',
     element: 'x'.repeat(41),
     summary: 'y'.repeat(101),
-    category: 'unknown',
   })
   assert.equal(result.isError, true)
   assert.match(result.text, /^core add: project_id required —/)
   assert.match(result.text, /element too long \(41\/40 chars, remove 1\)/)
   assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
-  assert.match(result.text, /invalid category "unknown"/)
 })
 
 test('core add folds project_id "*" into the batched error', async () => {
@@ -79,12 +87,10 @@ test('core add folds project_id "*" into the batched error', async () => {
     project_id: '*',
     element: 'x'.repeat(41),
     summary: 'y'.repeat(101),
-    category: 'unknown',
   })
   assert.equal(result.isError, true)
   assert.match(result.text, /^core add: project_id "\*" only valid for op="list"; element too long/)
   assert.match(result.text, /summary too long \(101\/100 chars, remove 1\)/)
-  assert.match(result.text, /invalid category "unknown"/)
 })
 
 test('core add suppresses malformed cwd project hints', async () => {
@@ -103,7 +109,6 @@ test('core add suppresses malformed cwd project hints', async () => {
       cwd,
       element: 'durable preference',
       summary: 'Callers prefer concise answers.',
-      category: 'preference',
     })
     assert.equal(result.text, 'core add: project_id required — pass "common" for COMMON pool, or project slug like "owner/repo" for scoped pool')
   } finally {
@@ -119,7 +124,7 @@ test('core edit by id succeeds without project_id', async () => {
     readMainConfig: () => ({}),
     editCoreImpl: async (dataDir, id, patch) => {
       call = { dataDir, id, patch }
-      return { id: Number(id), element: patch.element, summary: patch.summary, category: patch.category }
+      return { id: Number(id), element: patch.element, summary: patch.summary, category: 'preference' }
     },
   })
   const result = await handleMemoryAction({
@@ -128,10 +133,25 @@ test('core edit by id succeeds without project_id', async () => {
     id: 7,
     element: 'reply style',
     summary: 'Use concise answers.',
-    category: 'preference',
   })
   assert.equal(result.isError, undefined)
-  assert.equal(result.text, 'core edited (id=7): [preference] reply style — Use concise answers.')
+  assert.equal(result.text, 'core edited (id=7): reply style — Use concise answers.')
   assert.equal(call.id, 7)
   assert.equal(call.patch.project_id, undefined)
+  assert.equal(call.patch.category, undefined)
+})
+
+test('category-free core and candidate rows remain selectable in the TUI', () => {
+  const [core] = parseMemoryCoreRows('COMMON:\nid=7 reply style — Use concise answers.')
+  assert.equal(core._id, 7)
+  assert.equal(core._element, 'reply style')
+  assert.equal(core._summary, 'Use concise answers.')
+  assert.equal(Object.hasOwn(core, '_category'), false)
+
+  const [candidate] = parseMemoryCandidateRows(
+    'id=9 project=COMMON score=1.60 coding agent refs — Use C:\\Project\\refs. (durable)',
+  )
+  assert.equal(candidate._id, 9)
+  assert.equal(candidate.label, '#9 coding agent refs')
+  assert.equal(candidate._projectId, null)
 })

package/scripts/native-edit-wire-test.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { once } from 'node:events';
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import {
+  closeNativePatchServerForTests,
+  runServerEdit,
+} from '../src/runtime/agent/orchestrator/tools/patch.mjs';
+
+const binary = process.env.MIXDOG_EDIT_NATIVE_BIN;
+assert.ok(binary, 'MIXDOG_EDIT_NATIVE_BIN must point to the release mixdog-patch binary');
+assert.ok(existsSync(binary), `native EDIT test binary does not exist: ${binary}`);
+
+const responseFields = [
+  'replacements',
+  'readMs',
+  'applyMs',
+  'writeMs',
+  'totalMs',
+  'tier',
+  'contentHash',
+  'roundtripMs',
+];
+
+function digest(content) {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function assertCompleteResponse(response, { replacements, tier, content }) {
+  assert.deepEqual(Object.keys(response), responseFields, 'EDIT response must expose all eight decoded fields');
+  assert.equal(response.replacements, replacements);
+  assert.equal(response.tier, tier);
+  assert.match(response.contentHash, /^[a-f0-9]{64}$/);
+  assert.equal(response.contentHash, digest(content), 'EDIT response hash must describe the resulting bytes');
+  for (const field of ['readMs', 'applyMs', 'writeMs', 'totalMs', 'roundtripMs']) {
+    assert.ok(Number.isFinite(response[field]) && response[field] >= 0, `${field} must be a non-negative number`);
+  }
+}
+
+function edit(fullPath, oldString, newString, options = {}) {
+  return runServerEdit({
+    fullPath,
+    oldBuf: Buffer.from(oldString, 'utf8'),
+    newBuf: Buffer.from(newString, 'utf8'),
+    ...options,
+  });
+}
+
+async function rawEdit(fullPath, oldString, newString, { replaceAll = false, dryRun = false } = {}) {
+  const pathBuf = Buffer.from(fullPath, 'utf8');
+  const oldBuf = Buffer.from(oldString, 'utf8');
+  const newBuf = Buffer.from(newString, 'utf8');
+  const child = spawn(binary, ['--server'], { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+  const stdout = [];
+  const stderr = [];
+  child.stdout.on('data', (chunk) => stdout.push(chunk));
+  child.stderr.on('data', (chunk) => stderr.push(chunk));
+  child.stdin.end(Buffer.concat([
+    Buffer.from(`EDIT ${pathBuf.length} ${oldBuf.length} ${newBuf.length} ${replaceAll ? 1 : 0} ${dryRun ? 1 : 0}\n`),
+    pathBuf,
+    oldBuf,
+    newBuf,
+    Buffer.from('QUIT\n'),
+  ]));
+  const [code] = await once(child, 'exit');
+  assert.equal(code, 0, `raw native EDIT server failed: ${Buffer.concat(stderr).toString('utf8')}`);
+  return Buffer.concat(stdout).toString('utf8').trimEnd();
+}
+
+function assertRawResponse(line) {
+  const fields = line.split('\t');
+  assert.equal(fields.length, 8, 'raw EDIT response must contain exactly eight tab-delimited fields');
+  assert.equal(fields[0], 'OK');
+  for (const index of [2, 3, 4, 5]) {
+    assert.notEqual(fields[index], '', `raw EDIT timing field ${index} must be present`);
+    assert.match(fields[index], /^\d+(?:\.\d+)?$/, `raw EDIT timing field ${index} must be numeric`);
+  }
+}
+
+test('native EDIT production wire path preserves matching and response invariants', async (t) => {
+  const root = mkdtempSync(join(tmpdir(), 'mixdog-native-edit-wire-'));
+  try {
+    await t.test('rejects ambiguity, then reports the replace-all repeat count and full response', async () => {
+      const path = join(root, 'repeats.txt');
+      writeFileSync(path, 'token token token\n', 'utf8');
+
+      await assert.rejects(
+        edit(path, 'token', 'value'),
+        (error) => {
+          assert.equal(error.message, 'old_string found 3 times');
+          return true;
+        },
+      );
+      assert.equal(readFileSync(path, 'utf8'), 'token token token\n');
+
+      const expected = 'value value value\n';
+      assertRawResponse(await rawEdit(path, 'token', 'value', { replaceAll: true, dryRun: true }));
+      const response = await edit(path, 'token', 'value', { replaceAll: true });
+      assert.equal(readFileSync(path, 'utf8'), expected);
+      assertCompleteResponse(response, { replacements: 3, tier: 'exact', content: expected });
+    });
+
+    await t.test('rejects a 30-line folded match without writing', async () => {
+      const path = join(root, 'folded-30.txt');
+      const source = Array.from({ length: 30 }, (_, i) => `line ${i + 1} “value”`).join('\n');
+      const foldedNeedle = Array.from({ length: 30 }, (_, i) => `line ${i + 1} "value"`).join('\n');
+      writeFileSync(path, source, 'utf8');
+
+      await assert.rejects(
+        edit(path, foldedNeedle, 'unsafe replacement'),
+        /old_string is 30 lines \(>= 30\)\./,
+      );
+      assert.equal(readFileSync(path, 'utf8'), source);
+    });
+
+    await t.test('absorbs the deleted line newline', async () => {
+      const path = join(root, 'delete-crlf.txt');
+      const source = 'keep\r\ndelete me\r\nafter\r\n';
+      const expected = 'keep\r\nafter\r\n';
+      writeFileSync(path, source, 'utf8');
+
+      const response = await edit(path, 'delete me', '');
+      assert.equal(readFileSync(path, 'utf8'), expected);
+      assertCompleteResponse(response, { replacements: 1, tier: 'exact', content: expected });
+    });
+
+    await t.test('preserves CRLF while lowering an LF-authored replacement', async () => {
+      const path = join(root, 'preserve-crlf.txt');
+      const source = 'head\r\nold a\r\nold b\r\ntail\r\n';
+      const expected = 'head\r\nnew a\r\nnew b\r\ntail\r\n';
+      writeFileSync(path, source, 'utf8');
+
+      const response = await edit(path, 'old a\nold b', 'new a\nnew b');
+      assert.equal(readFileSync(path, 'utf8'), expected);
+      assertCompleteResponse(response, { replacements: 1, tier: 'crlf', content: expected });
+    });
+  } finally {
+    await closeNativePatchServerForTests();
+    rmSync(root, { recursive: true, force: true });
+  }
+});