kenaz 0.0.0-stage → 0.3.2

package/core/.formation/tools/prompt.test.js

@@ -0,0 +1,875 @@
+/**
+ * TASK_1978 — scaffold diet S2: dispatch prompt ceremony compression.
+ *
+ * Verifies the four compressed sub-agent/dispatch ceremony sections in
+ * prompt.js stay within the ≤800-byte-per-section budget, that every hard
+ * constraint that existed before the compression is still present (as a
+ * substring), and that the corresponding dispatch-detail/*.md files (moved
+ * explanatory prose) exist. Also checks the Shared Module: testing
+ * injection (sourced from .formation/roles/_shared/modules/testing.yaml).
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const path = require('path');
+
+const {
+  buildPrompt,
+  SUBAGENT_PREFIX,
+  buildSubagentWorktreePrefix,
+  appendCognitiveCheckpoint,
+  buildTaskContextQuery,
+  appendAlayaLessons,
+  deriveTaskStack,
+  deriveBijaStack,
+  passesAlayaRelevanceGate,
+  ALAYA_MIN_COSINE_DEFAULT,
+  ALAYA_STACK_OVERRIDE_COSINE,
+  ALAYA_CANDIDATE_POOL,
+  promptProfile,
+  extractRigor,
+  extractComplexity,
+  splitPromptSections,
+  resolveModules,
+  appendMemoryContext,
+  hasRustScope,
+  appendRustCheckReminder,
+  appendWorkflow,
+  applyRustCheckToPrefix,
+} = require('./prompt');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+// 800 -> 820 (2026-10-04): room for the "stash/reset --hard" ban after a subagent's
+// `git stash pop` took another session's shared stash entry. Do not trade other rules for bytes.
+const BYTE_BUDGET = 820;
+
+function bytes(str) {
+  return Buffer.byteLength(str, 'utf8');
+}
+
+function detailPath(name) {
+  return path.join(ROOT, '.formation', 'tools', 'dispatch-detail', name);
+}
+
+// ── SUBAGENT_PREFIX ([WORKTREE SUBAGENT MODE]) ──────────────────────────
+
+test('SUBAGENT_PREFIX stays within the compressed-section byte budget', () => {
+  assert.ok(
+    bytes(SUBAGENT_PREFIX) <= BYTE_BUDGET,
+    `SUBAGENT_PREFIX is ${bytes(SUBAGENT_PREFIX)} bytes, expected <= ${BYTE_BUDGET}`
+  );
+});
+
+test('SUBAGENT_PREFIX keeps every hard constraint from the pre-diet version', () => {
+  const mustContain = [
+    'commit',                 // COMMIT FIRST semantics
+    'telemetry',              // TASK_1957 telemetry-excluding git add
+    '禁 push',                 // never push
+    '刪 worktree',             // never hand-delete the worktree
+    '送出訊息=結束',            // sending the message ends execution
+    '禁長建置',                // no long builds
+    '禁 sleep 輪詢',           // no sleep-loop polling
+    '禁用 image name 殺行程',  // no taskkill by image name
+    'worktree 禁 complete',   // no task-api.js complete in worktree
+    '只做指定任務',            // single-task only
+    'pwd',                    // worktree absolute-path rule
+    'stash',                  // git stash stack is shared across sessions; a pop took another session's entry (2026-10-04)
+  ];
+  for (const needle of mustContain) {
+    assert.ok(
+      SUBAGENT_PREFIX.includes(needle),
+      `SUBAGENT_PREFIX missing hard constraint: "${needle}"`
+    );
+  }
+});
+
+test('SUBAGENT_PREFIX ends with a Details pointer to its detail file', () => {
+  assert.match(
+    SUBAGENT_PREFIX,
+    /Details: \.formation\/tools\/dispatch-detail\/worktree-subagent-mode\.md \(Read only if needed\)/
+  );
+});
+
+// ── buildSubagentWorktreePrefix (cross-project worktree variant) ───────
+
+test('cross-project worktree prefix stays within the compressed-section byte budget', () => {
+  const out = buildSubagentWorktreePrefix('WT', 'BR', 'PP');
+  assert.ok(
+    bytes(out) <= BYTE_BUDGET,
+    `cross-project prefix is ${bytes(out)} bytes, expected <= ${BYTE_BUDGET}`
+  );
+});
+
+test('cross-project worktree prefix keeps every hard constraint from the pre-diet version', () => {
+  const out = buildSubagentWorktreePrefix('WT', 'BR', 'PP');
+  const mustContain = [
+    'commit', 'telemetry', '禁 push', '刪 worktree', '送出訊息=結束',
+    '禁長建置', '禁 sleep 輪詢', '禁用 image name 殺行程',
+    'worktree 禁 complete', '只做指定任務',
+    'WT', 'PP', 'BR', // worktree path / repo / branch must be interpolated
+  ];
+  for (const needle of mustContain) {
+    assert.ok(out.includes(needle), `cross-project prefix missing: "${needle}"`);
+  }
+});
+
+test('cross-project worktree prefix ends with a Details pointer to its detail file', () => {
+  const out = buildSubagentWorktreePrefix('WT', 'BR', 'PP');
+  assert.match(
+    out,
+    /Details: \.formation\/tools\/dispatch-detail\/cross-project-worktree\.md \(Read only if needed\)/
+  );
+});
+
+// ── Shared Module: testing (sourced from _shared/modules/testing.yaml) ─
+
+function renderTestingModule() {
+  const modPath = path.join(ROOT, '.formation', 'roles', '_shared', 'modules', 'testing.yaml');
+  const raw = fs.readFileSync(modPath, 'utf-8');
+  const nameMatch = raw.match(/^name:\s*(.+)$/m);
+  const descMatch = raw.match(/^description:\s*(.+)$/m);
+  const moduleName = nameMatch ? nameMatch[1].trim() : path.basename(modPath, '.yaml');
+  const moduleDesc = descMatch ? descMatch[1].trim() : '';
+  const lines = [`## Shared Module: ${moduleName}`];
+  if (moduleDesc) { lines.push(moduleDesc); lines.push(''); }
+  const contentMatch = raw.match(/^content:\n([\s\S]*)$/m);
+  lines.push(contentMatch ? contentMatch[1].trimEnd() : raw.trimEnd());
+  return lines.join('\n');
+}
+
+test('Shared Module: testing injection stays within the compressed-section byte budget', () => {
+  const out = renderTestingModule();
+  assert.ok(
+    bytes(out) <= BYTE_BUDGET,
+    `Shared Module: testing is ${bytes(out)} bytes, expected <= ${BYTE_BUDGET}`
+  );
+});
+
+test('Shared Module: testing keeps coverage targets and defect-severity rules', () => {
+  const out = renderTestingModule();
+  const mustContain = ['>= 80%', '>= 70%', '100%', 'Critical=fix now', 'CI-integrated'];
+  for (const needle of mustContain) {
+    assert.ok(out.includes(needle), `Shared Module: testing missing: "${needle}"`);
+  }
+});
+
+test('Shared Module: testing ends with a Details pointer to its detail file', () => {
+  const out = renderTestingModule();
+  assert.match(
+    out,
+    /Details: \.formation\/tools\/dispatch-detail\/testing-module\.md \(Read only if needed\)/
+  );
+});
+
+// ── appendAlayaLessons (TASK_1992: Process lessons via alaya_recall;
+//    TASK_2101: absolute relevance floor + stack match on top) ──
+
+const ALAYA_TASK = JSON.stringify({
+  title: 'Fix appendCortexContext dedup bug',
+  scope_paths: ['.formation/tools/prompt.js'],
+});
+
+function makeStubCaller(response) {
+  // 2026-10-10: Alaya lessons are frozen by default; these tests keep covering the renderer.
+  return Object.assign((toolName, toolArgs) => {
+    assert.equal(toolName, 'alaya_recall');
+    assert.equal(toolArgs.mode, 'hybrid');
+    assert.deepEqual(toolArgs.seed_types, ['failure_seed', 'lesson_seed']);
+    // TASK_2101: wider candidate pool (post-filtering needs real candidates
+    // to keep) and the server-side cosine floor.
+    assert.equal(toolArgs.limit, ALAYA_CANDIDATE_POOL);
+    assert.equal(toolArgs.min_cosine, ALAYA_MIN_COSINE_DEFAULT);
+    if (typeof response === 'function') return response(toolArgs);
+    return response;
+  }, { __forceAlaya: true });
+}
+
+// High enough to clear ALAYA_STACK_OVERRIDE_COSINE (0.8) — bypasses the
+// stack-match half of the gate so these fixtures only exercise the floor
+// and the pre-2101 rendering/dedup/cap behavior.
+const HIGH_COSINE = 0.95;
+
+test('appendAlayaLessons renders the section from a stubbed hybrid recall with 3 seeds', () => {
+  const lines = [];
+  const stub = makeStubCaller({
+    mode_effective: 'hybrid',
+    bijas: [
+      { id: 'a1', seed_type: 'failure_seed', origin: 'local', content: 'Root cause one.', cosine: HIGH_COSINE },
+      { id: 'a2', seed_type: 'lesson_seed', origin: 'remote', content: 'Lesson two.', cosine: HIGH_COSINE },
+      { id: 'a3', seed_type: 'failure_seed', origin: 'remote', content: 'Failure three.', cosine: HIGH_COSINE },
+    ],
+  });
+  appendAlayaLessons(lines, ALAYA_TASK, stub);
+  const out = lines.join('\n');
+  assert.ok(out.includes('## Process lessons (Alaya)'));
+  assert.match(out, /Query: ".+" — 3 seeds \(mode=hybrid\)\./);
+  assert.ok(out.includes('- **failure_seed** [local] Root cause one.'));
+  assert.ok(out.includes('- **lesson_seed** [remote] Lesson two.'));
+  assert.ok(out.includes('- **failure_seed** [remote] Failure three.'));
+});
+
+test('appendAlayaLessons omits the section when the recall is null, empty, or throws', () => {
+  const nullCase = [];
+  appendAlayaLessons(nullCase, ALAYA_TASK, makeStubCaller(null));
+  assert.equal(nullCase.length, 0);
+
+  const emptyCase = [];
+  appendAlayaLessons(emptyCase, ALAYA_TASK, makeStubCaller({ mode_effective: 'hybrid', bijas: [] }));
+  assert.equal(emptyCase.length, 0);
+
+  const throwCase = [];
+  appendAlayaLessons(throwCase, ALAYA_TASK, () => { throw new Error('MCP unavailable'); });
+  assert.equal(throwCase.length, 0);
+
+  const noQueryCase = [];
+  appendAlayaLessons(noQueryCase, JSON.stringify({}), makeStubCaller({ bijas: [{ id: 'x', content: 'never called' }] }));
+  assert.equal(noQueryCase.length, 0);
+});
+
+test('appendAlayaLessons caps the rendered section at 900 chars total', () => {
+  const lines = [];
+  // Per-line content is already capped at 220 chars inside appendAlayaLessons,
+  // so 3 seeds alone stay well under 900 — push the total over budget via a
+  // long `origin` field (rendered verbatim, uncapped) instead.
+  const longOrigin = 'origin-'.repeat(60); // ~420 chars
+  const longContent = 'y'.repeat(220);
+  const stub = makeStubCaller({
+    mode_effective: 'hybrid',
+    bijas: [
+      { id: 'b1', seed_type: 'failure_seed', origin: longOrigin, content: longContent, cosine: HIGH_COSINE },
+      { id: 'b2', seed_type: 'lesson_seed', origin: longOrigin, content: longContent, cosine: HIGH_COSINE },
+      { id: 'b3', seed_type: 'failure_seed', origin: longOrigin, content: longContent, cosine: HIGH_COSINE },
+    ],
+  });
+  appendAlayaLessons(lines, ALAYA_TASK, stub);
+  const start = lines.indexOf('## Process lessons (Alaya)');
+  assert.ok(start >= 0, 'section header not found');
+  const sectionLines = lines.slice(start, lines.length - 1); // drop trailing blank line
+  const section = sectionLines.join('\n');
+  assert.ok(section.length <= 900, `section is ${section.length} chars, expected <= 900`);
+  assert.ok(section.endsWith('…'), 'over-budget section should end with an ellipsis');
+});
+
+test('appendAlayaLessons dedups seeds by id', () => {
+  const lines = [];
+  const stub = makeStubCaller({
+    mode_effective: 'hybrid',
+    bijas: [
+      { id: 'dup', seed_type: 'failure_seed', origin: 'local', content: 'First copy.', cosine: HIGH_COSINE },
+      { id: 'dup', seed_type: 'failure_seed', origin: 'local', content: 'Second copy (duplicate id).', cosine: HIGH_COSINE },
+    ],
+  });
+  appendAlayaLessons(lines, ALAYA_TASK, stub);
+  const out = lines.join('\n');
+  assert.match(out, /1 seeds/);
+  assert.ok(out.includes('First copy.'));
+  assert.ok(!out.includes('Second copy'));
+});
+
+test('buildTaskContextQuery is the single query builder shared by Cortex and Alaya', () => {
+  const q = buildTaskContextQuery(ALAYA_TASK);
+  assert.ok(q && q.includes('prompt'));
+  assert.equal(buildTaskContextQuery(JSON.stringify({})), null);
+});
+
+// ── TASK_2101: absolute relevance floor (cosine) + stack match ─────────
+
+test('deriveTaskStack extracts extensions and top path segments from scope_paths', () => {
+  const stack = deriveTaskStack(['dashboard/src-tauri/src/features/cortex/bija_embedding.rs', '.formation/tools/prompt.js']);
+  assert.ok(stack.has('rs'));
+  assert.ok(stack.has('js'));
+  assert.ok(stack.has('dashboard'));
+  assert.ok(stack.has('dashboard/src-tauri'));
+  assert.ok(stack.has('.formation'));
+  assert.ok(stack.has('.formation/tools'));
+  assert.equal(deriveTaskStack([]).size, 0);
+  assert.equal(deriveTaskStack(undefined).size, 0);
+});
+
+test('deriveBijaStack reads tags and source_symbol (file_path:symbol:kind)', () => {
+  const fromSourceSymbol = deriveBijaStack({
+    tags: '', source_symbol: 'dashboard/src-tauri/src/features/cortex/bija_embedding.rs:recall_bijas_hybrid_with_vec:function',
+  });
+  assert.ok(fromSourceSymbol.has('rs'));
+  assert.ok(fromSourceSymbol.has('dashboard'));
+
+  const fromTags = deriveBijaStack({ tags: 'unity, csharp', source_symbol: '' });
+  assert.ok(fromTags.has('unity'));
+  assert.ok(fromTags.has('csharp'));
+
+  // No signal at all (today's common case pre-hub-upgrade) -> empty, not an error.
+  assert.equal(deriveBijaStack({}).size, 0);
+  assert.equal(deriveBijaStack({ tags: '', source_symbol: '' }).size, 0);
+});
+
+test('passesAlayaRelevanceGate: cosine floor alone gates a null/low cosine out', () => {
+  const taskStack = deriveTaskStack(['.formation/tools/prompt.js']);
+  assert.equal(passesAlayaRelevanceGate({ cosine: null }, taskStack, ALAYA_MIN_COSINE_DEFAULT), false, 'null cosine (unscored) must fail the floor');
+  assert.equal(passesAlayaRelevanceGate({ cosine: ALAYA_MIN_COSINE_DEFAULT - 0.01 }, taskStack, ALAYA_MIN_COSINE_DEFAULT), false, 'below-floor cosine must fail');
+  assert.equal(
+    passesAlayaRelevanceGate({ cosine: ALAYA_MIN_COSINE_DEFAULT, tags: 'js' }, taskStack, ALAYA_MIN_COSINE_DEFAULT),
+    true,
+    'at-floor cosine with a stack match must pass'
+  );
+});
+
+test('passesAlayaRelevanceGate: stack mismatch is dropped unless cosine clears the override', () => {
+  const taskStack = deriveTaskStack(['.formation/tools/prompt.js']); // rs/js/.formation stack
+  const csharpNoise = { cosine: 0.75, tags: '', source_symbol: 'Assets/Combat/CombatFeedback.cs:Play:method' };
+  assert.equal(passesAlayaRelevanceGate(csharpNoise, taskStack, ALAYA_MIN_COSINE_DEFAULT), false, 'cross-stack .cs seed above the floor but below the override must be dropped');
+
+  const csharpButVeryRelevant = { ...csharpNoise, cosine: ALAYA_STACK_OVERRIDE_COSINE };
+  assert.equal(passesAlayaRelevanceGate(csharpButVeryRelevant, taskStack, ALAYA_MIN_COSINE_DEFAULT), true, 'cosine >= override clears a stack mismatch');
+
+  const matchingStack = { cosine: 0.75, tags: 'js', source_symbol: '' };
+  assert.equal(passesAlayaRelevanceGate(matchingStack, taskStack, ALAYA_MIN_COSINE_DEFAULT), true, 'a real stack overlap needs no override');
+});
+
+test('passesAlayaRelevanceGate: an empty task stack (no scope_paths) skips the stack half, floor still applies', () => {
+  const emptyTaskStack = deriveTaskStack([]);
+  assert.equal(passesAlayaRelevanceGate({ cosine: 0.75, tags: 'unrelated' }, emptyTaskStack, ALAYA_MIN_COSINE_DEFAULT), true);
+  assert.equal(passesAlayaRelevanceGate({ cosine: 0.1, tags: 'unrelated' }, emptyTaskStack, ALAYA_MIN_COSINE_DEFAULT), false);
+});
+
+test('ALAYA_MIN_COSINE_DEFAULT rejects the measured live noise band (TASK_2101 R4: noise 0.656-0.697, on-topic >= 0.709)', () => {
+  const emptyTaskStack = deriveTaskStack([]);
+  assert.equal(passesAlayaRelevanceGate({ cosine: 0.697 }, emptyTaskStack, ALAYA_MIN_COSINE_DEFAULT), false, 'top of the measured noise band must fail');
+  assert.equal(passesAlayaRelevanceGate({ cosine: 0.709 }, emptyTaskStack, ALAYA_MIN_COSINE_DEFAULT), true, 'bottom of the measured on-topic band must pass');
+});
+
+test('appendAlayaLessons drops candidates below the cosine floor or with a stack mismatch; renders nothing when none pass', () => {
+  const lines = [];
+  const stub = makeStubCaller({
+    mode_effective: 'hybrid',
+    bijas: [
+      // Below the floor entirely (mirrors the RRF-rank-only noise this card fixes).
+      { id: 'low_cosine', seed_type: 'failure_seed', origin: 'remote', content: 'TASK_396 combat feel seam: CombatFeedback.Play', cosine: 0.05 },
+      // Cleared the floor but wrong stack (Unity C# seed on a Rust/JS card) at a cosine well under the override.
+      { id: 'wrong_stack', seed_type: 'lesson_seed', origin: 'remote', content: 'dear-game-vm deployment is Docker-on-VM', cosine: 0.75, source_symbol: 'infra/game-vm/deploy.cs:Deploy:function' },
+      // Never scored by the semantic arm at all (fts-only hit).
+      { id: 'unscored', seed_type: 'failure_seed', origin: 'remote', content: 'Meta App Review requires Instagram OAuth', cosine: null },
+    ],
+  });
+  appendAlayaLessons(lines, ALAYA_TASK, stub);
+  assert.equal(lines.length, 0, 'zero passing candidates must render nothing, not an empty section');
+});
+
+test('appendAlayaLessons keeps a real stack match even at a moderate (non-override) cosine', () => {
+  const lines = [];
+  const stub = makeStubCaller({
+    mode_effective: 'hybrid',
+    bijas: [
+      { id: 'relevant', seed_type: 'failure_seed', origin: 'remote', content: 'get_db_dir cross-boundary failure in synapse connection', cosine: 0.75, tags: 'js' },
+    ],
+  });
+  appendAlayaLessons(lines, ALAYA_TASK, stub);
+  const out = lines.join('\n');
+  assert.ok(out.includes('## Process lessons (Alaya)'));
+  assert.ok(out.includes('get_db_dir cross-boundary failure in synapse connection'));
+});
+
+// ── dispatch-detail files exist (the moved-out explanatory prose) ─────
+
+test('every dispatch-detail file referenced by a compressed section exists', () => {
+  const files = [
+    'worktree-subagent-mode.md',
+    'cross-project-worktree.md',
+    'testing-module.md',
+  ];
+  for (const f of files) {
+    assert.ok(fs.existsSync(detailPath(f)), `missing dispatch-detail file: ${f}`);
+  }
+});
+
+// ── Ansuz.md / BOOT_FULL.md / VERIFY.md (S2 boot-lifecycle diet) ───────
+
+test('Ansuz.md is <= 4KB, the --full boot is archived (TASK_2372), VERIFY.md within budget', () => {
+  const ansuzPath = path.join(ROOT, '.claude', 'commands', 'Ansuz.md');
+  const bootFullPath = path.join(ROOT, '.specialist', 'Ansuz', 'BOOT_FULL.md');
+  const archivedBootFull = path.join(ROOT, 'dev', 'archive', 'ansuz', 'BOOT_FULL.md');
+  const verifyPath = path.join(ROOT, '.specialist', 'Ansuz', 'VERIFY.md');
+
+  const ansuz = fs.readFileSync(ansuzPath, 'utf-8');
+  assert.ok(bytes(ansuz) <= 4096, `Ansuz.md is ${bytes(ansuz)} bytes, expected <= 4096`);
+  assert.ok(!/Phase 0 sub-agent 委派/.test(ansuz), 'Ansuz.md should not carry the --full procedure body');
+  assert.ok(!/BOOT_MODE\s*=\s*`?full/.test(ansuz), 'Ansuz.md must not route a --full boot any more');
+
+  assert.ok(!fs.existsSync(bootFullPath), 'BOOT_FULL.md should be archived, not live');
+  assert.ok(fs.existsSync(archivedBootFull), 'archived BOOT_FULL.md missing');
+
+  assert.ok(fs.existsSync(verifyPath), 'VERIFY.md missing');
+  const verify = fs.readFileSync(verifyPath, 'utf-8');
+  assert.ok(bytes(verify) <= 2048, `VERIFY.md is ${bytes(verify)} bytes, expected <= 2048`);
+  assert.match(verify, /PARTIAL/);
+  assert.match(verify, /UNVERIFIED/);
+  assert.match(verify, /FIX/);
+});
+
+test('elixir.yaml no longer claims a 0-11 strict lifecycle', () => {
+  const elixirPath = path.join(ROOT, '.specialist', 'Ansuz', 'elixir.yaml');
+  const elixir = fs.readFileSync(elixirPath, 'utf-8');
+  assert.ok(!/0-11 strict lifecycle/.test(elixir), 'elixir.yaml still claims a 0-11 strict lifecycle');
+  assert.match(elixir, /VERIFY\.md/);
+  assert.match(elixir, /dev\/archive\/ansuz\/BOOT_FULL\.md/);
+});
+
+// ── TASK_1998: two-axis prompt policy (2026-09-22 user decision) ───────
+// CONTEXT volume (Cross-Project Context caps, Related Files Preview, Known
+// Failures, Project Memory) is driven by `complexity`. PROCESS strictness
+// (Working contract vs full ritual) is driven by `rigor`. The two axes are
+// independent — a rigor:low/complexity:complex card gets the full Cortex
+// Context but only the compact Working contract, and vice versa.
+
+test('promptProfile: complexity gates Related Files Preview / Known Failures / Project Memory', () => {
+  for (const rigor of ['low', 'medium', 'high']) {
+    const p = promptProfile({ rigor, complexity: 'simple' });
+    assert.equal(p.skipRelatedFilesPreview, true, `rigor=${rigor}`);
+    assert.equal(p.skipKnownFailures, true, `rigor=${rigor}`);
+    assert.equal(p.skipProjectMemory, true, `rigor=${rigor}`);
+  }
+  for (const complexity of ['medium', null, undefined, 'bogus']) {
+    const p = promptProfile({ rigor: 'medium', complexity });
+    assert.equal(p.skipRelatedFilesPreview, true, `complexity=${complexity}`);
+    assert.equal(p.skipKnownFailures, false, `complexity=${complexity}`);
+    assert.equal(p.skipProjectMemory, true, `complexity=${complexity}`);
+  }
+  const c = promptProfile({ rigor: 'medium', complexity: 'complex' });
+  assert.equal(c.skipRelatedFilesPreview, false);
+  assert.equal(c.skipKnownFailures, false);
+  assert.equal(c.skipProjectMemory, false);
+});
+
+test('TASK_2371: promptProfile has no Cortex fields for any complexity', () => {
+  for (const complexity of ['simple', 'medium', 'complex']) {
+    const p = promptProfile({ rigor: 'medium', complexity });
+    for (const k of Object.keys(p)) assert.ok(!/cortex|CrossProject/i.test(k), `unexpected profile key ${k}`);
+  }
+});
+
+test('promptProfile: rigor=high uses the same compact ritual as medium (TASK_2371)', () => {
+  for (const complexity of ['simple', 'medium', 'complex']) {
+    const p = promptProfile({ rigor: 'high', complexity });
+    assert.equal(p.rigor, 'high');
+    assert.equal(p.compactRitual, true, `complexity=${complexity}`);
+    assert.equal(p.ritualTier, 'medium', `complexity=${complexity}`);
+  }
+});
+
+test('promptProfile: rigor=low/medium (incl. missing/unrecognized, default) get the compact ritual, with distinct tiers', () => {
+  const low = promptProfile({ rigor: 'low', complexity: 'medium' });
+  assert.equal(low.compactRitual, true);
+  assert.equal(low.ritualTier, 'low');
+
+  for (const rigor of ['medium', null, undefined, 'bogus']) {
+    const p = promptProfile({ rigor, complexity: 'medium' });
+    assert.equal(p.compactRitual, true, `rigor=${rigor}`);
+    assert.equal(p.ritualTier, 'medium', `rigor=${rigor}`);
+  }
+});
+
+test('promptProfile: backwards-compatible string call maps rigor to the given string and complexity to medium', () => {
+  const viaString = promptProfile('high');
+  const viaObject = promptProfile({ rigor: 'high', complexity: 'medium' });
+  assert.deepEqual(viaString, viaObject);
+  assert.equal(viaString.rigor, 'high');
+  assert.equal(viaString.complexity, 'medium');
+
+  for (const v of [null, undefined]) {
+    const p = promptProfile(v);
+    assert.equal(p.rigor, 'medium');
+    assert.equal(p.complexity, 'medium');
+  }
+});
+
+test('extractRigor reads taskData.rigor; null when missing, unparseable, or non-string', () => {
+  assert.equal(extractRigor(JSON.stringify({ rigor: 'low' })), 'low');
+  assert.equal(extractRigor({ rigor: 'high' }), 'high');
+  assert.equal(extractRigor(JSON.stringify({})), null);
+  assert.equal(extractRigor(null), null);
+  assert.equal(extractRigor(undefined), null);
+  assert.equal(extractRigor('not json'), null);
+});
+
+test('extractComplexity reads taskData.complexity; defaults to "medium" when missing, unparseable, non-string, or unrecognized', () => {
+  assert.equal(extractComplexity(JSON.stringify({ complexity: 'simple' })), 'simple');
+  assert.equal(extractComplexity({ complexity: 'complex' }), 'complex');
+  assert.equal(extractComplexity(JSON.stringify({})), 'medium');
+  assert.equal(extractComplexity(null), 'medium');
+  assert.equal(extractComplexity(undefined), 'medium');
+  assert.equal(extractComplexity('not json'), 'medium');
+  assert.equal(extractComplexity(JSON.stringify({ complexity: 'bogus' })), 'medium');
+});
+
+test('splitPromptSections splits on "## "/"# " headers only, not "### " sub-headers', () => {
+  const text = [
+    'preamble text before any header (SUBAGENT_PREFIX-style, uncounted)',
+    '## Section A',
+    'line a1',
+    'line a2',
+    '### Sub-header (not a new top-level section)',
+    'line a3',
+    '# Section B',
+    'line b1',
+  ].join('\n');
+  const sections = splitPromptSections(text);
+  assert.equal(sections.length, 2);
+  assert.equal(sections[0].title, 'Section A');
+  assert.equal(sections[1].title, 'Section B');
+  assert.ok(sections[0].bytes > 0 && sections[1].bytes > 0);
+});
+
+// ── rigor tiers: Working contract / short progress note / full ritual ──
+
+test('rigor low: the six ritual sections collapse into "## Working contract"; Progress Note is dropped entirely', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', rigor: 'low' });
+
+  const ckLines = [];
+  appendCognitiveCheckpoint(ckLines, taskData, {});
+  const ck = ckLines.join('\n');
+  assert.ok(ck.includes('## Working contract'));
+  assert.ok(!ck.includes('synapse_inscribe'), 'memory system frozen 2026-10-10: no rune line');
+  assert.ok(!ck.includes('## Progress Note (brief)'), 'rigor:low should not get the short progress note');
+  const ritualNeedles = [
+    'Before You Start — Cognitive Recall',
+    `Before You Finish — Don't Let Your Discovery Die`,
+    '## Cognitive Checkpoint',
+  ];
+  for (const needle of ritualNeedles) {
+    assert.ok(!ck.includes(needle), `rigor:low output should not contain "${needle}"`);
+  }
+
+});
+
+test('rigor medium: "## Working contract" plus a short progress note, no rune-inscribe line (memory frozen)', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', rigor: 'medium' });
+
+  const ckLines = [];
+  appendCognitiveCheckpoint(ckLines, taskData, {});
+  const ck = ckLines.join('\n');
+  assert.ok(ck.includes('## Working contract'));
+  assert.ok(ck.includes('## Progress Note (brief)'), 'rigor:medium should get the short progress note');
+  assert.ok(!ck.includes('synapse_inscribe'), 'memory system frozen 2026-10-10: no rune line');
+  assert.ok(!ck.includes('## Progress Note (mandatory — write before finishing)'), 'rigor:medium should not get the full Progress Note');
+  assert.ok(ck.includes('parallel tool calls in ONE turn'), 'rigor:medium should get the concrete parallel-reads batching rule');
+  assert.ok(ck.includes('one bash command with separators'), 'rigor:medium should get the concrete shell-batching rule');
+  assert.ok(ck.includes('one command over all N'), 'rigor:medium should get the concrete N-similar-items batching rule');
+
+});
+
+test('rigor high: same brief ritual as medium, no mandatory Before You Start / Before You Finish / Cognitive Checkpoint (TASK_2371)', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', rigor: 'high' });
+  const ckLines = [];
+  appendCognitiveCheckpoint(ckLines, taskData, {});
+  const ck = ckLines.join('\n');
+  assert.ok(ck.includes('## Working contract'));
+  assert.ok(ck.includes('## Progress Note (brief)'));
+  assert.ok(!ck.includes('Cognitive Checkpoint'));
+  assert.ok(!ck.includes('Before You Start'));
+  assert.ok(!ck.includes('Before You Finish'));
+  assert.ok(!ck.includes('Progress Note (mandatory'));
+});
+
+test('a rigor:low subagent prompt (SUBAGENT_PREFIX + Working contract) keeps the worktree hard rules', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', rigor: 'low' });
+  const lines = [];
+  appendCognitiveCheckpoint(lines, taskData, {});
+  const full = SUBAGENT_PREFIX + lines.join('\n');
+  assert.ok(full.includes('禁 push'), 'worktree hard rule (no push) missing');
+  assert.ok(full.includes('刪 worktree'), 'worktree hard rule (no delete worktree) missing');
+  assert.ok(full.includes('## Working contract'));
+});
+
+// Functional check against the REAL .failure/.memory dirs (no mocking) —
+// confirms the section actually appears/disappears in an assembled prompt,
+// not just that the profile flag is set correctly.
+test('appendMemoryContext: complexity:medium prompt contains "## Known Failures", complexity:simple does not; neither carries "## Project Memory" except complexity:complex', () => {
+  const mediumTaskData = JSON.stringify({ id: 'TASK_TEST', complexity: 'medium' });
+  const mediumLines = [];
+  appendMemoryContext(mediumLines, mediumTaskData, {});
+  const mediumText = mediumLines.join('\n');
+  assert.ok(mediumText.includes('## Known Failures'), 'complexity:medium prompt should contain "## Known Failures"');
+  assert.ok(!mediumText.includes('## Project Memory'), 'complexity:medium prompt should NOT contain "## Project Memory"');
+
+  const simpleTaskData = JSON.stringify({ id: 'TASK_TEST', complexity: 'simple' });
+  const simpleLines = [];
+  appendMemoryContext(simpleLines, simpleTaskData, {});
+  const simpleText = simpleLines.join('\n');
+  assert.ok(!simpleText.includes('## Known Failures'), 'complexity:simple prompt should NOT contain "## Known Failures"');
+  assert.ok(!simpleText.includes('## Project Memory'), 'complexity:simple prompt should NOT contain "## Project Memory"');
+});
+
+// ── 3x3 matrix: simple/low, medium/medium, complex/high (task's minimum bar) ──
+
+test('two-axis matrix: simple/low has no Known Failures and has Working contract', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', complexity: 'simple', rigor: 'low' });
+  const memLines = [];
+  appendMemoryContext(memLines, taskData, {});
+  assert.ok(!memLines.join('\n').includes('## Known Failures'));
+  const ckLines = [];
+  appendCognitiveCheckpoint(ckLines, taskData, {});
+  assert.ok(ckLines.join('\n').includes('## Working contract'));
+});
+
+test('two-axis matrix: medium/medium has Known Failures and the short progress note', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', complexity: 'medium', rigor: 'medium' });
+
+  const memLines = [];
+  appendMemoryContext(memLines, taskData, {});
+  assert.ok(memLines.join('\n').includes('## Known Failures'));
+
+  const ckLines = [];
+  appendCognitiveCheckpoint(ckLines, taskData, {});
+  const ck = ckLines.join('\n');
+  assert.ok(ck.includes('## Progress Note (brief)'), 'medium/medium should carry the short progress note');
+});
+
+test('two-axis matrix: complex/high has Related Files Preview enabled and the brief ritual', () => {
+  const profile = promptProfile({ rigor: 'high', complexity: 'complex' });
+  assert.equal(profile.skipRelatedFilesPreview, false);
+  const ckLines = [];
+  appendCognitiveCheckpoint(ckLines, JSON.stringify({ id: 'TASK_TEST', complexity: 'complex', rigor: 'high' }), {});
+  const ck = ckLines.join('\n');
+  assert.ok(ck.includes('## Progress Note (brief)'));
+  assert.ok(!ck.includes('Cognitive Checkpoint'));
+});
+
+// ── TASK_2371: prompt diet ──
+
+test('TASK_2371: no Cortex / Episodic section can be produced (functions removed, builder output clean)', () => {
+  const prompt = require('./prompt.js');
+  assert.equal(prompt.appendCortexContext, undefined);
+  assert.equal(prompt.appendEpisodicContext, undefined);
+  const src = fs.readFileSync(path.join(__dirname, 'prompt.js'), 'utf-8');
+  assert.ok(!src.includes('## Cross-Project Context'));
+  assert.ok(!src.includes('## Episodic Memory'));
+});
+
+test('TASK_2371: Known Failures drop Heimdall REVERT / removed-system entries and cap at 3', () => {
+  const lines = [];
+  appendMemoryContext(lines, JSON.stringify({ id: 'TASK_TEST', complexity: 'complex' }), {});
+  const text = lines.join('\n');
+  assert.ok(!/Heimdall|\bREVERT\b|Kuzu|\bNorn\b|thalamus|\breflex\b|Formation squad/.test(text.split('## Project Memory')[0].split('## Known Failures')[1] || ''));
+  const fail = (text.split('## Known Failures')[1] || '').split(/\n## /)[0];
+  assert.ok((fail.match(/^- /gm) || []).length <= 3);
+});
+
+test('TASK_2371: loadFailures filter excludes Heimdall/REVERT entries', () => {
+  const { loadFailures } = require('./memory-loader.js');
+  const all = loadFailures({ tags: [] });
+  for (const e of all) assert.ok(!/TASK_1413|TASK_1427|TASK_904/.test(e.id), e.id);
+});
+
+test('TASK_2371: Shared Modules inject only on explicit opt-in tags', () => {
+  const noTag = resolveModules({ tags: ['auth', 'security', 'test', 'review'], scope_paths: ['src/auth/login.ts'] }, null, ROOT);
+  assert.deepEqual(noTag, []);
+  const optIn = resolveModules({ tags: ['security-review'] }, null, ROOT).map((p) => path.basename(p));
+  assert.deepEqual(optIn, ['security.yaml']);
+});
+
+// ── TASK_2082: Rust check reminder for worktree subagents ──────────────
+
+test('hasRustScope: true for a .rs file, true for a dashboard/src-tauri/ path, false otherwise', () => {
+  assert.equal(hasRustScope(JSON.stringify({ scope_paths: ['dashboard/src-tauri/src/x.rs'] })), true);
+  assert.equal(hasRustScope(JSON.stringify({ scope_paths: ['dashboard\\src-tauri\\src\\x.rs'] })), true);
+  assert.equal(
+    hasRustScope(JSON.stringify({ scope_paths: ['dashboard/src-tauri/resources/onnx/model.onnx'] })),
+    true
+  );
+  assert.equal(hasRustScope(JSON.stringify({ scope_paths: ['dev/scripts/rust-verify-worktree.js'] })), false);
+  assert.equal(hasRustScope(JSON.stringify({ scope_paths: [] })), false);
+  assert.equal(hasRustScope(null), false);
+  assert.equal(hasRustScope('not json'), false);
+});
+
+test('appendRustCheckReminder: renders only when isolated + Rust-scoped + core has the crate', () => {
+  const rustTaskData = JSON.stringify({ scope_paths: ['dashboard/src-tauri/src/x.rs'] });
+  const jsTaskData = JSON.stringify({ scope_paths: ['dev/scripts/foo.js'] });
+  const coreHasCrate = () => true;
+  const coreMissingCrate = () => false;
+
+  const isolatedRust = [];
+  appendRustCheckReminder(isolatedRust, rustTaskData, { corePath: '/core', rustCoreCheck: coreHasCrate }, true);
+  assert.ok(isolatedRust.join('\n').includes('## Rust check (once, after commit)'));
+
+  const notIsolated = [];
+  appendRustCheckReminder(notIsolated, rustTaskData, { corePath: '/core', rustCoreCheck: coreHasCrate }, false);
+  assert.deepEqual(notIsolated, [], 'shared-tree (non-isolated) mode must not get the section');
+
+  const jsCard = [];
+  appendRustCheckReminder(jsCard, jsTaskData, { corePath: '/core', rustCoreCheck: coreHasCrate }, true);
+  assert.deepEqual(jsCard, [], 'a JS-only card must not get the section');
+
+  const noCrateOnThisMachine = [];
+  appendRustCheckReminder(
+    noCrateOnThisMachine,
+    rustTaskData,
+    { corePath: '/core', rustCoreCheck: coreMissingCrate },
+    true
+  );
+  assert.deepEqual(
+    noCrateOnThisMachine,
+    [],
+    'a packaged machine without dashboard/src-tauri must not get the section even for a Rust-scoped card'
+  );
+});
+
+test('appendRustCheckReminder: resolved core path is interpolated, no hard-coded absolute path in the template', () => {
+  const rustTaskData = JSON.stringify({ scope_paths: ['dashboard/src-tauri/src/x.rs'] });
+  const lines = [];
+  appendRustCheckReminder(lines, rustTaskData, { corePath: '/resolved/core', rustCoreCheck: () => true }, true);
+  const text = lines.join('\n');
+  assert.ok(
+    text.includes('node /resolved/core/dev/scripts/rust-verify-worktree.js run <your branch> <test filter>'),
+    'must interpolate the resolved core path into the command template'
+  );
+  // No literal drive-letter/Windows absolute path baked into the source template itself.
+  assert.ok(!text.includes('C:\\'), 'template must not carry a hard-coded absolute path');
+});
+
+// Minimal do.yaml-shaped skillDef (real card structure per .formation/unit/do.yaml)
+// — enough to exercise appendWorkflow's commit-step branch without paying
+// for buildUnitPrompt's other live-project-dependent appends.
+const DO_LIKE_SKILL = {
+  collaboration: {
+    workflow: [
+      {
+        step: '提交變更',
+        run: 'git add -A && (git commit --no-verify -m "[{task_id}] task completed" || true)',
+        note: 'worktree 內顯式提交確保 post-complete 只需 merge 不需 recovery commit。',
+      },
+    ],
+  },
+};
+
+test('appendWorkflow: a worktree-subagent card with Rust scope gets the Rust check section after the commit step', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', scope_paths: ['dashboard/src-tauri/src/x.rs'] });
+  const lines = [];
+  appendWorkflow(lines, DO_LIKE_SKILL, { isSubagent: true, corePath: '/core', rustCoreCheck: () => true }, taskData);
+  const text = lines.join('\n');
+  assert.ok(text.includes('## Rust check (once, after commit)'));
+  assert.ok(text.includes('node /core/dev/scripts/rust-verify-worktree.js run <your branch> <test filter>'));
+  // Fixed by Ansuz review of eb7c3be5d: the section no longer tries to talk
+  // over hard rule 4 with a "this overrides rule 4" note — that wording
+  // fix now happens at the prefix+body composition point in dispatch.js
+  // (applyRustCheckToPrefix), covered separately below.
+  assert.ok(!text.includes('overrides'), 'section must not claim to override rule 4 by itself anymore');
+});
+
+test('appendWorkflow: a JS-only worktree-subagent card renders no Rust check section (byte-identical to before)', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', scope_paths: ['dev/scripts/foo.js'] });
+  const lines = [];
+  appendWorkflow(lines, DO_LIKE_SKILL, { isSubagent: true, corePath: '/core' }, taskData);
+  const text = lines.join('\n');
+  assert.ok(!text.includes('## Rust check'), 'JS-only card must not gain the new section');
+  // The commit-step block is unchanged: isolated staging note is still the last content.
+  assert.ok(
+    text.trimEnd().endsWith(
+      'Note: nothing to commit 時靜默跳過（不算失敗）；git commit 失敗（如 index.lock 競爭）會自動退避重試兩次，仍失敗則以非零退出 — 此時大聲回報錯誤，不要吞掉。'
+    )
+  );
+});
+
+test('appendWorkflow: a shared-tree (non-subagent) Rust-scoped card renders no Rust check section', () => {
+  const taskData = JSON.stringify({ id: 'TASK_TEST', scope_paths: ['dashboard/src-tauri/src/x.rs'] });
+  const lines = [];
+  appendWorkflow(lines, DO_LIKE_SKILL, { corePath: '/core' }, taskData);
+  const text = lines.join('\n');
+  assert.ok(!text.includes('## Rust check'), 'shared-tree mode has no isolated worktree to verify against');
+});
+
+// ── TASK_2082 defect fix (Ansuz review of eb7c3be5d): fix the contradictory
+// "Rust 交 Ansuz" hard rule 4 wording at the prefix+body COMPOSITION point
+// (dispatch.js) instead of relying on a later "overrides rule 4" note in
+// the body, which agents were observed obeying LESS than the earlier hard
+// rule. applyRustCheckToPrefix is the exported, dispatch.js-callable helper.
+
+test('applyRustCheckToPrefix: a Rust-card body rewrites hard rule 4 wording out of the real SUBAGENT_PREFIX', () => {
+  // Sanity: the real prefix constant does carry the literal phrase this
+  // fix depends on — if it ever changes, this test fails loudly instead of
+  // silently no-op'ing.
+  assert.ok(SUBAGENT_PREFIX.includes('Rust 交 Ansuz'));
+
+  const rustBody = '## Workflow\n...\n## Rust check (once, after commit)\nAfter committing, run exactly one narrow filter...\n';
+  const patched = applyRustCheckToPrefix(SUBAGENT_PREFIX, rustBody);
+  assert.ok(!patched.includes('Rust 交 Ansuz'), 'hard rule 4 wording must be gone from the composed prefix');
+  assert.ok(patched.includes('Rust 只准跑一次'), 'replacement wording must allow the single command');
+});
+
+test('applyRustCheckToPrefix: a JS-only body (no Rust check marker) leaves the prefix byte-identical', () => {
+  const jsBody = '## Workflow\n### 提交變更\nCommand: git add -A ...\n';
+  const patched = applyRustCheckToPrefix(SUBAGENT_PREFIX, jsBody);
+  assert.equal(patched, SUBAGENT_PREFIX);
+});
+
+test('applyRustCheckToPrefix: also patches the cross-project worktree prefix variant', () => {
+  const prefix = buildSubagentWorktreePrefix('WT', 'BR', 'PP');
+  assert.ok(prefix.includes('Rust 交 Ansuz'));
+  const rustBody = '## Rust check (once, after commit)\n...\n';
+  const patched = applyRustCheckToPrefix(prefix, rustBody);
+  assert.ok(!patched.includes('Rust 交 Ansuz'));
+  assert.ok(patched.includes('Rust 只准跑一次'));
+});
+
+// ── Role Expertise removal (TASK_2086) ──────────────────────────────────
+// appendRoleSkill/loadRoleSkill/ROLE_SKILL_MAP were removed: the extraction
+// regex was broken since it shipped (0a09fb2a5) and only ever injected a
+// one-line, wrong-stack (Python/FastAPI) role description + dangling
+// sub-heading. buildUnitPrompt (formation: unit) and buildLegacyPrompt
+// (formation: legacy) were the only two call sites.
+
+const MINIMAL_SKILL_DEF = { role: { identity: 'You are a developer.', priority: 'ship it' }, behavior: [] };
+
+function minimalTaskData(role) {
+  return JSON.stringify({ id: 'TASK_9999', title: 'Test task', role, scope_paths: [] });
+}
+
+test('buildPrompt (unit formation): role=backend produces no "## Role Expertise" section', () => {
+  const out = buildPrompt({ ...MINIMAL_SKILL_DEF, formation: 'unit' }, 'do it', minimalTaskData('backend'), {});
+  assert.ok(!out.includes('## Role Expertise'), 'Role Expertise section should be removed');
+  assert.ok(!out.includes('Python/FastAPI') && !out.includes('FastAPI'), 'wrong-stack Python/FastAPI text should not be injected');
+});
+
+test('buildPrompt (unit formation): role=frontend produces no "## Role Expertise" section', () => {
+  const out = buildPrompt({ ...MINIMAL_SKILL_DEF, formation: 'unit' }, 'do it', minimalTaskData('frontend'), {});
+  assert.ok(!out.includes('## Role Expertise'), 'Role Expertise section should be removed');
+});
+
+test('buildPrompt (legacy formation): role=backend produces no "## Role Expertise" section', () => {
+  const out = buildPrompt({ ...MINIMAL_SKILL_DEF, formation: 'legacy' }, 'do it', minimalTaskData('backend'), {});
+  assert.ok(!out.includes('## Role Expertise'), 'Role Expertise section should be removed');
+});
+
+// TASK_2252 — appendWorkflow rigor gate must accept taskData as JSON string OR object
+// (bare JSON.parse(object) threw, was swallowed, and the rigor:high gate failed open).
+const RIGOR_SKILL = { collaboration: { workflow: [{ step: 'Finish', run: 'node .collaboration/core/task-api.js complete {task_id}' }] } };
+test('TASK_2252 appendWorkflow rigor gate: string/object/invalid taskData', () => {
+  const cases = [
+    ['string rigor:high', JSON.stringify({ id: 'T', rigor: 'high' }), true],
+    ['object rigor:high', { id: 'T', rigor: 'high' }, true],
+    ['string rigor:medium (control)', JSON.stringify({ id: 'T', rigor: 'medium' }), false],
+    ['object rigor:medium (control)', { id: 'T', rigor: 'medium' }, false],
+    ['raw YAML (unparseable)', 'id: T\nrigor: high\n', false],
+    ['null', null, false],
+  ];
+  for (const [name, td, gated] of cases) {
+    const lines = [];
+    appendWorkflow(lines, RIGOR_SKILL, { taskId: 'TASK_X' }, td);
+    const out = lines.join('\n');
+    assert.equal(out.includes('rigor: high — 禁止執行 task-api.js complete'), gated, name);
+    if (!gated) assert.ok(out.includes('Command: node .collaboration/core/task-api.js complete TASK_X'), `${name}: complete step kept`);
+  }
+});
+test('TASK_2252 appendWorkflow dispatch_overrides honoured for object taskData too', () => {
+  const lines = [];
+  appendWorkflow(lines, { collaboration: { workflow: [] } }, {}, { id: 'T', dispatch_overrides: 'DO NOT COMMIT' });
+  assert.ok(lines.join('\n').includes('DO NOT COMMIT'));
+});
+
+test('memory frozen (2026-10-10): a caller without __forceAlaya renders no Alaya section and makes no MCP call', () => {
+  const lines = [];
+  let called = false;
+  appendAlayaLessons(lines, ALAYA_TASK, () => { called = true; return { bijas: [{ id: 'x', content: 'y', cosine: 0.99 }] }; });
+  assert.equal(called, false);
+  assert.equal(lines.join('\n').includes('Process lessons (Alaya)'), false);
+});