project-knowledge 0.1.0

package/_site/_test/hook-trigger-test.js

@@ -0,0 +1,257 @@
+// _site/_test/hook-trigger-test.js
+//
+// TASK-012: post-commit hook regression test.
+//
+// Verifies:
+//   1. hook-manager.installHook writes a post-commit script under .git/hooks/
+//      that is executable and contains the KB marker.
+//   2. installHook refuses to overwrite a non-KB-managed hook without overwrite.
+//   3. uninstallHook refuses to delete a non-KB-managed hook.
+//   4. uninstallHook removes a KB-managed hook.
+//   5. hook-trigger.js dispatches a `safe` job to the KB server, and
+//      exits 0 even when the server is unreachable (silent failure).
+//   6. End-to-end: a real `git commit` in a fixture repo fires the hook,
+//      which calls hook-trigger.js, which calls /api/jobs/run on a
+//      running test server. The job log shows a `safe` run for the
+//      fixture's slug.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+const { installHook, uninstallHook, readHookStatus, HOOK_MARKER } = require('../lib/hook-manager');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const HOOK_TRIGGER = path.join(ROOT, '_site', 'scripts', 'hook-trigger.js');
+const SITE_ROOT = path.join(ROOT, '_site');
+const KB_ROOT = ROOT;
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const JOBS_LOG = path.join(KB_ROOT, '.jobs-log.json');
+const PORT = process.env.KB_HOOK_TEST_PORT || '7802';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+
+const SLUG = 'hook-test-proj';
+const FIXTURE_REPO = path.join(os.tmpdir(), `kb-hook-test-${process.pid}`);
+
+function assert(cond, msg) { if (!cond) throw new Error('ASSERT: ' + msg); }
+
+function rmrf(p) {
+  try { fs.rmSync(p, { recursive: true, force: true }); } catch {}
+}
+
+function execGit(cwd, args) {
+  return spawnSync('git', args, { cwd, encoding: 'utf-8', env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+}
+
+function initRepo(p) {
+  rmrf(p);
+  fs.mkdirSync(p, { recursive: true });
+  let r = execGit(p, ['init', '--initial-branch=main']);
+  assert(r.status === 0, 'git init failed: ' + r.stderr);
+  execGit(p, ['config', 'user.email', 'kb-test@example.com']);
+  execGit(p, ['config', 'user.name', 'KB Test']);
+  execGit(p, ['config', 'commit.gpgsign', 'false']);
+  fs.writeFileSync(path.join(p, 'README.md'), '# hook test\n');
+  execGit(p, ['add', 'README.md']);
+  r = execGit(p, ['commit', '-m', 'init']);
+  assert(r.status === 0, 'initial commit failed: ' + r.stderr);
+}
+
+function makeCommit(p, msg) {
+  fs.writeFileSync(path.join(p, 'changelog.md'), `+ ${msg}\n`, { flag: 'a' });
+  execGit(p, ['add', 'changelog.md']);
+  const r = execGit(p, ['commit', '-m', msg]);
+  assert(r.status === 0, 'commit failed: ' + r.stderr + ' :: ' + r.stdout);
+}
+
+async function waitForServer() {
+  const deadline = Date.now() + 15000;
+  let last;
+  while (Date.now() < deadline) {
+    try {
+      const r = await fetch(`${BASE_URL}/api/state`);
+      if (r.status < 500) return;
+      last = new Error('HTTP ' + r.status);
+    } catch (e) { last = e; }
+    await new Promise(r => setTimeout(r, 250));
+  }
+  throw last || new Error('server did not start');
+}
+
+async function json(method, url, body) {
+  const r = await fetch(`${BASE_URL}${url}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await r.text();
+  let data = {};
+  if (text) { try { data = JSON.parse(text); } catch { data = { raw: text }; } }
+  return { res: r, status: r.status, data };
+}
+
+async function waitForJob(slug, timeoutMs = 30000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const r = await json('GET', '/api/jobs');
+    if (r.data && Array.isArray(r.data.history)) {
+      const hit = r.data.history.find(j => j.slug === slug && j.mode === 'safe');
+      if (hit) return hit;
+    }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  return null;
+}
+
+(async () => {
+  // ---- 1. installHook writes a real post-commit script with the marker ----
+  initRepo(FIXTURE_REPO);
+  let r = installHook({ repoPath: FIXTURE_REPO, siteRoot: SITE_ROOT, host: '127.0.0.1', port: Number(PORT) });
+  assert(r.ok, 'installHook failed: ' + r.error);
+  const hookPath = path.join(FIXTURE_REPO, '.git', 'hooks', 'post-commit');
+  assert(fs.existsSync(hookPath), 'hook file not created at ' + hookPath);
+  const hookText = fs.readFileSync(hookPath, 'utf-8');
+  assert(hookText.includes(HOOK_MARKER), 'hook missing KB marker');
+  assert(hookText.includes('hook-trigger.js'), 'hook does not call hook-trigger.js');
+  assert(hookText.includes('--kb-root'), 'hook missing --kb-root flag');
+  assert(hookText.includes(FIXTURE_REPO.replace(/\\/g, '/')), 'hook missing repo path');
+
+  // On Windows the executable bit is not enforced, but on POSIX it should be set.
+  if (process.platform !== 'win32') {
+    const st = fs.statSync(hookPath);
+    assert((st.mode & 0o111) !== 0, 'hook is not executable on POSIX');
+  }
+
+  // ---- 2. installHook refuses to overwrite a non-KB-managed hook ----
+  rmrf(hookPath);
+  fs.writeFileSync(hookPath, '#!/bin/sh\necho "user hook, do not touch"\n');
+  r = installHook({ repoPath: FIXTURE_REPO, siteRoot: SITE_ROOT, host: '127.0.0.1', port: Number(PORT) });
+  assert(!r.ok && r.status === 409, 'installHook should refuse non-KB hook without overwrite');
+  assert(fs.readFileSync(hookPath, 'utf-8').includes('do not touch'), 'user hook was overwritten');
+  // Now allow overwrite
+  r = installHook({ repoPath: FIXTURE_REPO, siteRoot: SITE_ROOT, host: '127.0.0.1', port: Number(PORT), overwrite: true });
+  assert(r.ok, 'overwrite installHook failed: ' + r.error);
+  assert(fs.readFileSync(hookPath, 'utf-8').includes(HOOK_MARKER), 'overwrite did not write KB hook');
+
+  // ---- 3. uninstallHook refuses to delete a non-KB-managed hook ----
+  rmrf(hookPath);
+  fs.writeFileSync(hookPath, '#!/bin/sh\necho "user hook"\n');
+  r = uninstallHook({ repoPath: FIXTURE_REPO });
+  assert(!r.ok && r.status === 409, 'uninstallHook should refuse non-KB hook');
+  assert(fs.existsSync(hookPath), 'non-KB hook was deleted');
+
+  // ---- 4. uninstallHook removes a KB-managed hook ----
+  installHook({ repoPath: FIXTURE_REPO, siteRoot: SITE_ROOT, host: '127.0.0.1', port: Number(PORT), overwrite: true });
+  assert(fs.existsSync(hookPath), 'KB hook not present before uninstall');
+  const text4 = fs.readFileSync(hookPath, 'utf-8');
+  assert(text4.includes(HOOK_MARKER), 'KB hook did not replace the non-KB hook');
+  r = uninstallHook({ repoPath: FIXTURE_REPO });
+  assert(r.ok && r.removed === true, 'uninstallHook failed: ' + r.error);
+  assert(!fs.existsSync(hookPath), 'hook still exists after uninstall');
+
+  // ---- 5. readHookStatus reports correctly ----
+  let s = readHookStatus({ repoPath: FIXTURE_REPO });
+  assert(s.installed === false, 'readHookStatus should report not installed');
+  installHook({ repoPath: FIXTURE_REPO, siteRoot: SITE_ROOT, host: '127.0.0.1', port: Number(PORT) });
+  s = readHookStatus({ repoPath: FIXTURE_REPO });
+  assert(s.installed === true && s.kbManaged === true, 'readHookStatus should report KB-managed hook');
+
+  // ---- 6. hook-trigger.js exits 0 when the server is unreachable ----
+  // Point it at a closed port to simulate a downed server.
+  const childDown = spawn(process.execPath, [HOOK_TRIGGER, '--kb-root', KB_ROOT, '--repo', FIXTURE_REPO, '--host', '127.0.0.1', '--port', '1'], {
+    cwd: ROOT, stdio: 'pipe', windowsHide: true, env: { ...process.env, KB_SITE_PORT: '1' },
+  });
+  const downExit = await new Promise(res => { childDown.on('exit', res); });
+  assert(downExit === 0, `hook-trigger should exit 0 even when server is down, got ${downExit}`);
+
+  // ---- 7. End-to-end: real commit → hook → server job ----
+  // Bring up a test server on PORT.
+  const server = spawn(process.execPath, [SERVER], {
+    cwd: ROOT,
+    env: { ...process.env, KB_SITE_PORT: PORT, KB_SITE_HOST: '127.0.0.1' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+  let serverOutput = '';
+  server.stdout.on('data', d => { serverOutput += d.toString(); });
+  server.stderr.on('data', d => { serverOutput += d.toString(); });
+
+  try {
+    await waitForServer();
+
+    // Register the fixture repo as a project under SLUG, with kbPath pointing
+    // at a throwaway dir so the orchestrator can write drafts.
+    const projKb = path.join(ROOT, 'projects', SLUG);
+    rmrf(projKb);
+    fs.mkdirSync(projKb, { recursive: true });
+    fs.mkdirSync(path.join(projKb, '_ai', 'drafts'), { recursive: true });
+    fs.mkdirSync(path.join(projKb, '_ai', 'runs'), { recursive: true });
+    fs.mkdirSync(path.join(projKb, '_ai', 'context-packs'), { recursive: true });
+    fs.writeFileSync(path.join(projKb, 'README.md'), '# hook test kb\n');
+    fs.writeFileSync(path.join(projKb, 'kb-manifest.json'), JSON.stringify({
+      schema: 'kb-manifest/v1', project: SLUG, kbRoot: SLUG,
+      goal: { path: 'project-goal.md', status: 'accepted', updatedAt: new Date().toISOString() },
+      analysis: { path: null, lastAnalyzedCommit: null, updatedAt: null },
+      trustedKnowledge: ['README.md'], draftAreas: ['_ai/drafts/'],
+      indexes: {}, aiProfileId: 'mock-agent',
+    }, null, 2));
+    fs.writeFileSync(path.join(projKb, 'project-goal.md'), '# goal\n\ntest goal\n');
+
+    // Register projects.json entry
+    const projects = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+    projects[SLUG] = {
+      displayName: 'Hook Test', localPath: FIXTURE_REPO, gitPath: FIXTURE_REPO,
+      isReference: false, primaryLanguage: 'JavaScript', tags: [], docConvention: 'frontmatter-relations',
+      kbPath: projKb, enabled: true, repoStatus: 'unknown',
+      headCommit: null, lastSeenCommit: null, lastAnalyzedCommit: null,
+      aiProfileId: 'mock-agent', kbSchemaVersion: 'v1', goalStatus: 'accepted',
+      kbInitialized: true, kbV2Migrated: true,
+    };
+    fs.writeFileSync(PROJECTS_JSON, JSON.stringify(projects, null, 2) + '\n', 'utf-8');
+
+    // Reinstall hook (in case installHook needed to update the port)
+    uninstallHook({ repoPath: FIXTURE_REPO });
+    r = installHook({ repoPath: FIXTURE_REPO, siteRoot: SITE_ROOT, host: '127.0.0.1', port: Number(PORT) });
+    assert(r.ok, 'reinstall failed: ' + r.error);
+
+    // Make a real commit
+    makeCommit(FIXTURE_REPO, 'feat: add changelog entry to trigger hook');
+
+    // Wait for the server to record the safe job
+    const job = await waitForJob(SLUG, 30000);
+    assert(job, `no safe job for ${SLUG} appeared within 30s — server output: ${serverOutput.slice(-1000)}`);
+    assert(job.mode === 'safe', 'wrong mode: ' + job.mode);
+    console.log('hook job observed:', job.jobId, job.mode, job.slug, '→', job.status);
+
+    // ---- 8. The hook-trigger log file is in KB root ----
+    const logPath = path.join(KB_ROOT, '.hook-trigger-errors.log');
+    // We don't assert it exists — only if there was a failure. But we do
+    // assert the file is writable: if it doesn't exist, that's fine.
+    if (fs.existsSync(logPath)) {
+      const lines = fs.readFileSync(logPath, 'utf-8').split('\n').filter(Boolean);
+      console.log('hook error log lines:', lines.length);
+    }
+
+    console.log('TASK-012 hook trigger test passed');
+  } catch (e) {
+    console.error('TASK-012 hook trigger test failed:', e.message);
+    if (serverOutput) console.error('--- server output ---');
+    if (serverOutput) console.error(serverOutput.slice(-2000));
+    process.exitCode = 1;
+  } finally {
+    // Cleanup
+    try { uninstallHook({ repoPath: FIXTURE_REPO }); } catch {}
+    rmrf(FIXTURE_REPO);
+    rmrf(path.join(ROOT, 'projects', SLUG));
+    try {
+      const projects = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+      if (projects[SLUG]) {
+        delete projects[SLUG];
+        fs.writeFileSync(PROJECTS_JSON, JSON.stringify(projects, null, 2) + '\n', 'utf-8');
+      }
+    } catch {}
+    try { fs.unlinkSync(JOBS_LOG); } catch {}
+    server.kill();
+  }
+})();

package/_site/_test/initial-analysis-test.js

@@ -0,0 +1,228 @@
+// TASK-007: Initial project analysis test
+// Run: node _site/_test/initial-analysis-test.js
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo } = require('./fixtures/make-git-repos');
+const {
+  runInitialAnalysis, readRun, listRuns, listDrafts,
+} = require('../lib/analysis-orchestrator');
+const { getAdapter } = require('../lib/ai-adapter');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const PORT = process.env.KB_INIT_TEST_PORT || '7797';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_SLUG = 'task-007-temp';
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+
+async function waitForServer() {
+  const deadline = Date.now() + 15000;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${BASE_URL}/api/state`);
+      if (res.ok) return;
+      lastError = new Error(`HTTP ${res.status}`);
+    } catch (e) { lastError = e; }
+    await new Promise(r => setTimeout(r, 250));
+  }
+  throw lastError || new Error('server did not start');
+}
+
+async function json(method, url, body) {
+  const res = await fetch(`${BASE_URL}${url}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : undefined,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let data = {};
+  if (text) { try { data = JSON.parse(text); } catch { data = { raw: text }; } }
+  return { res, data };
+}
+
+async function cleanup() {
+  const base = path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.rmSync(base, { recursive: true, force: true });
+  const cur = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+  if (cur[TEMP_SLUG]) {
+    delete cur[TEMP_SLUG];
+    fs.writeFileSync(PROJECTS_JSON, JSON.stringify(cur, null, 2) + '\n', 'utf-8');
+  }
+}
+
+(async () => {
+  assert(fs.existsSync(SERVER), 'server.js missing');
+  JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+
+  // 1. Unit: runInitialAnalysis on a v2-initialized fixture
+  const repo = makeRepo({ kind: 'multi-commit' });
+  const kbBase = path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.mkdirSync(kbBase, { recursive: true });
+  // Pre-existing KB files that must NOT be overwritten by the analysis
+  const existingGoal = '# Project Goal — PRESERVE-ME\n\npre-existing human goal text\n';
+  fs.writeFileSync(path.join(kbBase, 'project-goal.md'), existingGoal);
+
+  const project = {
+    slug: TEMP_SLUG,
+    kbPath: kbBase,
+    gitPath: repo.path,
+    localPath: repo.path,
+    aiProfileId: 'mock-agent',
+  };
+
+  let r = await runInitialAnalysis(project);
+  assert(r.ok, `initial analysis should succeed: ${r.error || ''}`);
+  assert(r.runRecord.status === 'succeeded', `run status should be succeeded, got ${r.runRecord.status}`);
+  assert(r.runRecord.aiProfileId === 'mock-agent', 'run should record aiProfileId');
+  assert(r.runRecord.drafts.length >= 2, 'run should have at least 2 drafts (goal + analysis)');
+
+  // 2. Drafts written to disk
+  const drafts = listDrafts(kbBase, r.runId);
+  assert(drafts.length >= 2, `drafts should be on disk, got ${drafts.length}`);
+  const goalDraft = drafts.find(d => d.path === 'project-goal.md');
+  assert(goalDraft, 'goal draft should exist');
+  const analysisDraft = drafts.find(d => d.path === 'project-analysis.md');
+  assert(analysisDraft, 'analysis draft should exist');
+
+  // 3. Draft contents
+  const goalText = fs.readFileSync(path.join(kbBase, '_ai', 'drafts', r.runId, 'project-goal.md'), 'utf-8');
+  assert(goalText.includes('One-Sentence Goal') || goalText.includes('oneSentenceGoal') || goalText.includes('AI Proposal'),
+    'goal draft should reference the AI proposal section');
+  const analysisText = fs.readFileSync(path.join(kbBase, '_ai', 'drafts', r.runId, 'project-analysis.md'), 'utf-8');
+  assert(analysisText.includes('AI Proposal') || analysisText.includes('AI-Inferred'), 'analysis draft should include AI proposal');
+
+  // 4. Pre-existing project-goal.md is preserved
+  const stillThere = fs.readFileSync(path.join(kbBase, 'project-goal.md'), 'utf-8');
+  assert(stillThere === existingGoal, 'pre-existing project-goal.md MUST NOT be overwritten by analysis');
+
+  // 5. Run metadata on disk
+  const run = readRun(kbBase, r.runId);
+  assert(run, 'run record should be readable');
+  assert(run.aiProfileId === 'mock-agent', 'run should record aiProfileId');
+  assert(run.finishedAt, 'run should have finishedAt');
+  assert(run.startedAt, 'run should have startedAt');
+  assert(Array.isArray(run.drafts), 'run should list drafts');
+  assert(Array.isArray(run.outputPaths) && run.outputPaths.length > 0, 'run should list outputPaths');
+  assert(run.contextPackPath, 'run should record contextPackPath');
+
+  // 6. runRecord.goalAccepted is false
+  assert(r.runRecord.goalAccepted === false, 'goalAccepted must default to false');
+
+  // 7. lastAnalyzedCommit was NOT advanced (project state must be untouched)
+  // Re-read projects.json to confirm the slug is still in place with no lastAnalyzedCommit
+  const cur = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+  // The orchestrator does not touch projects.json, so the temp slug may or may not be there yet.
+  // We focus on the run record.
+  assert(run.goalAccepted === false, 'run.goalAccepted should be false');
+
+  // 8. Language setting controls generated draft language markers.
+  const repoLang = makeRepo({ kind: 'one-commit' });
+  const kbZh = path.join(ROOT, 'projects', TEMP_SLUG + '-zh');
+  const kbEn = path.join(ROOT, 'projects', TEMP_SLUG + '-en');
+  fs.mkdirSync(kbZh, { recursive: true });
+  fs.mkdirSync(kbEn, { recursive: true });
+  let zhRun = await runInitialAnalysis({
+    slug: TEMP_SLUG + '-zh',
+    kbPath: kbZh,
+    gitPath: repoLang.path,
+    localPath: repoLang.path,
+    aiProfileId: 'mock-agent',
+    knowledgeLanguage: 'zh-CN',
+  });
+  assert(zhRun.ok, 'zh initial analysis should succeed');
+  let zhGoal = fs.readFileSync(path.join(kbZh, '_ai', 'drafts', zhRun.runId, 'project-goal.md'), 'utf-8');
+  assert(zhGoal.includes('AI 建议') && zhGoal.includes('一句话目标'), 'zh draft should use Chinese labels');
+  assert(zhRun.runRecord.knowledgeLanguage === 'zh-CN', 'zh run should record knowledgeLanguage');
+
+  let enRun = await runInitialAnalysis({
+    slug: TEMP_SLUG + '-en',
+    kbPath: kbEn,
+    gitPath: repoLang.path,
+    localPath: repoLang.path,
+    aiProfileId: 'mock-agent',
+    knowledgeLanguage: 'en-US',
+  });
+  assert(enRun.ok, 'en initial analysis should succeed');
+  let enGoal = fs.readFileSync(path.join(kbEn, '_ai', 'drafts', enRun.runId, 'project-goal.md'), 'utf-8');
+  assert(enGoal.includes('AI Proposal') && enGoal.includes('One-Sentence Goal'), 'en draft should use English labels');
+  assert(enRun.runRecord.knowledgeLanguage === 'en-US', 'en run should record knowledgeLanguage');
+  repoLang.cleanup();
+  fs.rmSync(kbZh, { recursive: true, force: true });
+  fs.rmSync(kbEn, { recursive: true, force: true });
+
+  repo.cleanup();
+  fs.rmSync(kbBase, { recursive: true, force: true });
+
+  // 9. Server tests
+  const child = spawn(process.execPath, [SERVER], {
+    cwd: ROOT,
+    env: { ...process.env, KB_SITE_PORT: PORT, KB_SITE_HOST: '127.0.0.1' },
+    stdio: ['ignore', 'pipe', 'pipe'],
+    windowsHide: true,
+  });
+  let serverOutput = '';
+  child.stdout.on('data', d => { serverOutput += d.toString(); });
+  child.stderr.on('data', d => { serverOutput += d.toString(); });
+
+  try {
+    await cleanup();
+    await waitForServer();
+
+    // 10. End-to-end: upsert, init, analyze
+    const repo2 = makeRepo({ kind: 'one-commit' });
+    const slug = TEMP_SLUG;
+    const kbPath = path.join(ROOT, 'projects', slug);
+    fs.mkdirSync(kbPath, { recursive: true });
+    fs.writeFileSync(path.join(kbPath, 'project-goal.md'), '# Goal — server\n');
+
+    r = await json('PUT', '/api/projects', {
+      slug,
+      config: { displayName: 'TASK-007', localPath: repo2.path, gitPath: repo2.path, kbPath },
+    });
+    assert(r.res.ok, 'upsert should succeed');
+
+    r = await json('POST', `/api/projects/${slug}/analyze/initial`, {});
+    assert(r.res.ok, `analyze initial should succeed: ${JSON.stringify(r.data)}`);
+    assert(r.data.runId, `should return runId: ${JSON.stringify(r.data)}`);
+    assert(r.data.run && r.data.run.status === 'succeeded', `run should be succeeded: ${JSON.stringify(r.data)}`);
+    const newRunId = r.data.runId;
+
+    // 11. List runs
+    r = await json('GET', `/api/projects/${slug}/runs`);
+    assert(r.res.ok, `list runs should succeed: ${JSON.stringify(r.data)}`);
+    assert(r.data.runs.length >= 1, `should have at least one run, got ${r.data.runs.length}`);
+    const listedIds = r.data.runs.map(x => x.runId);
+    assert(listedIds.includes(newRunId), `list should include the new run; newRunId=${newRunId} listed=${listedIds.join(',')}`);
+
+    // 12. Read run + drafts
+    r = await json('GET', `/api/projects/${slug}/runs/${newRunId}`);
+    assert(r.res.ok, `get run should succeed: ${JSON.stringify(r.data)}`);
+    assert(r.data.drafts.length >= 2, 'should have drafts');
+
+    // 13. List drafts separately
+    r = await json('GET', `/api/projects/${slug}/drafts/${newRunId}`);
+    assert(r.res.ok, `list drafts should succeed: ${JSON.stringify(r.data)}`);
+    assert(r.data.drafts.length >= 2, 'drafts should be listed');
+
+    // 14. Unknown adapter should 400
+    const cur2 = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+    cur2[slug].aiProfileId = 'nonexistent';
+    fs.writeFileSync(PROJECTS_JSON, JSON.stringify(cur2, null, 2) + '\n', 'utf-8');
+    r = await json('POST', `/api/projects/${slug}/analyze/initial`, {});
+    assert(!r.res.ok && r.res.status === 400, 'unknown adapter should 400');
+
+    repo2.cleanup();
+    console.log('TASK-007 initial analysis test passed');
+  } catch (e) {
+    console.error('TASK-007 initial analysis test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    await cleanup().catch(() => {});
+    child.kill();
+  }
+})();