ma-agents 2.20.3 → 2.22.0

package/test/enforcement-hooks.test.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+/**
+ * Tests for Story 8.5: Per-Agent Enforcement Hooks Research
+ *
+ * Tests the Claude Code hook deployment/removal in installer.js
+ * and the verify-manifest.js hook script.
+ */
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+let passed = 0;
+let failed = 0;
+const errors = [];
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  \u2713 ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  \u2717 ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+async function asyncTest(name, fn) {
+  try {
+    await fn();
+    console.log(`  \u2713 ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  \u2717 ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+const { deployClaudeCodeHook, removeClaudeCodeHook } = require('../lib/installer');
+
+// Helper to create a temp directory for each test
+function createTempDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
+}
+
+/**
+ * Helper: run the hook script with JSON input via a temp file piped to stdin.
+ * Works cross-platform (avoids shell quoting issues with echo).
+ */
+function runHookWithInput(inputObj) {
+  const hs = path.join(__dirname, '..', 'lib', 'hooks', 'claude-code', 'verify-manifest.js');
+  const tmpInput = path.join(os.tmpdir(), `hook-input-${Date.now()}.json`);
+  fs.writeFileSync(tmpInput, typeof inputObj === 'string' ? inputObj : JSON.stringify(inputObj), 'utf-8');
+  try {
+    return execSync(`node "${hs}" < "${tmpInput}"`, {
+      encoding: 'utf-8',
+      timeout: 5000
+    });
+  } finally {
+    fs.removeSync(tmpInput);
+  }
+}
+
+// ─── Task 1: deployClaudeCodeHook() tests ───────────────────────────────────
+
+console.log('\nTask 1 — deployClaudeCodeHook()');
+
+asyncTest('1.1: creates settings.json with hook when file does not exist', async () => {
+  const tmpDir = createTempDir();
+  try {
+    await deployClaudeCodeHook(tmpDir);
+
+    const settingsPath = path.join(tmpDir, '.claude', 'settings.json');
+    assert.ok(fs.existsSync(settingsPath), 'settings.json should be created');
+
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    assert.ok(settings.hooks, 'hooks key should exist');
+    assert.ok(settings.hooks.SessionStart, 'SessionStart hooks should exist');
+    assert.strictEqual(settings.hooks.SessionStart.length, 1);
+    assert.strictEqual(settings.hooks.SessionStart[0].matcher, 'startup');
+    assert.strictEqual(settings.hooks.SessionStart[0].hooks[0].type, 'command');
+    assert.ok(settings.hooks.SessionStart[0].hooks[0].command.includes('verify-manifest.js'));
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+}).then(() =>
+
+asyncTest('1.2: preserves existing settings when adding hook', async () => {
+  const tmpDir = createTempDir();
+  try {
+    const settingsDir = path.join(tmpDir, '.claude');
+    await fs.ensureDir(settingsDir);
+    const existingSettings = {
+      permissions: {
+        allow: ['Bash(node:*)']
+      },
+      someOtherSetting: true
+    };
+    await fs.writeFile(
+      path.join(settingsDir, 'settings.json'),
+      JSON.stringify(existingSettings, null, 2),
+      'utf-8'
+    );
+
+    await deployClaudeCodeHook(tmpDir);
+
+    const settings = JSON.parse(fs.readFileSync(path.join(settingsDir, 'settings.json'), 'utf-8'));
+    assert.ok(settings.permissions, 'existing permissions should be preserved');
+    assert.deepStrictEqual(settings.permissions.allow, ['Bash(node:*)']);
+    assert.strictEqual(settings.someOtherSetting, true);
+    assert.ok(settings.hooks.SessionStart, 'hook should be added');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() =>
+
+asyncTest('1.3: preserves existing hooks when adding our hook', async () => {
+  const tmpDir = createTempDir();
+  try {
+    const settingsDir = path.join(tmpDir, '.claude');
+    await fs.ensureDir(settingsDir);
+    const existingSettings = {
+      hooks: {
+        SessionStart: [
+          {
+            matcher: 'startup',
+            hooks: [{ type: 'command', command: 'echo "existing hook"' }]
+          }
+        ],
+        PreToolUse: [
+          {
+            matcher: 'Bash',
+            hooks: [{ type: 'command', command: 'echo "pre-tool"' }]
+          }
+        ]
+      }
+    };
+    await fs.writeFile(
+      path.join(settingsDir, 'settings.json'),
+      JSON.stringify(existingSettings, null, 2),
+      'utf-8'
+    );
+
+    await deployClaudeCodeHook(tmpDir);
+
+    const settings = JSON.parse(fs.readFileSync(path.join(settingsDir, 'settings.json'), 'utf-8'));
+    assert.strictEqual(settings.hooks.SessionStart.length, 2, 'should have 2 SessionStart hook groups');
+    assert.ok(settings.hooks.PreToolUse, 'PreToolUse hooks should be preserved');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() =>
+
+asyncTest('1.4: is idempotent — does not duplicate hook on second call', async () => {
+  const tmpDir = createTempDir();
+  try {
+    await deployClaudeCodeHook(tmpDir);
+    await deployClaudeCodeHook(tmpDir);
+
+    const settingsPath = path.join(tmpDir, '.claude', 'settings.json');
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    assert.strictEqual(settings.hooks.SessionStart.length, 1, 'should not duplicate hook');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() => {
+
+// ─── Task 2: removeClaudeCodeHook() tests ──────────────────────────────────
+
+console.log('\nTask 2 — removeClaudeCodeHook()');
+
+return asyncTest('2.1: removes our hook while preserving other hooks', async () => {
+  const tmpDir = createTempDir();
+  try {
+    const settingsDir = path.join(tmpDir, '.claude');
+    await fs.ensureDir(settingsDir);
+
+    // Deploy our hook first
+    await deployClaudeCodeHook(tmpDir);
+
+    // Add another hook manually
+    const settingsPath = path.join(settingsDir, 'settings.json');
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    settings.hooks.SessionStart.unshift({
+      matcher: 'startup',
+      hooks: [{ type: 'command', command: 'echo "other hook"' }]
+    });
+    settings.hooks.PreToolUse = [{ matcher: 'Bash', hooks: [{ type: 'command', command: 'echo "bash"' }] }];
+    await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+
+    await removeClaudeCodeHook(tmpDir);
+
+    const updated = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    assert.strictEqual(updated.hooks.SessionStart.length, 1, 'should keep other SessionStart hook');
+    assert.ok(updated.hooks.PreToolUse, 'PreToolUse hooks should be preserved');
+    assert.ok(!updated.hooks.SessionStart[0].hooks[0].command.includes('verify-manifest'), 'our hook should be removed');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+});
+
+}).then(() =>
+
+asyncTest('2.2: cleans up empty hooks object when last hook removed', async () => {
+  const tmpDir = createTempDir();
+  try {
+    await deployClaudeCodeHook(tmpDir);
+    await removeClaudeCodeHook(tmpDir);
+
+    const settingsPath = path.join(tmpDir, '.claude', 'settings.json');
+    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    assert.ok(!settings.hooks, 'hooks key should be removed when empty');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() =>
+
+asyncTest('2.3: no-op when settings.json does not exist', async () => {
+  const tmpDir = createTempDir();
+  try {
+    // Should not throw
+    await removeClaudeCodeHook(tmpDir);
+    assert.ok(!fs.existsSync(path.join(tmpDir, '.claude', 'settings.json')));
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() => {
+
+// ─── Task 3: verify-manifest.js hook script tests ──────────────────────────
+
+console.log('\nTask 3 — verify-manifest.js hook script');
+
+return asyncTest('3.1: outputs reminder when MANIFEST.yaml exists', async () => {
+  const tmpDir = createTempDir();
+  try {
+    const skillsDir = path.join(tmpDir, '.claude', 'skills');
+    await fs.ensureDir(skillsDir);
+    await fs.writeFile(path.join(skillsDir, 'MANIFEST.yaml'), '# test manifest\n', 'utf-8');
+
+    const result = runHookWithInput({ cwd: tmpDir, session_id: 'test', hook_event_name: 'SessionStart' });
+
+    assert.ok(result.includes('SKILL ENFORCEMENT ACTIVE'), 'should output enforcement reminder');
+    assert.ok(result.includes('MANIFEST.yaml'), 'should reference MANIFEST.yaml');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+});
+
+}).then(() =>
+
+asyncTest('3.2: silent when no MANIFEST.yaml exists', async () => {
+  const tmpDir = createTempDir();
+  try {
+    const result = runHookWithInput({ cwd: tmpDir, session_id: 'test', hook_event_name: 'SessionStart' });
+    assert.strictEqual(result.trim(), '', 'should produce no output when no manifest');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() =>
+
+asyncTest('3.3: exits 0 on malformed JSON input', async () => {
+  const tmpDir = createTempDir();
+  try {
+    // Pipe invalid JSON — should exit 0 (not crash)
+    const result = runHookWithInput('not json at all');
+    // If we get here, exit code was 0
+    assert.ok(true, 'should exit 0 on malformed input');
+  } finally {
+    fs.removeSync(tmpDir);
+  }
+})).then(() => {
+
+// ─── Task 4: Technical note document exists ─────────────────────────────────
+
+console.log('\nTask 4 — Technical note document');
+
+test('4.1: enforcement-hooks-research.md exists', () => {
+  const docPath = path.join(__dirname, '..', 'docs', 'technical-notes', 'enforcement-hooks-research.md');
+  assert.ok(fs.existsSync(docPath), 'technical note should exist');
+});
+
+test('4.2: document contains agent summary table', () => {
+  const docPath = path.join(__dirname, '..', 'docs', 'technical-notes', 'enforcement-hooks-research.md');
+  const content = fs.readFileSync(docPath, 'utf-8');
+  assert.ok(content.includes('| Agent |'), 'should contain agent summary table');
+  assert.ok(content.includes('Claude Code'), 'should reference Claude Code');
+  assert.ok(content.includes('Cursor'), 'should reference Cursor');
+  assert.ok(content.includes('GitHub Copilot'), 'should reference GitHub Copilot');
+  assert.ok(content.includes('Gemini'), 'should reference Gemini');
+  assert.ok(content.includes('Cline'), 'should reference Cline');
+  assert.ok(content.includes('Kilocode'), 'should reference Kilocode');
+  assert.ok(content.includes('Antigravity'), 'should reference Antigravity');
+  assert.ok(content.includes('BMAD'), 'should reference BMAD agents');
+});
+
+test('4.3: document contains recommendations section', () => {
+  const docPath = path.join(__dirname, '..', 'docs', 'technical-notes', 'enforcement-hooks-research.md');
+  const content = fs.readFileSync(docPath, 'utf-8');
+  assert.ok(content.includes('## Recommendations'), 'should contain recommendations section');
+});
+
+test('4.4: document contains prototype implementation section', () => {
+  const docPath = path.join(__dirname, '..', 'docs', 'technical-notes', 'enforcement-hooks-research.md');
+  const content = fs.readFileSync(docPath, 'utf-8');
+  assert.ok(content.includes('Prototype Implementation'), 'should contain prototype section');
+  assert.ok(content.includes('verify-manifest'), 'should reference the hook script');
+});
+
+// ─── Summary ────────────────────────────────────────────────────────────────
+
+console.log(`\n${'─'.repeat(60)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (errors.length > 0) {
+  console.log('\nFailures:');
+  errors.forEach(e => console.log(`  - ${e.name}: ${e.error}`));
+  process.exit(1);
+}
+
+});

package/test/generate-project-context.test.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+/**
+ * Tests for generateProjectContext() and updateProjectContextManifestPaths() — Stories 13.1, 13.2
+ *
+ * generateProjectContext AC coverage:
+ *   3.1  single platform → one MANIFEST path in output        (AC #14)
+ *   3.2  multiple platforms → correct count, correct order    (AC #15)
+ *   3.3  all relative paths — no absolute path segments        (AC #9)
+ *   3.4  {{MANIFEST_PATHS_LIST}} fully replaced               (AC #10)
+ *   3.5  empty agents array → fallback message, no error      (AC #12)
+ *   3.6  missing template → Error with path in message        (AC #13)
+ *   3.7  template version comment present in output           (AC #4, NFR25)
+ *   3.8  function does NOT call fs.writeFile / fs.pathExists  (AC #11)
+ *   3.9  agent without skillsDir is skipped (no undefined/MANIFEST.yaml)
+ *   3.10 all agents lack skillsDir → fallback message
+ *
+ * updateProjectContextManifestPaths AC coverage:
+ *   4.1  markers present + new agent → file updated, returns true
+ *   4.2  already up to date → returns false, no write
+ *   4.3  no markers (old-format) → returns false, backward compatible
+ *   4.4  agents without skillsDir excluded from update
+ */
+'use strict';
+
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+let passed = 0;
+let failed = 0;
+const errors = [];
+
+async function test(name, fn) {
+  try {
+    await fn();
+    console.log(`  ✓ ${name}`);
+    passed++;
+  } catch (err) {
+    console.error(`  ✗ ${name}: ${err.message}`);
+    failed++;
+    errors.push({ name, error: err.message });
+  }
+}
+
+// ─── Module imports ─────────────────────────────────────────────────────────
+// Template path derived directly — not imported from module (avoids leaking internals)
+const _TEMPLATE_PATH = path.join(__dirname, '..', 'lib', 'templates', 'project-context.template.md');
+
+let generateProjectContext, updateProjectContextManifestPaths;
+try {
+  ({ generateProjectContext, _updateProjectContextManifestPaths: updateProjectContextManifestPaths } = require('../lib/installer'));
+} catch (e) {
+  console.error('\n  FATAL: Cannot load installer module');
+  console.error(' ', e.message);
+  process.exit(1);
+}
+
+// Helper: agent stub with skillsDir property
+function agent(skillsDir) {
+  return { skillsDir };
+}
+
+// Helper: count backtick-wrapped MANIFEST.yaml path entries in content
+function countManifestPaths(content) {
+  const matches = content.match(/`[^`]+\/MANIFEST\.yaml`/g) || [];
+  return matches.length;
+}
+
+console.log('\n generate-project-context unit tests\n');
+
+async function runAll() {
+  // 3.7 Template version comment present
+  await test('3.7 template contains version comment <!-- ma-agents-template-version: 1.0 -->', async () => {
+    const content = await generateProjectContext('/some/root', [agent('.claude/skills')]);
+    assert.ok(
+      content.includes('<!-- ma-agents-template-version: 1.0 -->'),
+      'version comment not found in output'
+    );
+  });
+
+  // 3.1 Single platform → exactly one MANIFEST path
+  await test('3.1 single platform → exactly one MANIFEST path entry', async () => {
+    const content = await generateProjectContext('/some/root', [agent('.claude/skills')]);
+    const count = countManifestPaths(content);
+    assert.strictEqual(count, 1, `expected 1 MANIFEST.yaml path entry, got ${count}`);
+    assert.ok(content.includes('  - `.claude/skills/MANIFEST.yaml`'), 'expected .claude/skills path');
+  });
+
+  // 3.2 Multiple platforms → correct count and order
+  await test('3.2 multiple platforms → correct count and manifest order', async () => {
+    const agents = [
+      agent('.claude/skills'),
+      agent('.cursor/skills'),
+      agent('.gemini/skills')
+    ];
+    const content = await generateProjectContext('/some/root', agents);
+    const count = countManifestPaths(content);
+    assert.strictEqual(count, 3, `expected 3 MANIFEST.yaml path entries, got ${count}`);
+    const claudeIdx = content.indexOf('.claude/skills/MANIFEST.yaml');
+    const cursorIdx = content.indexOf('.cursor/skills/MANIFEST.yaml');
+    const geminiIdx = content.indexOf('.gemini/skills/MANIFEST.yaml');
+    assert.ok(claudeIdx < cursorIdx, 'claude should appear before cursor');
+    assert.ok(cursorIdx < geminiIdx, 'cursor should appear before gemini');
+  });
+
+  // 3.3 All relative paths — no absolute path segments
+  await test('3.3 all paths are relative — no absolute path segments in output', async () => {
+    const agents = [
+      agent('.claude/skills'),
+      agent('.cursor/skills')
+    ];
+    const content = await generateProjectContext('/some/root', agents);
+    // Absolute paths start with / (unix) or X:\ (windows) inside backticks
+    const hasAbsolute = /`\/[^`]+MANIFEST\.yaml`/.test(content) ||
+                        /`[A-Za-z]:\\[^`]+MANIFEST\.yaml`/.test(content);
+    assert.ok(!hasAbsolute, 'output contains absolute path segments');
+  });
+
+  // 3.4 {{MANIFEST_PATHS_LIST}} placeholder fully replaced
+  await test('3.4 {{MANIFEST_PATHS_LIST}} placeholder fully replaced', async () => {
+    const content = await generateProjectContext('/some/root', [agent('.claude/skills')]);
+    assert.ok(
+      !content.includes('{{MANIFEST_PATHS_LIST}}'),
+      'placeholder {{MANIFEST_PATHS_LIST}} still present in output'
+    );
+  });
+
+  // 3.5 Empty agents array → fallback message, no error
+  await test('3.5 empty agents array → fallback message, no error thrown', async () => {
+    let content;
+    try {
+      content = await generateProjectContext('/some/root', []);
+    } catch (err) {
+      assert.fail(`should not throw with empty agents, got: ${err.message}`);
+    }
+    assert.ok(
+      content.includes('no agents installed — run ma-agents to install skills'),
+      'fallback message not found in output'
+    );
+    assert.ok(!content.includes('{{MANIFEST_PATHS_LIST}}'), 'placeholder not replaced in fallback case');
+  });
+
+  // 3.5b null installedAgents → fallback message
+  await test('3.5b null installedAgents → fallback message, no error thrown', async () => {
+    let content;
+    try {
+      content = await generateProjectContext('/some/root', null);
+    } catch (err) {
+      assert.fail(`should not throw with null agents, got: ${err.message}`);
+    }
+    assert.ok(
+      content.includes('no agents installed — run ma-agents to install skills'),
+      'fallback message not found in output'
+    );
+  });
+
+  // 3.6 Missing template → Error thrown with path in message (runs after others to avoid race)
+  await test('3.6 missing template file → Error thrown with template path in message', async () => {
+    const backupPath = _TEMPLATE_PATH + '.bak';
+    const templateExists = fs.existsSync(_TEMPLATE_PATH);
+    if (templateExists) {
+      fs.renameSync(_TEMPLATE_PATH, backupPath);
+    }
+    try {
+      try {
+        await generateProjectContext('/some/root', [agent('.claude/skills')]);
+        assert.fail('Expected an Error to be thrown for missing template');
+      } catch (err) {
+        assert.ok(err instanceof Error, 'thrown value should be an Error instance');
+        assert.ok(
+          err.message.includes(_TEMPLATE_PATH),
+          `error message should include template path. Got: ${err.message}`
+        );
+      }
+    } finally {
+      if (templateExists) {
+        fs.renameSync(backupPath, _TEMPLATE_PATH);
+      }
+    }
+  });
+
+  // 3.8 Function returns string content — does NOT write any file
+  await test('3.8 function returns content string and does not write files', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-agents-test-'));
+    const beforeFiles = fs.readdirSync(tmpDir);
+
+    const result = await generateProjectContext(tmpDir, [agent('.claude/skills')]);
+
+    const afterFiles = fs.readdirSync(tmpDir);
+    assert.strictEqual(typeof result, 'string', 'function should return a string');
+    assert.ok(result.length > 0, 'returned string should not be empty');
+    assert.deepStrictEqual(beforeFiles, afterFiles, 'function should not write any files to disk');
+
+    fs.rmdirSync(tmpDir);
+  });
+
+  // 3.9 Agent without skillsDir is silently skipped (finding #4 guard)
+  await test('3.9 agent with undefined skillsDir is skipped — no undefined/MANIFEST.yaml in output', async () => {
+    const agents = [
+      agent('.claude/skills'),
+      { id: 'legacy-agent' }, // no skillsDir
+      agent('.cursor/skills')
+    ];
+    const content = await generateProjectContext('/some/root', agents);
+    assert.ok(!content.includes('undefined/MANIFEST.yaml'), 'output must not contain undefined/MANIFEST.yaml');
+    const count = countManifestPaths(content);
+    assert.strictEqual(count, 2, `expected 2 valid paths (legacy agent skipped), got ${count}`);
+  });
+
+  // 3.10 All agents without skillsDir → fallback message (no valid agents)
+  await test('3.10 all agents lack skillsDir → fallback message rather than empty list', async () => {
+    const content = await generateProjectContext('/some/root', [{ id: 'a' }, { id: 'b' }]);
+    assert.ok(
+      content.includes('no agents installed — run ma-agents to install skills'),
+      'fallback message should appear when no valid agents have skillsDir'
+    );
+    assert.ok(!content.includes('undefined/MANIFEST.yaml'), 'output must not contain undefined path');
+  });
+
+  // ─── updateProjectContextManifestPaths tests (finding #5, pipeline coverage) ───
+
+  // 4.1 Markers present + new agent → file updated, returns true
+  await test('4.1 updateProjectContextManifestPaths: markers present, new agent added → returns true and updates file', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-agents-update-test-'));
+    const outputPath = path.join(tmpDir, 'project-context.md');
+
+    // Write a file that simulates a generated project-context.md with one agent
+    const initial = [
+      '# Project Context',
+      '<!-- ma-agents:manifest-paths-start -->',
+      '  - `.claude/skills/MANIFEST.yaml`',
+      '<!-- ma-agents:manifest-paths-end -->',
+      '## Project-Specific Rules',
+      '<!-- user rules here -->'
+    ].join('\n');
+    fs.writeFileSync(outputPath, initial, 'utf8');
+
+    const result = await updateProjectContextManifestPaths(outputPath, [
+      agent('.claude/skills'),
+      agent('.gemini/skills')
+    ]);
+
+    assert.strictEqual(result, true, 'should return true when file was updated');
+    const updated = fs.readFileSync(outputPath, 'utf8');
+    assert.ok(updated.includes('  - `.claude/skills/MANIFEST.yaml`'), 'claude path should be present');
+    assert.ok(updated.includes('  - `.gemini/skills/MANIFEST.yaml`'), 'gemini path should be added');
+    assert.ok(updated.includes('<!-- user rules here -->'), 'user-written content must be preserved');
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  // 4.2 Markers present, no change needed → returns false, no write
+  await test('4.2 updateProjectContextManifestPaths: already up to date → returns false without writing', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-agents-update-test-'));
+    const outputPath = path.join(tmpDir, 'project-context.md');
+
+    const initial = [
+      '# Project Context',
+      '<!-- ma-agents:manifest-paths-start -->',
+      '  - `.claude/skills/MANIFEST.yaml`',
+      '<!-- ma-agents:manifest-paths-end -->'
+    ].join('\n');
+    fs.writeFileSync(outputPath, initial, 'utf8');
+    const mtime1 = fs.statSync(outputPath).mtimeMs;
+
+    // Small delay to ensure mtime would differ if file were written
+    await new Promise(r => setTimeout(r, 50));
+    const result = await updateProjectContextManifestPaths(outputPath, [agent('.claude/skills')]);
+
+    assert.strictEqual(result, false, 'should return false when no change needed');
+    const mtime2 = fs.statSync(outputPath).mtimeMs;
+    assert.strictEqual(mtime1, mtime2, 'file should not have been written when content unchanged');
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  // 4.3 No markers (old-format file) → returns false, backward compatible
+  await test('4.3 updateProjectContextManifestPaths: no markers in file → returns false (backward compatible)', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-agents-update-test-'));
+    const outputPath = path.join(tmpDir, 'project-context.md');
+
+    // Old-format file without markers
+    const oldFormat = [
+      '# Project Context',
+      '1. Read the MANIFEST.yaml for your platform:',
+      '  - `.claude/skills/MANIFEST.yaml`',
+      '2. Load ALL skills...'
+    ].join('\n');
+    fs.writeFileSync(outputPath, oldFormat, 'utf8');
+
+    const result = await updateProjectContextManifestPaths(outputPath, [
+      agent('.claude/skills'),
+      agent('.gemini/skills')
+    ]);
+
+    assert.strictEqual(result, false, 'should return false for old-format files without markers');
+    const content = fs.readFileSync(outputPath, 'utf8');
+    assert.strictEqual(content, oldFormat, 'old-format file must not be modified');
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  // 4.4 Markers present, agent with undefined skillsDir is excluded from update
+  await test('4.4 updateProjectContextManifestPaths: agents without skillsDir are excluded', async () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ma-agents-update-test-'));
+    const outputPath = path.join(tmpDir, 'project-context.md');
+
+    const initial = [
+      '# Project Context',
+      '<!-- ma-agents:manifest-paths-start -->',
+      '  - `.claude/skills/MANIFEST.yaml`',
+      '<!-- ma-agents:manifest-paths-end -->'
+    ].join('\n');
+    fs.writeFileSync(outputPath, initial, 'utf8');
+
+    const result = await updateProjectContextManifestPaths(outputPath, [
+      agent('.claude/skills'),
+      { id: 'legacy' } // no skillsDir
+    ]);
+
+    assert.strictEqual(result, false, 'should return false — only valid agent already present');
+    const content = fs.readFileSync(outputPath, 'utf8');
+    assert.ok(!content.includes('undefined'), 'must not introduce undefined paths');
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  // ─── Report ────────────────────────────────────────────────────────────────
+  console.log(`\n  ${passed} passed, ${failed} failed\n`);
+  if (failed > 0) {
+    errors.forEach(e => console.error(`  ✗ ${e.name}: ${e.error}`));
+    process.exit(1);
+  }
+}
+
+runAll();