kenaz 0.0.0-stage → 0.3.2

package/core/.claude/hooks/memory-guard.test.js

@@ -0,0 +1,574 @@
+'use strict';
+// TASK_2023: memory-guard fires a memory right before the tool call its
+// frontmatter trigger matches. Covers: frontmatter parsing, the negative
+// clause, invalid-regex resilience, Bash heredoc-body stripping, per-session
+// dedupe, and the merge into synapse-first-investigation.js's own output.
+const test = require('node:test');
+const assert = require('node:assert');
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const HOOK = path.join(__dirname, 'memory-guard.js');
+const SYNAPSE_FIRST_HOOK = path.join(__dirname, 'synapse-first-investigation.js');
+const guard = require('./memory-guard');
+
+function tmpDir(prefix) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function writeMemory(dir, name, frontmatter, body) {
+  fs.mkdirSync(dir, { recursive: true });
+  const fm = Object.entries(frontmatter)
+    .map(([k, v]) => (Array.isArray(v) ? `${k}:\n${v.map((x) => `  - ${x}`).join('\n')}` : `${k}: ${v}`))
+    .join('\n');
+  fs.writeFileSync(path.join(dir, name), `---\n${fm}\n---\n\n${body || 'body text'}\n`, 'utf8');
+}
+
+// ---- Frontmatter parsing ----
+
+test('loadTriggers parses triggers and compiles regexes', () => {
+  const dir = tmpDir('mg-parse-');
+  const cache = path.join(dir, 'cache.json');
+  writeMemory(dir, 'a.md', {
+    name: 'a',
+    description: 'do the thing carefully',
+    triggers: [String.raw`^Bash$ | git\s+push\s+--force`],
+  });
+  // A file with no triggers key must be ignored entirely.
+  writeMemory(dir, 'b.md', { name: 'b', description: 'no triggers here' });
+
+  const triggers = guard.loadTriggers([dir], cache);
+  assert.strictEqual(triggers.length, 1);
+  assert.strictEqual(triggers[0].file, 'a.md');
+  assert.strictEqual(triggers[0].description, 'do the thing carefully');
+  assert.ok(triggers[0].toolRegex.test('Bash'));
+  assert.ok(triggers[0].inputRegex.test('git push --force origin main'));
+  assert.strictEqual(triggers[0].negRegex, null);
+});
+
+test('loadTriggers also reads triggers nested under metadata (harness-rewritten frontmatter)', () => {
+  const dir = tmpDir('mg-meta-');
+  const cache = path.join(dir, 'cache.json');
+  fs.writeFileSync(
+    path.join(dir, 'nested.md'),
+    "---\nname: nested\ndescription: nested trigger\nmetadata:\n  type: feedback\n  triggers:\n    - 'Bash | task-api\\.js create'\n---\n\nbody\n",
+    'utf8',
+  );
+  const triggers = guard.loadTriggers([dir], cache);
+  assert.strictEqual(triggers.length, 1);
+  assert.strictEqual(triggers[0].file, 'nested.md');
+  assert.ok(triggers[0].inputRegex.test('node task-api.js create --title x'));
+});
+
+test('loadTriggers caches by mtime+size and skips re-parsing unchanged files', () => {
+  const dir = tmpDir('mg-cache-');
+  const cache = path.join(dir, 'cache.json');
+  writeMemory(dir, 'a.md', { name: 'a', description: 'x', triggers: [String.raw`^Bash$ | foo`] });
+
+  guard.loadTriggers([dir], cache);
+  const cached = JSON.parse(fs.readFileSync(cache, 'utf8'));
+  const absPath = path.join(dir, 'a.md');
+  assert.ok(cached.files[absPath]);
+  const firstMtime = cached.files[absPath].mtimeMs;
+
+  // Re-load without touching the file: cache entry must be reused (same mtime/size).
+  const triggers2 = guard.loadTriggers([dir], cache);
+  assert.strictEqual(triggers2.length, 1);
+  const cached2 = JSON.parse(fs.readFileSync(cache, 'utf8'));
+  assert.strictEqual(cached2.files[absPath].mtimeMs, firstMtime);
+});
+
+test('a source dir that does not exist is skipped without throwing', () => {
+  const dir = tmpDir('mg-missing-');
+  const missing = path.join(dir, 'does-not-exist');
+  const cache = path.join(dir, 'cache.json');
+  assert.doesNotThrow(() => guard.loadTriggers([missing], cache));
+});
+
+// ---- Negative clause ----
+
+test('negative clause suppresses the fire when it also matches', () => {
+  const dir = tmpDir('mg-neg-');
+  const cache = path.join(dir, 'cache.json');
+  writeMemory(dir, 'a.md', {
+    name: 'a',
+    description: 'needs projectPath',
+    triggers: [String.raw`^mcp__kenaz-dashboard__synapse_inscribe$ | . | !projectPath`],
+  });
+  const triggers = guard.loadTriggers([dir], cache);
+
+  const withoutField = guard.match(
+    'mcp__kenaz-dashboard__synapse_inscribe',
+    { content: 'x' },
+    { triggers, dedupe: false },
+  );
+  assert.strictEqual(withoutField.length, 1);
+
+  const withField = guard.match(
+    'mcp__kenaz-dashboard__synapse_inscribe',
+    { content: 'x', projectPath: '/repo' },
+    { triggers, dedupe: false },
+  );
+  assert.strictEqual(withField.length, 0);
+});
+
+// ---- Invalid regex / malformed frontmatter never crash ----
+
+test('an invalid regex in one trigger is skipped, not fatal', () => {
+  const dir = tmpDir('mg-badregex-');
+  const cache = path.join(dir, 'cache.json');
+  writeMemory(dir, 'bad.md', {
+    name: 'bad',
+    description: 'broken',
+    triggers: [String.raw`^Bash$ | git\s+push(`], // unbalanced paren
+  });
+  writeMemory(dir, 'good.md', {
+    name: 'good',
+    description: 'fine',
+    triggers: [String.raw`^Bash$ | git\s+push`],
+  });
+
+  let triggers;
+  assert.doesNotThrow(() => {
+    triggers = guard.loadTriggers([dir], cache);
+  });
+  assert.strictEqual(triggers.length, 1);
+  assert.strictEqual(triggers[0].file, 'good.md');
+});
+
+test('malformed frontmatter YAML never crashes loadTriggers', () => {
+  const dir = tmpDir('mg-badyaml-');
+  const cache = path.join(dir, 'cache.json');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'broken.md'), '---\ntriggers: [unterminated\n---\nbody\n', 'utf8');
+  let triggers;
+  assert.doesNotThrow(() => {
+    triggers = guard.loadTriggers([dir], cache);
+  });
+  assert.strictEqual(triggers.length, 0);
+});
+
+test('a malformed trigger string (wrong field count) is skipped', () => {
+  const dir = tmpDir('mg-badfields-');
+  const cache = path.join(dir, 'cache.json');
+  writeMemory(dir, 'a.md', {
+    name: 'a',
+    description: 'x',
+    triggers: [String.raw`^Bash$`, String.raw`^Bash$ | a | !b | c`],
+  });
+  const triggers = guard.loadTriggers([dir], cache);
+  assert.strictEqual(triggers.length, 0);
+});
+
+// ---- Heredoc-body stripping ----
+
+test('stripHeredocBodies removes a single-quoted heredoc body', () => {
+  const cmd = "git commit -F - <<'EOF'\nmentions taskkill and build:kenaz\nEOF";
+  const stripped = guard.stripHeredocBodies(cmd);
+  assert.ok(!stripped.includes('taskkill'));
+  assert.ok(!stripped.includes('build:kenaz'));
+  assert.ok(stripped.includes('git commit -F -'));
+});
+
+test('stripHeredocBodies handles multiple heredocs in one command', () => {
+  const cmd = "cat <<A\nfirst taskkill\nA\necho mid\ncat <<B\nsecond taskkill\nB";
+  const stripped = guard.stripHeredocBodies(cmd);
+  assert.ok(!stripped.includes('first taskkill'));
+  assert.ok(!stripped.includes('second taskkill'));
+  assert.ok(stripped.includes('echo mid'));
+});
+
+test('stripHeredocBodies handles indented <<- terminators', () => {
+  const cmd = "cat <<-EOF\n\ttaskkill inside\n\tEOF";
+  const stripped = guard.stripHeredocBodies(cmd);
+  assert.ok(!stripped.includes('taskkill inside'));
+});
+
+test('stripHeredocBodies leaves node -e program strings untouched', () => {
+  const cmd = String.raw`node -e "console.log('C:\Users\me\file.json')"`;
+  assert.strictEqual(guard.stripHeredocBodies(cmd), cmd);
+});
+
+test('heredoc stripping prevents a false fire while the underlying pattern still fires unstripped', () => {
+  const dir = tmpDir('mg-heredoc-fire-');
+  const cache = path.join(dir, 'cache.json');
+  writeMemory(dir, 'a.md', {
+    name: 'a',
+    description: 'no blanket kills',
+    triggers: [String.raw`^Bash$ | taskkill[^\n]*\s/IM\s`],
+  });
+  const triggers = guard.loadTriggers([dir], cache);
+
+  const real = guard.match('Bash', { command: 'taskkill /F /IM node.exe /T' }, { triggers, dedupe: false });
+  assert.strictEqual(real.length, 1);
+
+  const heredocText = "git commit -F - <<'EOF'\nran taskkill /F /IM node.exe /T earlier\nEOF";
+  const stripped = guard.stripHeredocBodies(heredocText);
+  const fromHeredoc = guard.match('Bash', { command: stripped }, { triggers, dedupe: false });
+  assert.strictEqual(fromHeredoc.length, 0, 'heredoc-body mention of the pattern must not fire');
+});
+
+// ---- Per-session dedupe ----
+
+test('a memory fires once per session, and dedupe:false bypasses that', () => {
+  const dir = tmpDir('mg-dedupe-');
+  const cache = path.join(dir, 'cache.json');
+  const statePath = path.join(dir, 'state.json');
+  // TASK_2024: match() now usage-logs whenever a sessionId is present. Pin
+  // it to a tmp-dir path so this test's real sessionIds never write into
+  // this worktree's own .kenaz/specialist/memory_usage.jsonl.
+  const usageLogPath = path.join(dir, 'usage.jsonl');
+  writeMemory(dir, 'a.md', { name: 'a', description: 'x', triggers: [String.raw`^Bash$ | cargo\s+test`] });
+  const triggers = guard.loadTriggers([dir], cache);
+
+  const session = 'sess-' + Date.now();
+  const first = guard.match('Bash', { command: 'cargo test' }, { triggers, sessionId: session, statePath, usageLogPath });
+  assert.strictEqual(first.length, 1);
+
+  const second = guard.match('Bash', { command: 'cargo test' }, { triggers, sessionId: session, statePath, usageLogPath });
+  assert.strictEqual(second.length, 0, 'same memory must not fire twice in the same session');
+
+  const otherSession = guard.match('Bash', { command: 'cargo test' }, {
+    triggers, sessionId: 'sess-other-' + Date.now(), statePath, usageLogPath,
+  });
+  assert.strictEqual(otherSession.length, 1, 'a different session gets its own fire');
+
+  const noDedupe = guard.match('Bash', { command: 'cargo test' }, {
+    triggers, sessionId: session, statePath, dedupe: false, usageLogPath,
+  });
+  assert.strictEqual(noDedupe.length, 1, 'dedupe:false ignores prior fires (eval replay mode)');
+});
+
+test('up to 3 matches are returned, ranked by trigger order', () => {
+  const dir = tmpDir('mg-cap-');
+  const cache = path.join(dir, 'cache.json');
+  for (let i = 1; i <= 4; i++) {
+    writeMemory(dir, `m${i}.md`, { name: `m${i}`, description: `m${i}`, triggers: [String.raw`^Bash$ | echo`] });
+  }
+  const triggers = guard.loadTriggers([dir], cache);
+  const results = guard.match('Bash', { command: 'echo hi' }, { triggers, dedupe: false });
+  assert.strictEqual(results.length, 3);
+});
+
+// ---- Standalone hook (MCP path): require() must never auto-run main() ----
+
+test('requiring memory-guard.js never auto-runs main() (no stdout emitted on require)', () => {
+  // require.main is undefined under `node -e`, so a require.main guard would
+  // be unreliable here (feedback_hook_require_main_guard); main() must only
+  // run when a caller explicitly invokes it.
+  const r = spawnSync(process.execPath, ['-e', `require(${JSON.stringify(HOOK)});`], {
+    input: '{}',
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  assert.strictEqual(r.stdout, '');
+});
+
+test('calling .main() explicitly (the MCP settings.json wiring) reads stdin and prints guard lines', () => {
+  const fixture = fixtureProject();
+  const script = `const d=${JSON.stringify(fixture.projectDir)};process.chdir(d);` +
+    `require(${JSON.stringify(HOOK)}).main()`;
+  const r = spawnSync(process.execPath, ['-e', script], {
+    input: JSON.stringify({
+      session_id: 'main-explicit-' + Date.now(),
+      tool_name: 'mcp__kenaz-dashboard__synapse_inscribe',
+      tool_input: { content: 'x' },
+    }),
+    encoding: 'utf8',
+    env: { ...process.env, CLAUDE_PROJECT_DIR: fixture.projectDir, HOME: fixture.home, USERPROFILE: fixture.home },
+    timeout: 10000,
+  });
+  assert.strictEqual(r.status, 0, r.stderr);
+  const parsed = JSON.parse(r.stdout);
+  assert.strictEqual(parsed.hookSpecificOutput.hookEventName, 'PreToolUse');
+});
+
+// ---- Merge into synapse-first-investigation.js output ----
+
+function fixtureProject() {
+  const home = tmpDir('mg-home-');
+  const projectDir = tmpDir('mg-proj-');
+  fs.mkdirSync(path.join(projectDir, '.kenaz', 'specialist'), { recursive: true });
+  fs.writeFileSync(path.join(projectDir, '.kenaz', 'project.yaml'), 'name: mg-fixture\n');
+
+  const encoded = require('./memory-guard').encodeProjectDirName(path.resolve(projectDir));
+  const memDir = path.join(home, '.claude', 'projects', encoded, 'memory');
+  fs.mkdirSync(memDir, { recursive: true });
+  writeMemory(memDir, 'no-blanket-kill.md', {
+    name: 'no-blanket-kill',
+    description: 'never kill by image name',
+    triggers: [String.raw`^Bash$ | taskkill[^\n]*\s/IM\s`],
+  });
+  return { home, projectDir };
+}
+
+function runSynapseFirst(payload, { home, projectDir }) {
+  const r = spawnSync(process.execPath, [SYNAPSE_FIRST_HOOK], {
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir, HOME: home, USERPROFILE: home },
+    timeout: 10000,
+  });
+  let ctx = '';
+  try { ctx = JSON.parse(r.stdout).hookSpecificOutput.additionalContext || ''; } catch {}
+  return { status: r.status, out: ctx, err: r.stderr };
+}
+
+test('memory-guard line is merged into the emitOk (no-nudge) path', () => {
+  const fixture = fixtureProject();
+  const payload = {
+    session_id: 'merge-ok-' + Date.now(),
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Bash',
+    tool_input: { command: 'taskkill /F /IM node.exe /T' },
+  };
+  const r = runSynapseFirst(payload, fixture);
+  assert.strictEqual(r.status, 0, r.err);
+  assert.ok(r.out.includes('memory guard'), 'guard line missing from ok path: ' + r.out);
+  assert.ok(r.out.includes('never kill by image name'));
+});
+
+test('memory-guard line is merged alongside an existing LSP nudge, keeping both', () => {
+  const fixture = fixtureProject();
+  const payload = {
+    session_id: 'merge-nudge-' + Date.now(),
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Bash',
+    tool_input: { command: 'grep -rn "bridge_symbols_to_heat" dashboard/src-tauri/src/ && taskkill /F /IM node.exe /T' },
+  };
+  const r = runSynapseFirst(payload, fixture);
+  assert.strictEqual(r.status, 0, r.err);
+  assert.ok(r.out.includes('LSP nudge'), 'existing nudge must survive the merge: ' + r.out);
+  assert.ok(r.out.includes('memory guard'), 'guard line missing from nudge path: ' + r.out);
+});
+
+test('memory-guard fires once per session inside synapse-first-investigation.js too', () => {
+  const fixture = fixtureProject();
+  const session = 'merge-dedupe-' + Date.now();
+  const cmd = { command: 'taskkill /F /IM node.exe /T' };
+  const first = runSynapseFirst({ session_id: session, tool_name: 'Bash', tool_input: cmd }, fixture);
+  assert.ok(first.out.includes('memory guard'));
+  const second = runSynapseFirst({ session_id: session, tool_name: 'Bash', tool_input: cmd }, fixture);
+  assert.ok(!second.out.includes('memory guard'), 'second fire in same session must be silent: ' + second.out);
+});
+
+// ---- Knowledge-tier area digests (TASK_2024) ----
+//
+// KNOWLEDGE.md's own real headers use JSON.stringify'd trigger arrays with
+// `[\\/]`-style path-separator classes; these tests build small, hermetic
+// KNOWLEDGE.md fixtures instead (via JSON.stringify, never hand-escaped
+// strings) so parsing/matching is verified without depending on the real
+// user memory dir's content.
+
+test('parseAreaTriggerHeaders parses an area-triggers header, ignores a header without one, and skips an invalid regex without dropping the section', () => {
+  const dir = tmpDir('mg-area-parse-');
+  const md = path.join(dir, 'KNOWLEDGE.md');
+  const content = [
+    '# Knowledge index',
+    '',
+    `## Has triggers <!-- area-triggers: ${JSON.stringify(['^Bash$ | git\\s+push', '^Bash$ | ('])} -->`,
+    '- [A](a.md) — a',
+    '- [B](b.md) — b',
+    '',
+    '## No triggers here',
+    '- [C](c.md) — c',
+    '',
+  ].join('\n');
+  fs.writeFileSync(md, content, 'utf8');
+
+  const sections = guard.parseAreaTriggerHeaders(md);
+  assert.strictEqual(sections.length, 1, 'a header without an area-triggers comment must produce no section');
+  assert.strictEqual(sections[0].title, 'Has triggers');
+  assert.strictEqual(sections[0].triggers.length, 1, 'the invalid regex trigger must be skipped, not fatal');
+  assert.strictEqual(sections[0].entries.length, 2);
+  assert.deepStrictEqual(sections[0].entries.map((e) => e.file), ['a.md', 'b.md']);
+});
+
+test('a KNOWLEDGE.md with no area-triggers headers at all yields no sections, without throwing', () => {
+  const dir = tmpDir('mg-area-none-');
+  const md = path.join(dir, 'KNOWLEDGE.md');
+  fs.writeFileSync(md, '# Knowledge index\n\n## Plain section\n- [A](a.md) — a\n', 'utf8');
+  assert.doesNotThrow(() => {
+    const sections = guard.parseAreaTriggerHeaders(md);
+    assert.strictEqual(sections.length, 0);
+  });
+});
+
+/** A KNOWLEDGE.md with one area-triggers section ("Synapse area") + two referenced memory files with distinct mtimes. */
+function areaFixture() {
+  const dir = tmpDir('mg-area-');
+  fs.writeFileSync(path.join(dir, 'old_synapse_note.md'), 'old\n', 'utf8');
+  fs.writeFileSync(path.join(dir, 'new_synapse_note.md'), 'new\n', 'utf8');
+  const past = new Date(Date.now() - 60_000);
+  fs.utimesSync(path.join(dir, 'old_synapse_note.md'), past, past);
+
+  const kmd = path.join(dir, 'KNOWLEDGE.md');
+  const content = [
+    '# Knowledge index',
+    '',
+    `## Synapse area <!-- area-triggers: ${JSON.stringify(['^(Read|Edit|Write)$ | features.(synapse|cortex).'])} -->`,
+    '- [Old synapse note](old_synapse_note.md) — old',
+    '- [New synapse note](new_synapse_note.md) — new',
+    '',
+  ].join('\n');
+  fs.writeFileSync(kmd, content, 'utf8');
+
+  return {
+    dir,
+    kmd,
+    sections: guard.parseAreaTriggerHeaders(kmd),
+    statePath: path.join(dir, 'state.json'),
+    // TASK_2024: matchAreas() usage-logs whenever a sessionId is present.
+    // Pin it to this fixture's own tmp dir so tests never write into this
+    // worktree's real .kenaz/specialist/memory_usage.jsonl.
+    usageLogPath: path.join(dir, 'usage.jsonl'),
+  };
+}
+
+test('matchAreas: first Read of a matching path returns the digest once per session, most-used first, else KNOWLEDGE.md order', () => {
+  const fx = areaFixture();
+  const sessionId = 'area-sess-' + Date.now();
+
+  // No usage yet: curated KNOWLEDGE.md order, NOT mtime (new_synapse_note is newer but listed second).
+  const first = guard.matchAreas('Read', { file_path: 'dashboard/src-tauri/src/features/synapse/memory.rs' }, {
+    sections: fx.sections, statePath: fx.statePath, usageLogPath: fx.usageLogPath, sessionId,
+  });
+  assert.strictEqual(first.length, 1);
+  assert.ok(first[0].lines[0].startsWith(`📚 knowledge area: Synapse area — 2 entries in ${fx.kmd}`));
+  assert.ok(first[0].lines[1].includes('old_synapse_note.md'), 'index order when unused: ' + first[0].lines[1]);
+  assert.ok(first[0].lines[2].includes('new_synapse_note.md'));
+
+  // Reads of new_synapse_note (not 'area' shows, which would self-reinforce) move it up in a later session.
+  const reads = [1, 2].map(() => JSON.stringify({ ts: new Date().toISOString(), session_id: 'x', kind: 'read', file: path.join(fx.dir, 'new_synapse_note.md') })).join('\n') + '\n';
+  fs.appendFileSync(fx.usageLogPath, reads);
+  const later = guard.matchAreas('Read', { file_path: 'dashboard/src-tauri/src/features/synapse/memory.rs' }, {
+    sections: fx.sections, statePath: fx.statePath, usageLogPath: fx.usageLogPath, sessionId: sessionId + '-later',
+  });
+  assert.ok(later[0].lines[1].includes('new_synapse_note.md'), 'most-read first: ' + later[0].lines[1]);
+
+  const second = guard.matchAreas('Read', { file_path: 'dashboard/src-tauri/src/features/synapse/other.rs' }, {
+    sections: fx.sections, statePath: fx.statePath, usageLogPath: fx.usageLogPath, sessionId,
+  });
+  assert.strictEqual(second.length, 0, 'the same section must not fire twice in the same session');
+});
+
+test('matchAreas: a Read of an unrelated file returns nothing', () => {
+  const fx = areaFixture();
+  const result = guard.matchAreas('Read', { file_path: 'README.md' }, {
+    sections: fx.sections, statePath: fx.statePath, usageLogPath: fx.usageLogPath, sessionId: 'area-sess-unrelated-' + Date.now(),
+  });
+  assert.strictEqual(result.length, 0);
+});
+
+test('usage log: a guard fire and an area digest each append a JSONL line, keyed by kind/file/session', () => {
+  const dir = tmpDir('mg-usage-');
+  const usageLogPath = path.join(dir, 'memory_usage.jsonl');
+  const sessionId = 'usage-sess-' + Date.now();
+
+  const guardDir = tmpDir('mg-usage-guard-');
+  const cache = path.join(guardDir, 'cache.json');
+  writeMemory(guardDir, 'a.md', { name: 'a', description: 'x', triggers: [String.raw`^Bash$ | cargo\s+test`] });
+  const triggers = guard.loadTriggers([guardDir], cache);
+  guard.match('Bash', { command: 'cargo test' }, {
+    triggers, sessionId, statePath: path.join(dir, 'guard-state.json'), usageLogPath,
+  });
+
+  const fx = areaFixture();
+  guard.matchAreas('Read', { file_path: 'features/synapse/x.rs' }, {
+    sections: fx.sections, sessionId, statePath: path.join(dir, 'area-state.json'), usageLogPath,
+  });
+
+  const lines = fs.readFileSync(usageLogPath, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+  assert.ok(lines.some((r) => r.kind === 'guard' && r.file === 'a.md' && r.session_id === sessionId));
+  assert.ok(lines.some((r) => r.kind === 'area' && r.file === 'new_synapse_note.md' && r.session_id === sessionId));
+  assert.ok(lines.some((r) => r.kind === 'area' && r.file === 'old_synapse_note.md' && r.session_id === sessionId));
+});
+
+test('usage log: without a sessionId, match()/matchAreas() do not write (avoids polluting the log from eval/measurement replays)', () => {
+  const dir = tmpDir('mg-usage-nosession-');
+  const usageLogPath = path.join(dir, 'memory_usage.jsonl');
+
+  const guardDir = tmpDir('mg-usage-guard2-');
+  const cache = path.join(guardDir, 'cache.json');
+  writeMemory(guardDir, 'a.md', { name: 'a', description: 'x', triggers: [String.raw`^Bash$ | cargo\s+test`] });
+  const triggers = guard.loadTriggers([guardDir], cache);
+  guard.match('Bash', { command: 'cargo test' }, { triggers, dedupe: false, usageLogPath });
+
+  const fx = areaFixture();
+  guard.matchAreas('Read', { file_path: 'features/synapse/x.rs' }, {
+    sections: fx.sections, dedupe: false, usageLogPath,
+  });
+
+  assert.ok(!fs.existsSync(usageLogPath), 'no sessionId and no explicit logUsage:true must skip the write entirely');
+});
+
+/** Run the Read|Edit|Write PreToolUse entry exactly as settings.json does: `require('./memory-guard.js').main()` under `node -e`. */
+function runMain(payload, fixture) {
+  const code = `process.chdir(process.env.CLAUDE_PROJECT_DIR);require(${JSON.stringify(HOOK)}).main()`;
+  const r = spawnSync(process.execPath, ['-e', code], {
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    env: { ...process.env, CLAUDE_PROJECT_DIR: fixture.projectDir, HOME: fixture.home, USERPROFILE: fixture.home },
+    timeout: 10000,
+  });
+  assert.strictEqual(r.status, 0, r.stderr);
+  return JSON.parse(r.stdout);
+}
+
+test('memory-guard main() logs a usage-log "read" line for a Read inside the memory dir', () => {
+  const fixture = fixtureProject();
+  const memDir = path.join(fixture.home, '.claude', 'projects', guard.encodeProjectDirName(path.resolve(fixture.projectDir)), 'memory');
+  const filePath = path.join(memDir, 'no-blanket-kill.md');
+
+  runMain({
+    session_id: 'read-sess-' + Date.now(),
+    tool_name: 'Read',
+    tool_input: { file_path: filePath },
+  }, fixture);
+
+  const usageLogPath = path.join(fixture.projectDir, '.kenaz', 'specialist', 'memory_usage.jsonl');
+  const lines = fs.readFileSync(usageLogPath, 'utf8').trim().split('\n').map((l) => JSON.parse(l));
+  assert.ok(lines.some((row) => row.kind === 'read' && row.file === 'no-blanket-kill.md'));
+});
+
+/** fixtureProject() + a KNOWLEDGE.md area section matching features/(synapse|cortex)/ paths (either separator). */
+function fixtureProjectWithArea() {
+  const fixture = fixtureProject();
+  const memDir = path.join(fixture.home, '.claude', 'projects', guard.encodeProjectDirName(path.resolve(fixture.projectDir)), 'memory');
+  fs.writeFileSync(path.join(memDir, 'note.md'), 'note\n', 'utf8');
+  const content = [
+    '# Knowledge index',
+    '',
+    `## Synapse area <!-- area-triggers: ${JSON.stringify(['^(Read|Edit|Write)$ | features.(synapse|cortex).'])} -->`,
+    '- [Note](note.md) — note',
+    '',
+  ].join('\n');
+  fs.writeFileSync(path.join(memDir, 'KNOWLEDGE.md'), content, 'utf8');
+  return fixture;
+}
+
+test('memory-guard main() no longer injects area digests (2026-10-09), even for an area-matching path', () => {
+  const fixture = fixtureProjectWithArea();
+  const areaFile = path.join(fixture.projectDir, 'features', 'synapse', 'thing.rs');
+  const plainFile = path.join(fixture.projectDir, 'other.rs');
+
+  const run = (filePath) => runMain({
+    session_id: 'mgm-sess-' + Date.now() + '-' + path.basename(filePath),
+    tool_name: 'Edit',
+    tool_input: { file_path: filePath, old_string: 'x', new_string: 'y' },
+  }, fixture);
+
+  const withDigest = run(areaFile);
+  const withoutDigest = run(plainFile);
+
+  assert.ok(
+    !(withDigest.hookSpecificOutput.additionalContext || '').includes('📚 knowledge area'),
+    'area digest must not be injected: ' + JSON.stringify(withDigest),
+  );
+  assert.ok(
+    !(withoutDigest.hookSpecificOutput.additionalContext || '').includes('📚 knowledge area'),
+    'digest must not appear for an unrelated file: ' + JSON.stringify(withoutDigest),
+  );
+});

package/core/.claude/hooks/reflex-feedback.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+// reflex-feedback.js — RETIRED (TASK_2348). The reflex system was removed (measured zero benefit).
+// This no-op stays so user-level ~/.claude/settings.json entries that still point here exit 0
+// instead of erroring; the manifest lists it under `retired`, so install-claude-hooks sweeps them.
+process.exit(0);

package/core/.claude/hooks/session-init.ps1

@@ -0,0 +1,49 @@
+# Session Start Hook - 显示 Command 选择菜单
+# 当新 session 启动时，提示 Claude 显示可用的 Agent 指令供用户选择
+
+param()
+
+# 读取 stdin 获取 session 信息
+$input = [Console]::In.ReadToEnd()
+$sessionInfo = $input | ConvertFrom-Json -ErrorAction SilentlyContinue
+
+# 检查是否是新启动（不是 resume）
+$source = $sessionInfo.source
+if ($source -eq "startup" -or $source -eq "clear") {
+    # Canary is generated by session.js (buildAssembledPrompt) — not duplicated here.
+
+    # 返回 additionalContext，触发 Claude 显示选择菜单
+    $menuContext = @"
+[SESSION_INIT_TRIGGER]
+新 session 已启动。请立即使用 AskUserQuestion 工具向用户展示 Agent 选择菜单：
+
+可用的 Agent 指令：
+- /產品 - 需求分析、任务规划、PRD 撰写
+- /設計 - UI/UX 设计、设计规范、视觉稿
+- /architect - 系统架构设计
+- /進度 - 查看开发进度
+- /init - 初始化新专案
+
+请用 AskUserQuestion 让用户选择要使用的模式，选项包括：
+1. 产品需求分析 (/產品)
+2. UI/UX 设计 (/設計)
+3. Pipeline 开发 (/dev)
+4. 系统架构设计 (/architect)
+5. 自由对话（不使用特定 Agent）
+
+用户选择后，自动调用对应的 Skill。
+"@
+
+    $additionalContext = $menuContext
+
+    $context = @{
+        hookSpecificOutput = @{
+            hookEventName = "SessionStart"
+            additionalContext = $additionalContext
+        }
+    } | ConvertTo-Json -Depth 10 -Compress
+
+    Write-Output $context
+}
+
+exit 0