project-knowledge 0.1.0

package/_site/server.js

@@ -0,0 +1,1058 @@
+// KB management site server — zero npm deps (Node built-ins only).
+// Run: node "D:\SanQian.Xu\project-knowledge-base\_site\server.js"
+// Listens on http://localhost:7777  (override with KB_SITE_PORT env)
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { spawn, exec } = require('child_process');
+const { getAdapter, listAdapters, validateInitialOutput, validateCommitBatchOutput } = require('./lib/ai-adapter');
+const { execGit } = require('./lib/git-runner');
+const { buildContextPack } = require('./lib/context-pack-builder');
+const { scanProject, applyScanResult } = require('./lib/scanner');
+const { runInitialAnalysis, runCommitAnalysis, readRun, listRuns, listDrafts } = require('./lib/analysis-orchestrator');
+const { applyDrafts, rejectDrafts, readDraftContent } = require('./lib/draft-apply');
+const { runJob, makeJob, readJobLog, KNOWN_MODES } = require('./lib/job-orchestrator');
+const { validateKb, buildPrContextPack } = require('./lib/kb-validator');
+const { installHook, uninstallHook, readHookStatus } = require('./lib/hook-manager');
+
+const KB_ROOT = path.resolve(__dirname, '..');
+const SITE_ROOT = __dirname;
+const PORT = parseInt(process.env.KB_SITE_PORT || '7777', 10);
+const HOST = process.env.KB_SITE_HOST || '127.0.0.1';
+const TASK_NAME = 'KB-GitCommits-Daily';
+const SCRIPT = 'D:\\SanQian.Xu\\project-knowledge-base\\scripts\\gen-commit-doc.ps1';
+const SAFE_RUNNER = 'D:\\SanQian.Xu\\project-knowledge-base\\_site\\scripts\\safe-runner.js';
+const PROJECT_SCHEMA_VERSION = 'v1';
+const DEFAULT_AI_PROFILE_ID = 'mock-agent';
+const DEFAULT_KNOWLEDGE_LANGUAGE = 'zh-CN';
+const AI_PROFILES_PATH = path.join(KB_ROOT, 'ai-profiles.json');
+const JOBS_LOG_PATH = path.join(KB_ROOT, '.jobs-log.json');
+
+// ---- state ----
+let lastRun = { time: null, status: null, slug: null, output: '' };
+const runningJobs = new Map();
+
+// Read a fresh copy of projects.json (re-loaded on every dispatch so that
+// background jobs see the latest registry state).
+function readProjectsForJob() {
+  return JSON.parse(fs.readFileSync(path.join(KB_ROOT, 'projects.json'), 'utf-8'));
+}
+
+// ---- helpers ----
+function send(res, status, body, type) {
+  type = type || 'application/json';
+  const text = typeof body === 'string' ? body : JSON.stringify(body, null, 2);
+  res.writeHead(status, {
+    'Content-Type': type + '; charset=utf-8',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type',
+    'Cache-Control': 'no-store',
+  });
+  res.end(text);
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    req.on('error', reject);
+  });
+}
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+
+function writeJson(p, obj) {
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + '\n', 'utf-8');
+}
+
+function isSafeSlug(s) { return typeof s === 'string' && /^[a-z0-9][a-z0-9-]{0,40}$/.test(s); }
+
+function normalizeKnowledgeLanguage(value) {
+  return value === 'en-US' ? 'en-US' : DEFAULT_KNOWLEDGE_LANGUAGE;
+}
+
+function defaultProjectKbPath(slug) {
+  return path.join(KB_ROOT, 'projects', slug);
+}
+
+function isLegacyKbPath(value) {
+  return typeof value === 'string' && /[\\/]SanQian\.Xu[\\/]kb[\\/]projects[\\/]/i.test(value);
+}
+
+// ---- AI profiles (TASK-005) ----
+function readAiProfiles() {
+  if (!fs.existsSync(AI_PROFILES_PATH)) {
+    return { schema: 'ai-profiles/v1', defaultProfileId: DEFAULT_AI_PROFILE_ID, profiles: listAdapters().map(a => ({
+      id: a.id, name: a.name, description: a.description, enabled: a.id !== 'claude-code-agent', implementation: a.id,
+    })) };
+  }
+  return JSON.parse(fs.readFileSync(AI_PROFILES_PATH, 'utf-8'));
+}
+
+function writeAiProfiles(cfg) {
+  writeJson(AI_PROFILES_PATH, cfg);
+}
+
+function validateProfileConfig(cfg) {
+  const errors = [];
+  if (!cfg || typeof cfg !== 'object') return ['not an object'];
+  if (cfg.schema !== 'ai-profiles/v1') errors.push('schema must be ai-profiles/v1');
+  if (!Array.isArray(cfg.profiles)) { errors.push('profiles must be an array'); return errors; }
+  const ids = new Set();
+  for (let i = 0; i < cfg.profiles.length; i++) {
+    const p = cfg.profiles[i];
+    if (!p.id) { errors.push(`profiles[${i}] missing id`); continue; }
+    if (ids.has(p.id)) errors.push(`duplicate id: ${p.id}`);
+    ids.add(p.id);
+    if (!getAdapter(p.id)) errors.push(`unknown adapter id: ${p.id}`);
+  }
+  if (cfg.defaultProfileId && !ids.has(cfg.defaultProfileId)) errors.push(`defaultProfileId not in profiles: ${cfg.defaultProfileId}`);
+  return errors;
+}
+
+function normalizeProjectConfig(slug, input) {
+  const source = input && typeof input === 'object' ? input : {};
+  const before = JSON.stringify(source);
+  const cfg = { ...source };
+
+  cfg.displayName = cfg.displayName || slug;
+  cfg.localPath = cfg.localPath || '';
+  cfg.gitPath = cfg.gitPath || cfg.localPath;
+  cfg.isReference = !!cfg.isReference;
+  cfg.primaryLanguage = cfg.primaryLanguage || '';
+  cfg.docConvention = cfg.docConvention || 'frontmatter-relations';
+
+  if (!Array.isArray(cfg.tags)) {
+    cfg.tags = typeof cfg.tags === 'string'
+      ? cfg.tags.split(',').map(s => s.trim()).filter(Boolean)
+      : [];
+  }
+
+  if (!cfg.kbPath || isLegacyKbPath(cfg.kbPath)) {
+    cfg.kbPath = defaultProjectKbPath(slug);
+  }
+
+  if (cfg.enabled == null) cfg.enabled = true;
+  if (!cfg.repoStatus) cfg.repoStatus = 'unknown';
+  if (!Object.prototype.hasOwnProperty.call(cfg, 'headCommit')) cfg.headCommit = null;
+  if (!Object.prototype.hasOwnProperty.call(cfg, 'lastSeenCommit')) cfg.lastSeenCommit = null;
+  if (!Object.prototype.hasOwnProperty.call(cfg, 'lastAnalyzedCommit')) cfg.lastAnalyzedCommit = null;
+  if (!cfg.aiProfileId) cfg.aiProfileId = DEFAULT_AI_PROFILE_ID;
+  cfg.knowledgeLanguage = normalizeKnowledgeLanguage(cfg.knowledgeLanguage);
+  if (!cfg.kbSchemaVersion) cfg.kbSchemaVersion = PROJECT_SCHEMA_VERSION;
+  if (!cfg.goalStatus) cfg.goalStatus = 'not-created';
+
+  return { config: cfg, changed: JSON.stringify(cfg) !== before };
+}
+
+function normalizeProjects(rawProjects) {
+  const out = {};
+  let changed = false;
+  for (const slug of Object.keys(rawProjects || {})) {
+    const result = normalizeProjectConfig(slug, rawProjects[slug]);
+    out[slug] = result.config;
+    changed = changed || result.changed;
+  }
+  return { projects: out, changed };
+}
+
+function readProjects(options = {}) {
+  const projectsPath = path.join(KB_ROOT, 'projects.json');
+  const rawProjects = readJson(projectsPath);
+  const result = normalizeProjects(rawProjects);
+  if (options.persistMigrations && result.changed) {
+    writeJson(projectsPath, result.projects);
+  }
+  return result.projects;
+}
+
+function listSubTree(root, prefix, depth, max) {
+  if (depth > max) return [];
+  const out = [];
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return out; }
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.name.startsWith('.')) continue;
+    if (entry.name === 'node_modules') continue;
+    const rel = prefix + entry.name;
+    if (entry.isDirectory()) {
+      const children = listSubTree(path.join(root, entry.name), rel + '/', depth + 1, max);
+      out.push({ type: 'dir', name: entry.name, path: rel, children });
+    } else {
+      let size = 0;
+      try { size = fs.statSync(path.join(root, entry.name)).size; } catch {}
+      out.push({ type: 'file', name: entry.name, path: rel, size });
+    }
+  }
+  return out;
+}
+
+function shellEscape(s) {
+  return '"' + String(s).replace(/"/g, '""').replace(/`/g, '``') + '"';
+}
+
+// ---- scanner (TASK-004): read-only commit range + state without invoking AI ----
+// (scanProject and applyScanResult now live in ./lib/scanner.js so the analysis
+// orchestrator can share the same code path.)
+
+async function scanAndPersistProject(slug, projects, options = {}) {
+  if (!projects[slug]) return { ok: false, status: 404, error: 'Slug not in projects.json' };
+  const scan = await scanProject({ slug, ...projects[slug] }, options);
+  applyScanResult(projects[slug], scan);
+  writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+  return { ok: true, slug, scan };
+}
+
+// ---- schedule (uses schtasks.exe directly to avoid PowerShell module load issues) ----
+function schtasksQuery() {
+  return new Promise((resolve) => {
+    // Force UTF-8 console output by setting code page 65001 first.
+    // The chcp message goes to stderr; the >nul redirects chcp's "Active code page" stdout message.
+    const cmd = `chcp 65001 >nul 2>&1 & schtasks /query /tn "${TASK_NAME}" /v /fo list`;
+    exec(cmd, { encoding: 'utf8', windowsHide: true, maxBuffer: 4 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) {
+        const msg = (stderr || '').toString().trim();
+        if (/the system cannot find/i.test(msg) || /cannot find the specified file/i.test(msg) || /指定的文件|找不到/i.test(msg)) {
+          return resolve({ registered: false, error: 'task not registered' });
+        }
+        return resolve({ registered: false, error: msg || err.message });
+      }
+      // Strip leading chcp echo line if present
+      let text = stdout;
+      const lines = text.split(/\r?\n/);
+      if (lines.length && !/^\s*\S+:.+/.test(lines[0])) {
+        lines.shift();
+        text = lines.join('\n');
+      }
+      // Parse "Key: Value" lines
+      const map = {};
+      text.split(/\r?\n/).forEach(line => {
+        const m = line.match(/^([^:]+):\s*(.*)$/);
+        if (m) {
+          const k = m[1].trim();
+          const v = m[2].trim();
+          if (k && v) map[k] = v;
+        }
+      });
+      if (Object.keys(map).length === 0) return resolve({ registered: false, error: 'empty output', raw: stdout.slice(0, 500) });
+      resolve({ registered: true, raw: map });
+    });
+  });
+}
+
+function getScheduleInfo() {
+  return schtasksQuery().then(r => {
+    if (!r.registered) return r;
+    const m = r.raw;
+    return {
+      registered: true,
+      hostName: m['HostName'] || m['主机名'] || '',
+      taskName: m['TaskName'] || m['任务名称'] || TASK_NAME,
+      nextRun: m['Next Run Time'] || m['下次运行时间'] || '',
+      lastRun: m['Last Run Time'] || m['上次运行时间'] || '',
+      lastResult: m['Last Result'] || m['上次结果'] || '',
+      status: m['Status'] || m['状态'] || '',
+      scheduleType: m['Schedule Type'] || m['计划类型'] || '',
+      startTime: m['Start Time'] || m['开始时间'] || '',
+      runAsUser: m['Run As User'] || m['以用户身份运行'] || '',
+      raw: m,
+    };
+  });
+}
+
+function buildScheduleArgs(frequency, time, options = {}) {
+  // Default to the safe-runner (scan + analyze-commits; never apply).
+  // Callers can opt into the legacy PowerShell script for backward compatibility.
+  const useLegacy = options && options.runner === 'legacy';
+  const tr = useLegacy
+    ? `powershell -ExecutionPolicy Bypass -File "${SCRIPT}" -ProjectSlug ALL`
+    : `node "${SAFE_RUNNER}" --slug ALL`;
+  switch (frequency) {
+    case 'off':      return null;
+    case 'hourly':   return ['/create', '/tn', TASK_NAME, '/tr', tr, '/sc', 'hourly', '/f'];
+    case 'every6h':  return ['/create', '/tn', TASK_NAME, '/tr', tr, '/sc', 'hourly', '/mo', '6', '/f'];
+    case 'every12h': return ['/create', '/tn', TASK_NAME, '/tr', tr, '/sc', 'hourly', '/mo', '12', '/f'];
+    case 'daily':    return ['/create', '/tn', TASK_NAME, '/tr', tr, '/sc', 'daily', '/st', time || '08:00', '/f'];
+    case 'weekly':   return ['/create', '/tn', TASK_NAME, '/tr', tr, '/sc', 'weekly', '/d', 'MON', '/st', time || '08:00', '/f'];
+    default: throw new Error('Unknown frequency: ' + frequency);
+  }
+}
+
+function updateSchedule(frequency, time, options = {}) {
+  return new Promise((resolve) => {
+    // Always delete first
+    const del = spawn('schtasks', ['/delete', '/tn', TASK_NAME, '/f'], { windowsHide: true });
+    del.on('close', () => {
+      if (frequency === 'off') return resolve({ ok: true, mode: 'off' });
+      const args = buildScheduleArgs(frequency, time, options);
+      const p = spawn('schtasks', args, { windowsHide: true });
+      let out = '', err = '';
+      p.stdout.on('data', d => out += d);
+      p.stderr.on('data', d => err += d);
+      p.on('close', code => {
+        if (code !== 0) return resolve({ ok: false, error: (err || out).trim(), code });
+        resolve({ ok: true, mode: frequency, time: time || '08:00', runner: options.runner || 'safe' });
+      });
+      p.on('error', e => resolve({ ok: false, error: e.message }));
+    });
+    del.on('error', e => resolve({ ok: false, error: e.message }));
+  });
+}
+
+function startJob({ mode, slug }) {
+  if (!KNOWN_MODES.has(mode)) return { ok: false, status: 400, error: `unknown mode: ${mode}` };
+  const job = makeJob({ mode, slug: slug || 'ALL' });
+  runningJobs.set(job.jobId, job);
+  // Run the job in the background so the HTTP request returns immediately.
+  // The job orchestrator updates `job` in place; the route handler returns
+  // just the jobId so the UI can poll.
+  (async () => {
+    try {
+      const projects = readProjectsForJob();
+      await runJob({
+        job,
+        projects,
+        projectsPath: path.join(KB_ROOT, 'projects.json'),
+        jobsLogPath: JOBS_LOG_PATH,
+        writeProjects: () => writeJson(path.join(KB_ROOT, 'projects.json'), projects),
+      });
+    } catch (e) {
+      job.status = 'failed';
+      job.endTime = new Date().toISOString();
+      job.exitCode = 1;
+      job.output += `\n[dispatch error] ${e.message}\n${e.stack || ''}`;
+    } finally {
+      lastRun = { time: job.endTime, status: job.status, slug: job.slug, mode: job.mode, output: (job.output || '').slice(-6000) };
+      // Keep the live record for 10 minutes so the UI can poll completion.
+      setTimeout(() => runningJobs.delete(job.jobId), 10 * 60 * 1000);
+    }
+  })();
+  return { ok: true, jobId: job.jobId, mode: job.mode, slug: job.slug };
+}
+
+// ---- git inspector (TASK-002) ----
+// (execGit is now imported from ./lib/git-runner so the context-pack-builder can share it.)
+
+async function inspectGit(gitPath) {
+  const result = {
+    gitPath: gitPath || '',
+    repoStatus: 'unknown',
+    defaultBranch: null,
+    currentBranch: null,
+    headCommit: null,
+    remoteUrl: null,
+    error: null,
+  };
+  if (!gitPath) {
+    result.repoStatus = 'missing-path';
+    result.error = 'no git path configured';
+    return result;
+  }
+  if (!fs.existsSync(gitPath)) {
+    result.repoStatus = 'missing-path';
+    result.error = `path not found: ${gitPath}`;
+    return result;
+  }
+
+  const inside = await execGit(gitPath, ['rev-parse', '--is-inside-work-tree']);
+  if (!inside.ok || inside.stdout.trim() !== 'true') {
+    result.repoStatus = 'not-git';
+    result.error = 'not inside a git work tree';
+    return result;
+  }
+
+  const toplevel = await execGit(gitPath, ['rev-parse', '--show-toplevel']);
+  if (toplevel.ok) result.gitPath = toplevel.stdout.trim();
+
+  const head = await execGit(gitPath, ['rev-parse', 'HEAD']);
+  if (!head.ok) {
+    // Empty repo: rev-parse HEAD fails with "unknown revision"
+    const empty = await execGit(gitPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    if (empty.ok) {
+      result.currentBranch = (empty.stdout || '').trim() || null;
+    }
+    result.repoStatus = 'empty';
+    result.error = 'repository has no commits';
+    return result;
+  }
+  result.headCommit = head.stdout.trim() || null;
+
+  const branch = await execGit(gitPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (branch.ok) result.currentBranch = (branch.stdout || '').trim() || null;
+
+  const defaultRef = await execGit(gitPath, ['symbolic-ref', 'refs/remotes/origin/HEAD']);
+  if (defaultRef.ok) {
+    const ref = (defaultRef.stdout || '').trim();
+    const m = ref.match(/refs\/remotes\/origin\/(.+)$/);
+    if (m) result.defaultBranch = m[1];
+  }
+  if (!result.defaultBranch) {
+    // Fallback: detect by checking local branches that match origin/<name>
+    const branches = await execGit(gitPath, ['branch', '--list']);
+    if (branches.ok) {
+      const lines = (branches.stdout || '').split(/\r?\n/);
+      const mainLine = lines.find(l => /\bmain\b/.test(l)) || lines.find(l => /\bmaster\b/.test(l));
+      if (mainLine) {
+        result.defaultBranch = mainLine.replace(/^\*\s*/, '').trim();
+      }
+    }
+  }
+
+  const remote = await execGit(gitPath, ['remote', 'get-url', 'origin']);
+  if (remote.ok) result.remoteUrl = (remote.stdout || '').trim() || null;
+  else result.remoteUrl = null;
+
+  result.repoStatus = 'ok';
+  return result;
+}
+
+function applyGitInspection(project, inspection) {
+  project.repoStatus = inspection.repoStatus;
+  project.headCommit = inspection.headCommit;
+  project.currentBranch = inspection.currentBranch;
+  project.defaultBranch = inspection.defaultBranch;
+  project.remoteUrl = inspection.remoteUrl;
+  project.gitPath = inspection.gitPath || project.gitPath;
+  return project;
+}
+
+async function validateAndPersistProject(slug, projects) {
+  if (!projects[slug]) return { ok: false, status: 404, error: 'Slug not in projects.json' };
+  const cfg = projects[slug];
+  const targetPath = cfg.gitPath || cfg.localPath;
+  const inspection = await inspectGit(targetPath);
+  applyGitInspection(cfg, inspection);
+  writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+  return { ok: true, slug, inspection };
+}
+
+// ---- project init (create dir structure) ----
+const V2_DIRS = [
+  'architecture', 'modules', 'commits', 'operations', 'references',
+  'requirements', 'features', 'changes', 'quality',
+  '_ai/drafts', '_ai/runs', '_ai/context-packs',
+];
+
+function readTemplate(name) {
+  const p = path.join(KB_ROOT, 'templates', name);
+  if (!fs.existsSync(p)) return null;
+  return fs.readFileSync(p, 'utf-8');
+}
+
+function renderTemplate(content, vars) {
+  return content.replace(/__([A-Z_][A-Z0-9_]*)__/g, (_, key) => (key in vars ? String(vars[key]) : `__${key}__`));
+}
+
+function todayIso() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function initProjectDirs(slug) {
+  const base = path.join(KB_ROOT, 'projects', slug);
+  const created = [];
+  for (const sub of V2_DIRS) {
+    const p = path.join(base, sub);
+    if (!fs.existsSync(p)) { fs.mkdirSync(p, { recursive: true }); created.push(sub); }
+  }
+  const vars = {
+    PROJECT: slug,
+    SLUG: slug,
+    DATE: todayIso(),
+    AUTHOR: process.env.USERNAME || process.env.USER || 'unknown',
+    COMMIT: '0000000000000000000000000000000000000000',
+    SHORTCOMMIT: '0000000',
+    SUBJECT: 'initial',
+    TYPE: 'chore',
+    CLASSIFICATION: 'infrastructure',
+  };
+  const tplDir = path.join(KB_ROOT, 'templates');
+  const seeds = [
+    { rel: 'README.md',            tpl: 'project-readme.md' },
+    { rel: 'framework.md',         tpl: 'framework.md' },
+    { rel: 'project-goal.md',      tpl: 'project-goal.md' },
+    { rel: 'project-analysis.md',  tpl: 'project-analysis.md' },
+    { rel: 'kb-manifest.json',     tpl: 'kb-manifest.json' },
+    { rel: 'architecture/overview.md', tpl: null, fallback: `# Architecture — ${slug}\n` },
+    { rel: 'modules/00-index.md',  tpl: null, fallback: `# Modules — ${slug}\n\n(No modules yet)\n` },
+    { rel: 'commits/00-index.md',  tpl: 'index-header.md' },
+    { rel: 'features/00-index.md', tpl: null, fallback: `# Features — ${slug}\n\n(No features yet)\n` },
+    { rel: 'changes/00-index.md',  tpl: null, fallback: `# Changes — ${slug}\n\n(No analyzed changes yet)\n` },
+    { rel: 'quality/quality-review-rules.md', tpl: 'quality-review-rules.md' },
+    { rel: 'requirements/roadmap.md',          tpl: null, fallback: `# Roadmap — ${slug}\n` },
+    { rel: 'requirements/constraints.md',      tpl: null, fallback: `# Constraints — ${slug}\n` },
+    { rel: 'requirements/success-criteria.md', tpl: null, fallback: `# Success Criteria — ${slug}\n` },
+    { rel: 'references/source-map.md',         tpl: null, fallback: `# Source Map — ${slug}\n` },
+  ];
+  for (const { rel, tpl, fallback } of seeds) {
+    const target = path.join(base, rel);
+    if (fs.existsSync(target)) continue;
+    let content = fallback;
+    if (tpl) {
+      const tplPath = path.join(tplDir, tpl);
+      if (fs.existsSync(tplPath)) {
+        content = renderTemplate(fs.readFileSync(tplPath, 'utf-8'), vars);
+      } else if (fallback) {
+        content = fallback;
+      }
+    }
+    if (content != null) {
+      fs.writeFileSync(target, content, 'utf-8');
+      created.push(rel);
+    }
+  }
+  return { created, basePath: base };
+}
+
+// Idempotently add v2 layout to an existing project. Used by migration endpoint.
+function ensureV2Layout(slug) {
+  return initProjectDirs(slug);
+}
+
+// ---- routing ----
+const server = http.createServer(async (req, res) => {
+  try {
+    const url = new URL(req.url, 'http://x');
+    const p = url.pathname;
+    const m = req.method;
+
+    if (m === 'OPTIONS') {
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+      });
+      return res.end();
+    }
+
+    // Static
+    if (m === 'GET' && (p === '/' || p === '/index.html')) {
+      const html = fs.readFileSync(path.join(SITE_ROOT, 'index.html'), 'utf-8');
+      return send(res, 200, html, 'text/html');
+    }
+    if (m === 'GET' && p === '/favicon.ico') return send(res, 204, '');
+
+    // GET /api/state — aggregate (enriches projects with kbInitialized flag)
+    if (m === 'GET' && p === '/api/state') {
+      const projects = readProjects({ persistMigrations: true });
+      for (const slug of Object.keys(projects)) {
+        const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+        // Project is "KB-initialized" if the dir exists AND README.md is present
+        try {
+          const stat = fs.statSync(kbPath);
+          if (stat.isDirectory() && fs.existsSync(path.join(kbPath, 'README.md'))) {
+            projects[slug].kbInitialized = true;
+            // Count commits and modules
+            const commitsDir = path.join(kbPath, 'commits');
+            const modulesDir = path.join(kbPath, 'modules');
+            try { projects[slug].commitCount = fs.readdirSync(commitsDir).filter(f => f.endsWith('.md') && f !== '00-index.md').length; } catch {}
+            try { projects[slug].moduleCount = fs.readdirSync(modulesDir).filter(f => f.endsWith('.md') && f !== '00-index.md').length; } catch {}
+          } else {
+            projects[slug].kbInitialized = false;
+          }
+        } catch {
+          projects[slug].kbInitialized = false;
+        }
+      }
+      const schedule = await getScheduleInfo();
+      return send(res, 200, { projects, schedule, lastRun, kbRoot: KB_ROOT, projectSchemaVersion: PROJECT_SCHEMA_VERSION });
+    }
+
+    // GET /api/projects
+    if (m === 'GET' && p === '/api/projects') {
+      return send(res, 200, readProjects({ persistMigrations: true }));
+    }
+
+    // PUT /api/projects — replace or upsert one
+    if (m === 'PUT' && p === '/api/projects') {
+      const body = JSON.parse(await readBody(req));
+      const projects = readProjects({ persistMigrations: true });
+      if (body.slug && body.config) {
+        if (!isSafeSlug(body.slug)) return send(res, 400, { error: 'Invalid slug' });
+        if (typeof body.config !== 'object' || body.config === null) {
+          return send(res, 400, { error: 'Invalid config' });
+        }
+        projects[body.slug] = normalizeProjectConfig(body.slug, body.config).config;
+        // Auto-validate git on add/update — populates repoStatus, headCommit, etc.
+        const targetPath = projects[body.slug].gitPath || projects[body.slug].localPath;
+        const inspection = await inspectGit(targetPath);
+        applyGitInspection(projects[body.slug], inspection);
+        writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+        return send(res, 200, { ok: true, slug: body.slug, repoStatus: inspection.repoStatus });
+      }
+      if (body.projects && typeof body.projects === 'object') {
+        const normalized = normalizeProjects(body.projects).projects;
+        writeJson(path.join(KB_ROOT, 'projects.json'), normalized);
+        return send(res, 200, { ok: true });
+      }
+      return send(res, 400, { error: 'Need { slug, config } or { projects }' });
+    }
+
+    // POST /api/projects/:slug/init
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/init')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: true });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const result = initProjectDirs(slug);
+      // Mark project as v2 after init
+      projects[slug].kbSchemaVersion = 'v2';
+      writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+      return send(res, 200, { ok: true, ...result, kbSchemaVersion: 'v2' });
+    }
+
+    // POST /api/projects/:slug/migrate-v2 — add v2 layout to an existing project
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/migrate-v2')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: true });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const result = ensureV2Layout(slug);
+      projects[slug].kbSchemaVersion = 'v2';
+      writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+      return send(res, 200, { ok: true, ...result, kbSchemaVersion: 'v2' });
+    }
+
+    // POST /api/projects/:slug/validate-git
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/validate-git')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      const result = await validateAndPersistProject(slug, projects);
+      if (!result.ok) return send(res, result.status, { error: result.error });
+      return send(res, 200, { ok: true, slug, ...result.inspection });
+    }
+
+    // GET /api/projects/:slug/git-status (read-only inspection without writing)
+    if (m === 'GET' && p.startsWith('/api/projects/') && p.endsWith('/git-status')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const cfg = projects[slug];
+      const targetPath = cfg.gitPath || cfg.localPath;
+      const inspection = await inspectGit(targetPath);
+      return send(res, 200, { ok: true, slug, ...inspection });
+    }
+
+    // GET /api/projects/:slug/hook-status — read whether the post-commit hook is installed
+    if (m === 'GET' && p.startsWith('/api/projects/') && p.endsWith('/hook-status')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const cfg = projects[slug];
+      const repoPath = cfg.gitPath || cfg.localPath;
+      const status = readHookStatus({ repoPath });
+      return send(res, status.ok ? 200 : status.status || 500, { ok: true, slug, ...status });
+    }
+
+    // POST /api/projects/:slug/hook-install { overwrite?: boolean }
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/hook-install')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const cfg = projects[slug];
+      const repoPath = cfg.gitPath || cfg.localPath;
+      const body = JSON.parse(await readBody(req).catch(() => '{}'));
+      const overwrite = !!(body && body.overwrite);
+      const result = installHook({ repoPath, siteRoot: SITE_ROOT, host: HOST, port: PORT, overwrite });
+      return send(res, result.ok ? 200 : result.status || 500, { ok: !!result.ok, slug, ...result });
+    }
+
+    // POST /api/projects/:slug/hook-uninstall
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/hook-uninstall')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const cfg = projects[slug];
+      const repoPath = cfg.gitPath || cfg.localPath;
+      const result = uninstallHook({ repoPath });
+      return send(res, result.ok ? 200 : result.status || 500, { ok: !!result.ok, slug, ...result });
+    }
+
+    // POST /api/projects/:slug/scan — read-only scanner; updates headCommit + lastSeenCommit only
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/scan')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const body = await readBody(req).catch(() => '{}');
+      const parsed = (() => { try { return JSON.parse(body); } catch { return {}; } })();
+      const projects = readProjects({ persistMigrations: false });
+      const result = await scanAndPersistProject(slug, projects, { maxCommits: parsed.maxCommits || 200 });
+      if (!result.ok) return send(res, result.status, { error: result.error });
+      return send(res, 200, { ok: true, slug, ...result.scan });
+    }
+
+    // GET /api/projects/:slug/scan — read-only scan preview
+    if (m === 'GET' && p.startsWith('/api/projects/') && p.endsWith('/scan')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const scan = await scanProject({ slug, ...projects[slug] });
+      return send(res, 200, { ok: true, slug, ...scan });
+    }
+
+    // POST /api/scan-all — scan every enabled project
+    if (m === 'POST' && p === '/api/scan-all') {
+      const projects = readProjects({ persistMigrations: false });
+      const results = [];
+      for (const slug of Object.keys(projects)) {
+        if (projects[slug].enabled === false) continue;
+        const r = await scanAndPersistProject(slug, projects);
+        results.push({ slug, ok: r.ok, ...(r.ok ? r.scan : { error: r.error }) });
+      }
+      return send(res, 200, { ok: true, results });
+    }
+
+    // GET /api/ai-profiles — list configured profiles and available adapters
+    if (m === 'GET' && p === '/api/ai-profiles') {
+      const cfg = readAiProfiles();
+      return send(res, 200, { ok: true, config: cfg, adapters: listAdapters() });
+    }
+
+    // PUT /api/ai-profiles — replace the whole ai-profiles.json
+    if (m === 'PUT' && p === '/api/ai-profiles') {
+      const body = JSON.parse(await readBody(req));
+      const errors = validateProfileConfig(body);
+      if (errors.length) return send(res, 400, { ok: false, errors });
+      writeAiProfiles(body);
+      return send(res, 200, { ok: true });
+    }
+
+    // PUT /api/projects/:slug/ai-profile — set a project's AI profile
+    if (m === 'PUT' && p.startsWith('/api/projects/') && p.endsWith('/ai-profile')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const body = JSON.parse(await readBody(req));
+      if (!body.aiProfileId) return send(res, 400, { error: 'aiProfileId required' });
+      if (!getAdapter(body.aiProfileId)) return send(res, 400, { error: `unknown adapter: ${body.aiProfileId}` });
+      const projects = readProjects({ persistMigrations: true });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      projects[slug].aiProfileId = body.aiProfileId;
+      writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+      return send(res, 200, { ok: true, slug, aiProfileId: body.aiProfileId });
+    }
+
+    // PUT /api/projects/:slug/settings - set project-level AI and KB generation settings
+    if (m === 'PUT' && p.startsWith('/api/projects/') && p.endsWith('/settings')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const body = JSON.parse(await readBody(req));
+      const projects = readProjects({ persistMigrations: true });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+
+      if (body.aiProfileId != null) {
+        if (!body.aiProfileId) return send(res, 400, { error: 'aiProfileId required' });
+        if (!getAdapter(body.aiProfileId)) return send(res, 400, { error: `unknown adapter: ${body.aiProfileId}` });
+        projects[slug].aiProfileId = body.aiProfileId;
+      }
+
+      if (body.knowledgeLanguage != null) {
+        if (!['zh-CN', 'en-US'].includes(body.knowledgeLanguage)) {
+          return send(res, 400, { error: 'knowledgeLanguage must be zh-CN or en-US' });
+        }
+        projects[slug].knowledgeLanguage = body.knowledgeLanguage;
+      }
+
+      writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+      return send(res, 200, {
+        ok: true,
+        slug,
+        aiProfileId: projects[slug].aiProfileId,
+        knowledgeLanguage: projects[slug].knowledgeLanguage,
+      });
+    }
+
+    // POST /api/projects/:slug/context-pack — build a context pack (TASK-006)
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/context-pack')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const body = await readBody(req).catch(() => '{}');
+      const parsed = (() => { try { return JSON.parse(body); } catch { return {}; } })();
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const trigger = parsed.trigger === 'commits' ? 'commits' : 'initial';
+      let commits = [];
+      if (trigger === 'commits') {
+        const scan = await scanProject({ slug, ...projects[slug] }, { maxCommits: parsed.maxCommits || 200 });
+        commits = scan.commits;
+      }
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const pack = await buildContextPack({
+        project: { slug, ...projects[slug], kbPath },
+        runId: parsed.runId,
+        trigger,
+        commits,
+      });
+      return send(res, 200, { ok: true, slug, runId: pack.runId, entryCount: pack.entries.length, contextPack: pack });
+    }
+
+    // POST /api/projects/:slug/analyze/initial — run initial analysis (TASK-007)
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/analyze/initial')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const result = await runInitialAnalysis({ slug, ...projects[slug], kbPath });
+      if (!result.ok) {
+        return send(res, result.status, { ok: false, error: result.error, runId: result.runId, run: result.runRecord });
+      }
+      return send(res, 200, { ok: true, slug, runId: result.runId, run: result.runRecord });
+    }
+
+    // POST /api/projects/:slug/analyze/commits — run incremental commit analysis (TASK-008)
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/analyze/commits')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const result = await runCommitAnalysis({ slug, ...projects[slug], kbPath });
+      if (!result.ok) {
+        return send(res, result.status, { ok: false, error: result.error, runId: result.runId, run: result.runRecord });
+      }
+      return send(res, 200, { ok: true, slug, runId: result.runId, noop: !!result.noop, run: result.runRecord });
+    }
+
+    // GET /api/projects/:slug/runs — list run records
+    if (m === 'GET' && p.startsWith('/api/projects/') && p.endsWith('/runs')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      return send(res, 200, { ok: true, slug, runs: listRuns(kbPath) });
+    }
+
+    // GET /api/projects/:slug/runs/:runId — read a single run
+    if (m === 'GET' && p.match(/^\/api\/projects\/[a-z0-9-]+\/runs\/[A-Za-z0-9_-]+$/)) {
+      const parts = p.split('/');
+      const slug = parts[3];
+      const runId = parts[5];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const run = readRun(kbPath, runId);
+      if (!run) return send(res, 404, { error: 'run not found' });
+      return send(res, 200, { ok: true, slug, run, drafts: listDrafts(kbPath, runId) });
+    }
+
+    // GET /api/projects/:slug/drafts/:runId — list drafts in a run
+    if (m === 'GET' && p.match(/^\/api\/projects\/[a-z0-9-]+\/drafts\/[A-Za-z0-9_-]+$/)) {
+      const parts = p.split('/');
+      const slug = parts[3];
+      const runId = parts[5];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      return send(res, 200, { ok: true, slug, runId, drafts: listDrafts(kbPath, runId) });
+    }
+
+    // GET /api/projects/:slug/drafts/:runId/raw?path=... — read a single draft's text
+    if (m === 'GET' && p.match(/^\/api\/projects\/[a-z0-9-]+\/drafts\/[A-Za-z0-9_-]+\/raw$/)) {
+      const parts = p.split('/');
+      const slug = parts[3];
+      const runId = parts[5];
+      const rel = url.searchParams.get('path') || '';
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const text = readDraftContent(kbPath, runId, rel);
+      if (text == null) return send(res, 404, { error: 'draft not found' });
+      return send(res, 200, { ok: true, slug, runId, path: rel, content: text }, 'text/plain');
+    }
+
+    // POST /api/projects/:slug/drafts/:runId/apply — apply selected drafts to the KB (TASK-009)
+    if (m === 'POST' && p.match(/^\/api\/projects\/[a-z0-9-]+\/drafts\/[A-Za-z0-9_-]+\/apply$/)) {
+      const parts = p.split('/');
+      const slug = parts[3];
+      const runId = parts[5];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const body = await readBody(req).catch(() => '{}');
+      const parsed = (() => { try { return JSON.parse(body); } catch { return {}; } })();
+      if (!Array.isArray(parsed.drafts)) return send(res, 400, { error: 'drafts array required' });
+      // Default headCommitAtRun to the value recorded in the run record so callers
+      // can just POST {drafts, allowGoalEdit} and have lastAnalyzedCommit advance correctly.
+      const runRecord = readRun(kbPath, runId);
+      const headCommitAtRun = parsed.headCommitAtRun || (runRecord && runRecord.headCommitAtRun) || null;
+      const result = applyDrafts({
+        kbPath,
+        slug,
+        runId,
+        drafts: parsed.drafts,
+        allowGoalEdit: !!parsed.allowGoalEdit,
+        headCommitAtRun,
+      });
+      if (!result.ok) return send(res, result.status, { ok: false, error: result.error, ...result });
+      // On successful apply, advance the project's lastAnalyzedCommit to the run's head commit
+      if (headCommitAtRun) {
+        projects[slug].lastAnalyzedCommit = headCommitAtRun;
+        writeJson(path.join(KB_ROOT, 'projects.json'), projects);
+      }
+      return send(res, 200, { ok: true, ...result });
+    }
+
+    // POST /api/projects/:slug/validate-kb — validate KB contract (TASK-011)
+    if (m === 'POST' && p.startsWith('/api/projects/') && p.endsWith('/validate-kb')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const result = validateKb(kbPath);
+      return send(res, result.status, { ok: result.ok, ...result });
+    }
+
+    // GET /api/projects/:slug/pr-context — build a PR consumer context pack (TASK-011)
+    if (m === 'GET' && p.startsWith('/api/projects/') && p.endsWith('/pr-context')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const result = buildPrContextPack(kbPath);
+      return send(res, result.status || (result.ok ? 200 : 422), { ok: result.ok, ...result });
+    }
+
+    // POST /api/projects/:slug/drafts/:runId/reject — reject all drafts in a run (TASK-009)
+    if (m === 'POST' && p.match(/^\/api\/projects\/[a-z0-9-]+\/drafts\/[A-Za-z0-9_-]+\/reject$/)) {
+      const parts = p.split('/');
+      const slug = parts[3];
+      const runId = parts[5];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const projects = readProjects({ persistMigrations: false });
+      if (!projects[slug]) return send(res, 404, { error: 'Slug not in projects.json' });
+      const kbPath = projects[slug].kbPath || defaultProjectKbPath(slug);
+      const body = await readBody(req).catch(() => '{}');
+      const parsed = (() => { try { return JSON.parse(body); } catch { return {}; } })();
+      const result = rejectDrafts({ kbPath, runId, reason: parsed.reason });
+      if (!result.ok) return send(res, result.status, result);
+      return send(res, 200, { ok: true, ...result });
+    }
+
+    // GET /api/schedule
+    if (m === 'GET' && p === '/api/schedule') {
+      return send(res, 200, await getScheduleInfo());
+    }
+
+    // PUT /api/schedule  { frequency, time?, runner? }
+    if (m === 'PUT' && p === '/api/schedule') {
+      const body = JSON.parse(await readBody(req));
+      if (!body.frequency) return send(res, 400, { error: 'frequency required' });
+      const result = await updateSchedule(body.frequency, body.time, { runner: body.runner });
+      return send(res, 200, result);
+    }
+
+    // POST /api/jobs/run — run a job in one of the supported modes (TASK-010)
+    if (m === 'POST' && p === '/api/jobs/run') {
+      const body = await readBody(req).catch(() => '{}');
+      const parsed = (() => { try { return JSON.parse(body); } catch { return {}; } })();
+      const mode = parsed.mode || 'legacy';
+      const slug = parsed.slug || 'ALL';
+      const result = startJob({ mode, slug });
+      if (!result.ok) return send(res, result.status, result);
+      return send(res, 200, result);
+    }
+
+    // GET /api/jobs — recent job history (persisted to .jobs-log.json)
+    if (m === 'GET' && p === '/api/jobs') {
+      const history = readJobLog(JOBS_LOG_PATH);
+      return send(res, 200, {
+        ok: true,
+        history,
+        running: [...runningJobs.values()].map(j => ({
+          jobId: j.jobId, mode: j.mode, slug: j.slug, status: j.status,
+          startTime: j.startTime, endTime: j.endTime,
+        })),
+        knownModes: [...KNOWN_MODES],
+        lastRun,
+      });
+    }
+
+    // GET /api/jobs/:jobId — read a single job (live or persisted)
+    if (m === 'GET' && p.match(/^\/api\/jobs\/job-[0-9]+-[0-9]+$/)) {
+      const jobId = p.split('/')[3];
+      const live = runningJobs.get(jobId);
+      if (live) {
+        return send(res, 200, {
+          ok: true, job: {
+            jobId: live.jobId, mode: live.mode, slug: live.slug,
+            status: live.status, startTime: live.startTime, endTime: live.endTime,
+            exitCode: live.exitCode, summary: live.summary,
+            output: (live.output || '').slice(-6000),
+          }
+        });
+      }
+      const history = readJobLog(JOBS_LOG_PATH);
+      const persisted = history.find(j => j.jobId === jobId);
+      if (!persisted) return send(res, 404, { error: 'job not found' });
+      return send(res, 200, { ok: true, job: persisted });
+    }
+
+    // POST /api/script/run — backward-compat alias for /api/jobs/run with mode=legacy
+    if (m === 'POST' && p === '/api/script/run') {
+      const body = await readBody(req).catch(() => '{}');
+      const parsed = (() => { try { return JSON.parse(body); } catch { return {}; } })();
+      const mode = parsed.mode || 'legacy';
+      const slug = parsed.slug || 'ALL';
+      const result = startJob({ mode, slug });
+      if (!result.ok) return send(res, result.status, result);
+      return send(res, 200, result);
+    }
+
+    // GET /api/script/status — backward-compat alias
+    if (m === 'GET' && p === '/api/script/status') {
+      return send(res, 200, { lastRun, running: [...runningJobs.values()] });
+    }
+
+    // GET /api/dirs/:slug
+    if (m === 'GET' && p.startsWith('/api/dirs/')) {
+      const slug = p.split('/')[3];
+      if (!isSafeSlug(slug)) return send(res, 400, { error: 'Invalid slug' });
+      const kbPath = path.join(KB_ROOT, 'projects', slug);
+      if (!fs.existsSync(kbPath)) return send(res, 404, { error: 'Project KB not initialized' });
+      return send(res, 200, listSubTree(kbPath, '', 0, 3));
+    }
+
+    // GET /api/raw?path=relative  (read a markdown file under projects/)
+    if (m === 'GET' && p === '/api/raw') {
+      const rel = url.searchParams.get('path');
+      if (!rel) return send(res, 400, { error: 'path required' });
+      const abs = path.resolve(KB_ROOT, rel);
+      if (!abs.startsWith(KB_ROOT)) return send(res, 403, { error: 'outside kb root' });
+      if (!fs.existsSync(abs)) return send(res, 404, { error: 'not found' });
+      const stat = fs.statSync(abs);
+      if (stat.isDirectory()) {
+        const tree = listSubTree(abs, rel.replace(/\\/g, '/') + '/', 0, 4);
+        return send(res, 200, { type: 'dir', tree });
+      }
+      const buf = fs.readFileSync(abs);
+      return send(res, 200, { type: 'file', content: buf.toString('utf-8'), size: stat.size }, 'text/plain');
+    }
+
+    send(res, 404, { error: 'Not found', path: p });
+  } catch (e) {
+    console.error('[server error]', e);
+    send(res, 500, { error: e.message, stack: e.stack });
+  }
+});
+
+server.listen(PORT, HOST, () => {
+  console.log(`[kb-site] listening on http://${HOST}:${PORT}`);
+  console.log(`[kb-site] KB root: ${KB_ROOT}`);
+  console.log(`[kb-site] task:    ${TASK_NAME}`);
+});