mixdog 0.9.37 → 0.9.39

package/scripts/internal-comms-smoke.mjs

@@ -19,38 +19,80 @@ function assert(condition, message) {
 function readSrc(...parts) {
   return readFileSync(join(root, 'src', ...parts), 'utf8');
 }
-// Rules wrap across lines; collapse whitespace so phrase asserts are line-agnostic.
-function flat(text) {
-  return String(text || '').replace(/\s+/g, ' ');
+function normalize(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+function rawBlock(text, start, end, label) {
+  const source = String(text);
+  const from = source.indexOf(start);
+  if (from < 0) throw new Error(`${label}: missing start marker ${start}`);
+  const finish = source.indexOf(end, from + start.length);
+  if (finish < 0) throw new Error(`${label}: missing end marker ${end}`);
+  return source.slice(from, finish);
+}
+function block(text, start, end, label) {
+  return normalize(rawBlock(text, start, end, label));
+}
+function bodyAfterFrontmatter(text, label) {
+  const source = String(text);
+  const opening = source.match(/^---[ \t]*\r?\n/);
+  if (!opening) throw new Error(`${label}: missing frontmatter opening fence`);
+  const closing = source.slice(opening[0].length).match(/^---[ \t]*(?:\r?\n|$)/m);
+  if (!closing) throw new Error(`${label}: missing frontmatter closing fence`);
+  return source.slice(opening[0].length + closing.index + closing[0].length);
+}
+function roleBody(text, label) {
+  return normalize(bodyAfterFrontmatter(text, label));
+}
+function frontmatter(text, label) {
+  const source = String(text);
+  const opening = source.match(/^---[ \t]*\r?\n/);
+  if (!opening) throw new Error(`${label}: missing frontmatter opening fence`);
+  const closing = source.slice(opening[0].length).match(/^---[ \t]*(?:\r?\n|$)/m);
+  if (!closing) throw new Error(`${label}: missing frontmatter closing fence`);
+  return source.slice(opening[0].length, opening[0].length + closing.index);
 }
 
-// --- Lead brief contract: canonical in lead-brief.md, referenced from WORKFLOW -
+// --- Compact rule contracts -------------------------------------------------
 const workflow = readSrc('workflows', 'default', 'WORKFLOW.md');
 const leadBrief = readSrc('rules', 'lead', 'lead-brief.md');
+const solo = readSrc('workflows', 'solo', 'WORKFLOW.md');
+const bench = readSrc('workflows', 'bench', 'WORKFLOW.md');
+const general = readSrc('rules', 'lead', '01-general.md');
+const leadTool = readSrc('rules', 'lead', 'lead-tool.md');
+const core = readSrc('rules', 'agent', '00-core.md');
+const common = readSrc('rules', 'agent', '00-common.md');
+const skip = readSrc('rules', 'agent', '20-skip-protocol.md');
 const BRIEF_FIELDS = ['Goal:', 'Anchors:', 'Allow/Forbid:', 'Deliver:', 'Verify:'];
-// Canonical brief contract lives in lead-brief.md (Lead brief contract).
-assert(/minimum characters, maximum information/i.test(flat(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
+const TOKEN_PRINCIPLE = /minimum (?:characters|chars), maximum (?:information|info)/i;
+function requireAll(text, label, patterns) {
+  for (const pattern of patterns) assert(pattern.test(normalize(text).toLowerCase()), `${label}: missing ${pattern}`);
+}
+assert(TOKEN_PRINCIPLE.test(normalize(leadBrief)), 'lead-brief.md: brief must state min-char/max-info principle');
 for (const field of BRIEF_FIELDS) assert(leadBrief.includes(field), `lead-brief.md: brief missing labeled field ${field}`);
 assert(leadBrief.includes('Stop:'), 'lead-brief.md: brief must add Stop: for heavy-worker bound');
-assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(flat(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
-assert(/authoritative/i.test(flat(leadBrief)), 'lead-brief.md: brief must state spec-file precedence over summary');
-// WORKFLOW.md must not duplicate the field list; it defers to the lead brief contract.
-assert(/lead brief contract/i.test(flat(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
+assert(/role-known|already (?:owns|knows)|wasted cost|wasted/i.test(normalize(leadBrief)), 'lead-brief.md: brief must ban restating known rules/background as cost');
+assert(/spec\/test beats its summary/i.test(normalize(leadBrief)), 'lead-brief.md: spec/test must beat summary');
+requireAll(leadBrief, 'Lead brief lifecycle', [
+  /full brief only for fresh spawn\/`respawned: true`/, /live follow-ups are delta/,
+  /dead-tag send is cold: re-supply anchors/, /never `send` mid-run/,
+  /batch one follow-up after completion/, /interrupt only to cancel/,
+  /agent communication is english/,
+]);
+assert(/lead brief contract/i.test(normalize(workflow)), 'WORKFLOW.md: must defer to the lead brief contract');
 assert(!BRIEF_FIELDS.every((field) => workflow.includes(field)), 'WORKFLOW.md: must not duplicate the full brief field list');
 
-// --- Agent handoff contract (00-core.md) -----------------------------------
-const core = readSrc('rules', 'agent', '00-core.md');
-assert(/minimum characters, maximum information/i.test(flat(core)), '00-core: handoff must state token-optimized principle');
 assert(/fragments/i.test(core), '00-core: handoff must require fragments');
 assert(/file:line/i.test(core), '00-core: handoff must anchor evidence to file:line');
-assert(/Banned as pure cost/i.test(flat(core)), '00-core: handoff must list banned cost items');
 for (const banned of ['headings', 'tables', 'narration', 'raw logs', 'next-checks']) {
   assert(core.toLowerCase().includes(banned), `00-core: banned list missing ${banned}`);
 }
-const common = readSrc('rules', 'agent', '00-common.md');
 assert(/Public Agent Constraints/i.test(common), '00-common: must be titled public-only constraints');
-assert(/git operations deferred to Lead/i.test(common), '00-common: must refuse git/Ship');
+assert(/git operations deferred to Lead/i.test(normalize(common)), '00-common: must refuse git/Ship');
 assert(/Overflow goes to a file/i.test(common), '00-common: must keep overflow-to-file rule');
+requireAll(common, 'Public-agent shell', [
+  /shell only verifies own edits/, /no exploration, install, or state change beyond brief/,
+]);
 
 // --- Per-role output contracts --------------------------------------------
 const roles = {
@@ -59,19 +101,125 @@ const roles = {
   'reviewer/AGENT.md': readSrc('agents', 'reviewer', 'AGENT.md'),
   'debugger/AGENT.md': readSrc('agents', 'debugger', 'AGENT.md'),
 };
-for (const [name, text] of Object.entries(roles)) {
-  assert(/file:line/i.test(text), `${name}: role output must anchor to file:line`);
-  assert(/fragments|no report bloat|no prose|no narration|no preamble/i.test(flat(text)), `${name}: role output must forbid prose bloat`);
+
+// Semantic contracts deliberately avoid prose snapshots.
+function snapshot(actual, expected, label) {
+  assert(normalize(actual) === normalize(expected), `${label}: canonical snapshot changed`);
+}
+assert(/^agents:\s*$/m.test(frontmatter(solo, 'Solo workflow')), 'Solo: agents frontmatter must be empty');
+requireAll(workflow, 'Default approval', [
+  /read-only investigation\/planning while consulting/, /later explicit user message after the latest plan/,
+  /initial\/additional\/changed requests reset planning/, /scope change needs a revised plan and fresh approval/,
+  /no edits, state mutation, or delegation/,
+]);
+requireAll(workflow, 'Default routing', [
+  /delegate by default/, /only coordinates, does git, or an obvious 1-edit\/ 1-check change/,
+  /implementation\/research\/debugging to its matching agent/, /indicators, not automatic categories/,
+  /worker: bounded established path, low local risk\/coupling\/verification, clear local check/,
+  /heavy worker: high risk\/coupling\/verification \(including any high-risk scope\), or coupled staged work needing coordinated verification/,
+  /reviewer verifies an implementation/, /debugger handles requested debugging or root cause after a failed fix/,
+]);
+requireAll(workflow, 'Default lifecycle', [
+  /draft before any implementation/, /parallel gain exceeds coordination\/merge cost/,
+  /all in one turn, with no count cap/, /real dependency, overlapping write, or inseparable coupling/,
+  /after async spawn, end the turn/, /every delegated implementation gets one reviewer/,
+  /lead integration\/cross-scope verification in parallel/, /high-risk scopes add distinct lenses/,
+  /original live session/, /loop fix -> re-verify \(same reviewer \+ lead re-check\) until clean/,
+  /bug surviving 2\+ fix cycles/, /agent reports relay.*as in-progress, never conclusions/,
+  /final \(not interim\) report/, /never forward raw agent output/,
+  /explicit user request after issue-free feedback/, /outcome\/direction change, pause and re-consult/,
+]);
+requireAll(solo, 'Solo lifecycle', [
+  /no edits or state mutation/, /never spawn, send, delegate, or ask agents to work/,
+  /read-only investigation\/planning while consulting/,
+  /later explicit user message after the latest plan/,
+  /initial\/additional\/changed requests reset planning/,
+  /scope change needs a revised plan and fresh approval/,
+  /checks\/fixes directly until clean or reports a blocker/, /final \(not interim\) report/,
+  /interim updates are in-progress, never conclusions/,
+  /issue-free user feedback/,
+]);
+requireAll(bench, 'Bench lifecycle', [
+  /never wait for approval or ask questions/, /verified complete or provably blocked/,
+  /maximum independent scopes/, /spawning every scope in one turn/,
+  /build\/test-green gate/, /no polling, guessing, or dependent work/,
+  /one reviewer per implementation scope/, /never deferred\/batched/,
+  /fact-check agent responses and cross-check implementation\/review yourself before acting/,
+  /return fixes to the original scope/, /loop verify -> fix -> re-verify until clean/,
+  /skip only simple, low-risk review/, /hard blocked/, /outcome and evidence/,
+]);
+requireAll(leadTool, 'Lead tools', [
+  /write-role agents self-verify/, /cross-scope verification.*benches.*all git/,
+  /workflow permits delegation/, /no-delegation workflow.*controls/,
+]);
+requireAll(general, 'General safety', [
+  /identify as mixdog\/current coding agent/, /destructive\/hard-to-reverse action needs explicit confirmation/,
+  /never push, build, deploy without explicit user request/, /implementation approval is not deploy approval/,
+]);
+requireAll(skip, 'Silent skip', [
+  /webhook-handler/, /scheduler-task/, /label-only, duplicate\/dedup, no action needed\/report/,
+  /whole response.*\[meta:silent\]/,
+]);
+
+const roleSnapshots = {
+  'worker/AGENT.md': `# Worker
+Scoped implementation agent.
+
+Own only the bounded responsibility assigned in the brief. Trust its
+\`file:line\` anchors; do only minimal targeted discovery, then make the
+smallest coherent patch. No drive-by cleanup or scope expansion.
+
+EDIT-FIRST DISCIPLINE. Patch promptly rather than repeating read-only turns;
+stop and report blocked when the assigned scope cannot be completed.
+
+Self-verify with a targeted check (for example, \`node --check\` or a focused
+test), then report the changed \`file:line\` and stop.`,
+  'heavy-worker/AGENT.md': `# Heavy Worker
+Own the assigned implementation slice through staged delivery.
+
+Break work into bounded, dependency-aware slices and execute them in sequence.
+At each checkpoint, run the narrowest relevant test or build before expanding
+the slice. Keep the smallest coherent change; control blast radius rather than
+rewriting adjacent systems.
+
+EDIT-FIRST DISCIPLINE. Patch incrementally and stop at the first explicit
+boundary: unclear ownership, a missing dependency, or growing blast radius.
+Do not cross that boundary without a new bounded assignment; report blocked
+work with the relevant file:line.
+
+Self-verify each checkpoint and the final slice with shell (targeted test/build).`,
+  'reviewer/AGENT.md': `# Reviewer
+Independent regression/risk review agent.
+
+Review the approved intent, diff, and tests with independent judgment. Prioritize
+actionable correctness, regression, security, and verification risks; inspect
+affected boundaries. Do not reimplement the change or report non-risky nits.
+Report findings first, severity-ordered, with one line per \`file:line\`. If clean,
+say so in one line and include only material residual risk.`,
+  'debugger/AGENT.md': `# Debugger
+Root-cause analysis agent.
+
+Smallest confirmed cause chain before fixes. Return likely cause, evidence
+(\`file:line\`), smallest next check/fix. Mark confirmed facts vs inferences;
+avoid broad speculation.
+
+Converge, don't sweep: when new evidence stops accruing, report the best
+cause chain so far.`,
+};
+for (const [name, expected] of Object.entries(roleSnapshots)) {
+  const text = roles[name];
+  const permission = text.match(/^permission:\s*(.+)$/m)?.[1];
+  assert(permission === (name === 'worker/AGENT.md' || name === 'heavy-worker/AGENT.md' ? 'read-write' : 'read'), `${name}: permission contract changed`);
+  snapshot(roleBody(text, name), expected, name);
 }
-assert(/severity-ordered/i.test(flat(roles['reviewer/AGENT.md'])), 'reviewer: must keep severity-ordered findings');
-assert(/confirmed[\s\S]*inferences/i.test(roles['debugger/AGENT.md']), 'debugger: must separate confirmed facts vs inferences');
-assert(/Stop:|how-to-verify|how to verify/i.test(flat(roles['heavy-worker/AGENT.md'])), 'heavy-worker: must bound scope / state how to verify');
+assert(/confirmed facts vs inferences/i.test(normalize(roles['debugger/AGENT.md'])), 'debugger: must separate confirmed facts from inferences');
+assert(/file:line/i.test(normalize(roles['debugger/AGENT.md'])), 'debugger: must anchor evidence to file:line');
 
 // --- Injection: Lead rules actually carry the brief contract ---------------
 const dataDir = mkdtempSync(join(tmpdir(), 'mixdog-internal-comms-smoke-'));
 try {
   const leadRules = rulesBuilder.buildInjectionContent({ PLUGIN_ROOT: join(root, 'src'), DATA_DIR: dataDir });
-  assert(/minimum characters, maximum information/i.test(flat(leadRules)), 'injected Lead rules must carry the brief token principle');
+  assert(TOKEN_PRINCIPLE.test(normalize(leadRules)), 'injected Lead rules must carry the brief token principle');
   for (const field of BRIEF_FIELDS) assert(leadRules.includes(field), `injected Lead rules missing brief field ${field}`);
 } finally {
   rmSync(dataDir, { recursive: true, force: true });

package/scripts/live-worker-smoke.mjs

@@ -35,8 +35,44 @@ function taskId(text) {
 async function main() {
   const leadToolRules = readFileSync('src/rules/lead/lead-tool.md', 'utf8');
   const workflowRules = readFileSync('src/workflows/default/WORKFLOW.md', 'utf8');
-  assert(/Use `agent` for scoped implementation/i.test(leadToolRules), 'lead rules must direct scoped work to agents');
-  assert(/PARALLEL across independent scopes/i.test(workflowRules), 'workflow rules must keep independent work parallel');
+  const soloRules = readFileSync('src/workflows/solo/WORKFLOW.md', 'utf8');
+  const compact = (text) => text.toLowerCase().replace(/\s+/g, ' ');
+  const hasAll = (text, ...terms) => terms.every((term) => text.includes(term));
+  const lead = compact(leadToolRules);
+  const workflow = compact(workflowRules);
+  const solo = compact(soloRules);
+  const reviewSkipViolation = (text) => compact(text)
+    .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) ||
+        /\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) ||
+        /\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 exception = /\b(?:unless|except(?:\s+when)?|only\s+if)\b/.test(clause);
+      return hasReview && hasSkip && (!negated || exception);
+    });
+  for (const [phrase, expected] of [
+    ['Never skip Reviewer verification', false],
+    ['Reviewer verification must not be skipped', false],
+    ['Must not proceed without review', false],
+    ['Never skip risky review, but may skip simple review', true],
+    ['Never skip review unless low-risk', true],
+    ['Never skip review except when low-risk', true],
+    ['Never skip review only if low-risk', true],
+    ['May omit review', true],
+    ['Proceed without review', true],
+  ]) assert(reviewSkipViolation(phrase) === expected, `review-skip detector case failed: ${phrase}`);
+  const skipsReview = reviewSkipViolation(workflow);
+  assert(hasAll(lead, 'workflow permits delegation', 'use `agent`', 'implementation', 'research', 'review', 'debugging'), 'lead rules must conditionally direct scoped work to agents');
+  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(!skipsReview, 'default workflow must not permit delegated-review skips');
+  assert(hasAll(solo, 'never spawn', 'send', 'delegate', 'ask agents'), 'Solo workflow must forbid delegation');
   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 });

package/scripts/memory-cycle-routing-test.mjs

@@ -0,0 +1,111 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { resolveMaintenancePreset } from '../src/runtime/shared/llm/index.mjs'
+import { sonnetCascade } from '../src/runtime/memory/lib/memory-cycle2-gate.mjs'
+import { runPhaseMerge } from '../src/runtime/memory/lib/memory-cycle2-mutations.mjs'
+import { invokeCycle3Maintenance } from '../src/runtime/memory/lib/memory-cycle3.mjs'
+
+test('cycle2 cascade uses the memory maintenance route', async () => {
+  const expected = resolveMaintenancePreset('memory')
+  let received
+  await sonnetCascade(
+    [{ id: 1, status: 'pending', verb: 'active', category: 'fact', element: 'x', summary: 'y' }],
+    '',
+    {
+      callLlm: (opts) => {
+        received = opts
+        return '1|keep'
+      },
+    },
+  )
+  assert.deepEqual(received.preset, expected)
+  assert.equal(received.mode, 'cycle2-cascade')
+})
+
+test('cycle2 cascade preserves an explicit test override', async () => {
+  let received
+  await sonnetCascade(
+    [{ id: 1, status: 'pending', verb: 'active', category: 'fact', element: 'x', summary: 'y' }],
+    '',
+    {
+      cascadePreset: 'test-route',
+      callLlm: (opts) => {
+        received = opts
+        return '1|keep'
+      },
+    },
+  )
+  assert.equal(received.preset, 'test-route')
+})
+
+test('cycle2 phase merge judge dispatches through the memory maintenance route', async () => {
+  const expected = resolveMaintenancePreset('memory')
+  let received
+  const db = {
+    query: async () => ({ rows: [] }),
+  }
+  db.query = async (sql) => {
+    if (sql.includes('WITH active AS')) {
+      return {
+        rows: [{
+          a_id: 1, a_category: 'fact', a_summary: 'a', a_score: 1, a_last_seen_at: 1, a_status: 'active',
+          b_id: 2, b_category: 'fact', b_summary: 'b', b_score: 1, b_last_seen_at: 1, b_status: 'active',
+          sim: 0.8,
+        }],
+      }
+    }
+    return { rows: [] }
+  }
+  const result = await runPhaseMerge(db, {
+    callLlm: (opts) => {
+      received = opts
+      return 'distinct'
+    },
+  })
+  assert.equal(result.llm_calls, 1)
+  assert.deepEqual(received.preset, expected)
+  assert.equal(received.mode, 'cycle2-phase_merge_judge')
+})
+
+test('cycle2 phase merge preserves an explicit test override', async () => {
+  let received
+  const db = {
+    query: async (sql) => (sql.includes('WITH active AS')
+      ? { rows: [{ a_id: 1, a_category: 'fact', a_summary: 'a', a_score: 1, a_last_seen_at: 1, a_status: 'active', b_id: 2, b_category: 'fact', b_summary: 'b', b_score: 1, b_last_seen_at: 1, b_status: 'active', sim: 0.8 }] }
+      : { rows: [] }),
+  }
+  await runPhaseMerge(db, {
+    preset: 'test-route',
+    callLlm: (opts) => {
+      received = opts
+      return 'distinct'
+    },
+  })
+  assert.equal(received.preset, 'test-route')
+})
+
+test('cycle3 dispatches through the memory maintenance route', async () => {
+  const expected = resolveMaintenancePreset('memory')
+  let received
+  await invokeCycle3Maintenance('test prompt', {
+    callLlm: (opts) => {
+      received = opts
+      return '1|keep'
+    },
+  })
+  assert.deepEqual(received.preset, expected)
+  assert.equal(received.agent, 'cycle3-agent')
+  assert.equal(received.mode, 'cycle3-review')
+})
+
+test('cycle3 preserves an explicit test override', async () => {
+  let received
+  await invokeCycle3Maintenance('test prompt', {
+    preset: 'test-route',
+    callLlm: (opts) => {
+      received = opts
+      return '1|keep'
+    },
+  })
+  assert.equal(received.preset, 'test-route')
+})

package/scripts/memory-rule-contract-test.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+
+const root = new URL('..', import.meta.url)
+const rawRules = Object.fromEntries(await Promise.all([
+  ['cycle1', 'src/rules/agent/40-cycle1-agent.md'],
+  ['cycle2', 'src/rules/agent/41-cycle2-agent.md'],
+  ['cycle3', 'src/rules/agent/42-cycle3-agent.md'],
+].map(async ([name, path]) => [
+  name,
+  await readFile(new URL(path, root), 'utf8'),
+])))
+const rules = Object.fromEntries(Object.entries(rawRules)
+  .map(([name, text]) => [name, text.replace(/\s+/g, ' ').trim()]))
+
+function includesAll(text, clauses) {
+  for (const clause of clauses) assert.ok(text.includes(clause), `missing: ${clause}`)
+}
+
+test('cycle1 preserves chunk schema, taxonomy, coverage, and escaping', () => {
+  const text = rules.cycle1
+  includesAll(text, [
+    '<idx_csv>|<element>|<category>|<summary>', 'included input row numbers',
+    'comma-separated, without `@`', '5–10-word recall key',
+    '`rule` (standing policy)', '`constraint` (hard limit)',
+    '`decision` (agreed choice)', '`fact` (verified truth)', '`goal` (open target)',
+    '`preference` (style/taste)', '`task` (pending work)', '`issue` (broken state)',
+    '1–3 complete sentences', 'important names, paths, IDs, versions, numbers, errors, causes, and outcomes verbatim',
+    'match input language', 'Every input row appears exactly once',
+    'Group nearby same-topic rows, splitting only at real topic changes',
+    'retain clarifications with their topic', 'Never mix `[sess:XXX]` markers',
+    'Replace literal `|` with `/`', 'fields contain no newlines',
+    'No JSON, fences, prose, preamble, or tool calls',
+  ])
+})
+
+test('cycle2 preserves essential taxonomy, phases, rejects, formats, and fields', () => {
+  const text = rules.cycle2
+  includesAll(text, [
+    '`is_root` long-term memory', 'candidate `id`/`category`/`score`/`element`/`summary`',
+    'only when clearly exactly one essential concept',
+    'identity (stable non-derivable user fact)', 'preference (durable taste/style/interaction preference)',
+    'goal (long-running committed goal)', 'principle (cross-session behavior directive)',
+    'policy (standing team decision)', 'procedure (recurring trigger + steps + caveats)',
+    'event (rare foundational change not reconstructible from its rule)',
+    'system constant (durable path/schema/model/channel invariant needed later and absent from rules)',
+    'Anything unclear or outside these concepts is `archived`',
+    '`phase1_new_chunks` → `active` if clearly essential, otherwise `archived`',
+    '`phase2_reevaluate` → `active` to promote, otherwise `archived`',
+    '`phase3_active_review` requires every-row verdict: default `archived`, or `active`, `update`, `merge`',
+    'silence is not keep', 'work narratives', 'static facts without behavior/user value',
+    'rule-system meta', 'resolved bug/fix logs', 'rule-file duplicates',
+    'single-run measurements/counts/versions', 'session-scoped or in-progress decisions',
+    '<id>|<verb>', '<id>|update|<element>|<summary>',
+    '<id>|merge|<target_id>|<source_ids_csv>|<element>|<summary>',
+    'Use only input IDs; never invent IDs', 'fresh `element` and a 3-sentence `summary`',
+    'keeps `target_id`, absorbs `source_ids_csv`, and uses only one `project_id`',
+    'complete sentences in input language', 'preserve important specifics verbatim',
+    'omit actor/meta filler', '`rule > constraint > decision > fact > goal > preference > task > issue`',
+    'Replace literal `|` with `/`', 'fields contain no newlines',
+    'For phase 3, emit one verdict per input row', 'start with a digit',
+  ])
+})
+
+test('cycle3 preserves durable-event verdicts, formats, and exceptions', () => {
+  const text = rules.cycle3
+  includesAll(text, [
+    'one digit-starting pipe verdict line per input id', 'CORE is durable standing knowledge',
+    'rules, preferences, identity, goals, and current system/structure descriptions—not a log',
+    'Each entry is one short clause (≤120 chars)',
+    'Current rule/preference/live structure = durable',
+    'past event (shipped version, measured value, made fix) = not durable', 'When unsure, keep',
+    '`keep`: durable, already one short clause',
+    '`update`: durable but verbose/multi-sentence; compress to one ≤120-char clause',
+    '`merge`: duplicate; fold into its survivor in the same project pool',
+    '`delete`: past event, not a current rule or structure',
+    'Verbose durable is always `update`, never `keep`',
+    '<id>|keep', '<id>|update|<element>|<summary>',
+    '<id>|merge|<target_id>|<source_ids_csv>', '<id>|delete',
+    'IDs match input rows; never invent them', 'summary is one ≤120-char clause',
+    '`element` is short', 'retains `target_id`, absorbs sources, and stays within one `project_id`',
+    'Replace literal `|` with `/`', 'fields contain no newlines',
+    'Emit a verdict for every input row', 'start with a digit',
+  ])
+})
+
+test('compacted rules remain below their pre-compaction character counts', () => {
+  const preCompaction = { cycle1: 1214, cycle2: 2166, cycle3: 1530 }
+  for (const [name, before] of Object.entries(preCompaction)) {
+    assert.ok(rawRules[name].length < before, `${name} was not compacted`)
+  }
+})

package/scripts/notify-completion-mirror-test.mjs

@@ -0,0 +1,73 @@
+// notifyFnForSession must not double-inject a background-task completion. The
+// mirror skip is gated on an EXPLICIT model-visible-delivery ack
+// (modelVisibleDelivered), set ONLY by the TUI execution-ui path that injects
+// the completion body into the active loop — never on a generic truthy
+// onNotification return. So: delivered ack → mirror suppressed; headless /
+// display-only / API listener (no ack) → mirror kept as the sole delivery.
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { shouldMirrorCompletionToPendingQueue } from '../src/session-runtime/runtime-core.mjs';
+
+// A terminal agent completion with a Result body — accepted by
+// shouldPersistModelVisibleToolCompletion.
+const completionText = 'Async agent task task_1 completed finished.\n\nResult:\n> ok';
+const completionMeta = { type: 'agent_task_result', execution_id: 'task_1', status: 'completed' };
+
+test('delivered-live completion: no pending mirror (explicit model-visible ack)', () => {
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_live',
+    modelVisibleDelivered: true,
+    hasEnqueue: true,
+    text: completionText,
+    meta: completionMeta,
+  });
+  assert.equal(mirror, false, 'live twin already injected → mirror suppressed');
+});
+
+test('headless completion: pending mirror kept (no ack)', () => {
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_headless',
+    modelVisibleDelivered: false,
+    hasEnqueue: true,
+    text: completionText,
+    meta: completionMeta,
+  });
+  assert.equal(mirror, true, 'no listener delivered → queue copy is the sole delivery');
+});
+
+test('display-only listener returning true (no ack): pending mirror kept', () => {
+  // A generic display/API listener consumes the event (would return true) but
+  // never injects the model-visible body, so it sets NO modelVisibleDelivered
+  // ack. The mirror must stay, or the model never sees the completion body.
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_display_only',
+    modelVisibleDelivered: false,
+    hasEnqueue: true,
+    text: completionText,
+    meta: completionMeta,
+  });
+  assert.equal(mirror, true, 'generic handled===true is NOT an ack → mirror kept');
+});
+
+test('unhandled but non-terminal notification is never mirrored', () => {
+  const mirror = shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_headless',
+    modelVisibleDelivered: false,
+    hasEnqueue: true,
+    text: 'still running...',
+    meta: { status: 'running' },
+  });
+  assert.equal(mirror, false, 'only persistable terminal completions mirror');
+});
+
+test('missing session id or enqueue capability never mirrors', () => {
+  assert.equal(shouldMirrorCompletionToPendingQueue({
+    callerSessionId: '', modelVisibleDelivered: false, hasEnqueue: true,
+    text: completionText, meta: completionMeta,
+  }), false, 'no caller session → nothing to mirror into');
+  assert.equal(shouldMirrorCompletionToPendingQueue({
+    callerSessionId: 'sess_headless', modelVisibleDelivered: false, hasEnqueue: false,
+    text: completionText, meta: completionMeta,
+  }), false, 'no enqueue capability → cannot mirror');
+});

package/scripts/output-style-smoke.mjs

@@ -13,7 +13,7 @@ function assert(condition, message) {
   if (!condition) throw new Error(message);
 }
 
-const DEFAULT_REPORT_LABELS = new Set(['\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
+const DEFAULT_REPORT_LABELS = new Set(['Changes', 'Verification', 'Risks / next steps', '\uBC14\uB010 \uC810', '\uD655\uC778\uD55C \uAC83', '\uB0A8\uC740 \uB9AC\uC2A4\uD06C/\uB2E4\uC74C \uB2E8\uACC4', '\uB2E4\uC74C \uB2E8\uACC4']);
 
 function assertCleanOutput(name, value, { maxLines = 3, maxBullets = 3, allowedLabels = new Set() } = {}) {
   const text = String(value || '').trim();
@@ -52,7 +52,7 @@ for (const required of [
   'Mixdog default — the most detailed style',
   'State conclusions, not reasoning',
   'Use labels such as',
-  '`\uBC14\uB010 \uC810`, `\uD655\uC778\uD55C \uAC83`,',
+  '`Changes`, `Verification`,',
   'Synthesize agent or retrieval results',
   'Do not hide blockers',
 ]) {