project-knowledge 0.1.0 → 1.0.0

package/_site/_test/kb-v2-templates-test.js

@@ -1,4 +1,4 @@
-// TASK-003: KB v2 templates test
+// TASK-003/TASK-020: KB template compatibility test
 // Run: node _site/_test/kb-v2-templates-test.js
 const fs = require('fs');
 const path = require('path');
@@ -35,6 +35,9 @@ const REQUIRED_V2_FILES = [
   'references/source-map.md',
 ];
 
+const REQUIRED_V3_TOP_LEVEL = ['ARCHITECTURE.md', 'GOAL.md', 'README.md', 'changes', 'modules'];
+const REQUIRED_V3_FILES = ['README.md', 'GOAL.md', 'ARCHITECTURE.md', 'modules/00-index.md', 'changes/00-index.md'];
+
 function assert(cond, msg) { if (!cond) throw new Error(msg); }
 
 async function waitForServer() {
@@ -64,9 +67,9 @@ async function json(method, url, body) {
 }
 
 async function cleanupTemp() {
-  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'));
+  const base = cur[TEMP_SLUG] && cur[TEMP_SLUG].kbPath || path.join(ROOT, 'projects', TEMP_SLUG);
+  fs.rmSync(base, { recursive: true, force: true });
   if (cur[TEMP_SLUG]) {
     delete cur[TEMP_SLUG];
     fs.writeFileSync(PROJECTS_JSON, JSON.stringify(cur, null, 2) + '\n', 'utf-8');
@@ -104,51 +107,36 @@ async function cleanupTemp() {
 
     r = await json('POST', `/api/projects/${TEMP_SLUG}/init`);
     assert(r.res.ok, 'init should succeed');
-    assert(r.data.kbSchemaVersion === 'v2', `init should set schema v2, got ${r.data.kbSchemaVersion}`);
+    assert(r.data.kbSchemaVersion === 'v3', `init should set schema v3, got ${r.data.kbSchemaVersion}`);
 
-    const base = path.join(ROOT, 'projects', TEMP_SLUG);
-    for (const sub of REQUIRED_V2_DIRS) {
-      const p = path.join(base, sub);
-      assert(fs.existsSync(p) && fs.statSync(p).isDirectory(), `missing dir: ${sub}`);
-    }
-    for (const rel of REQUIRED_V2_FILES) {
+    const savedProjects = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+    const base = savedProjects[TEMP_SLUG].kbPath;
+    const topLevel = fs.readdirSync(base).filter(name => !name.startsWith('.')).sort();
+    assert(JSON.stringify(topLevel) === JSON.stringify(REQUIRED_V3_TOP_LEVEL), `v3 top-level mismatch: ${topLevel.join(', ')}`);
+    for (const rel of REQUIRED_V3_FILES) {
       const p = path.join(base, rel);
-      assert(fs.existsSync(p), `missing file: ${rel}`);
+      assert(fs.existsSync(p), `missing v3 file: ${rel}`);
     }
-
-    // 2. Manifest parses and points to existing files
-    const manifestPath = path.join(base, 'kb-manifest.json');
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-    assert(manifest.schema === 'kb-manifest/v1', 'manifest schema should be v1');
-    assert(manifest.project === TEMP_SLUG, 'manifest project should match');
-    assert(manifest.goal.path === 'project-goal.md', 'manifest should point at project-goal.md');
-    assert(Array.isArray(manifest.trustedKnowledge) && manifest.trustedKnowledge.length > 0, 'trustedKnowledge should be non-empty');
-    for (const tpath of [manifest.goal.path, manifest.analysis.path, ...manifest.indexes ? Object.values(manifest.indexes) : []]) {
-      const full = path.join(base, tpath);
-      assert(fs.existsSync(full), `manifest should not point to missing file: ${tpath}`);
-    }
-    for (const trusted of manifest.trustedKnowledge) {
-      const full = path.join(base, trusted);
-      assert(fs.existsSync(full), `trusted entry should exist: ${trusted}`);
-    }
-
-    // 3. Templates rendered with project name
-    const goal = fs.readFileSync(path.join(base, 'project-goal.md'), 'utf-8');
-    assert(goal.includes(TEMP_SLUG), 'project-goal should contain project name');
-    assert(goal.includes('TODO'), 'project-goal should still have TODO placeholders');
-    const analysis = fs.readFileSync(path.join(base, 'project-analysis.md'), 'utf-8');
-    assert(analysis.includes(TEMP_SLUG), 'project-analysis should contain project name');
-    const feature = fs.readFileSync(path.join(base, 'features/00-index.md'), 'utf-8');
-    assert(feature.includes('Features'), 'features index should be created');
-
-    // 4. Idempotent re-init
-    const before = fs.readFileSync(manifestPath, 'utf-8');
+    assert(!fs.existsSync(path.join(base, 'kb-manifest.json')), 'v3 init should not create manifest');
+    assert(!fs.existsSync(path.join(base, '_ai')), 'v3 init should not create _ai inside KB');
+
+    // 2. Templates rendered with project name
+    const goal = fs.readFileSync(path.join(base, 'GOAL.md'), 'utf-8');
+    assert(goal.includes(TEMP_SLUG), 'GOAL should contain project name');
+    assert(goal.includes('TODO'), 'GOAL should still have TODO placeholders');
+    const analysis = fs.readFileSync(path.join(base, 'ARCHITECTURE.md'), 'utf-8');
+    assert(analysis.includes(TEMP_SLUG), 'ARCHITECTURE should contain project name');
+    const modulesIndex = fs.readFileSync(path.join(base, 'modules', '00-index.md'), 'utf-8');
+    assert(modulesIndex.includes('Modules'), 'modules index should be created');
+
+    // 3. Idempotent re-init
+    const before = fs.readFileSync(path.join(base, 'GOAL.md'), 'utf-8');
     r = await json('POST', `/api/projects/${TEMP_SLUG}/init`);
     assert(r.res.ok, 're-init should succeed');
-    const after = fs.readFileSync(manifestPath, 'utf-8');
-    assert(before === after, 're-init should not rewrite manifest');
+    const after = fs.readFileSync(path.join(base, 'GOAL.md'), 'utf-8');
+    assert(before === after, 're-init should not rewrite GOAL');
 
-    // 5. Legacy commits/ is preserved when migrating an existing v1 project
+    // 4. Legacy commits/ is preserved when migrating an existing v1 project to v2
     const legacySlug = 'task-003-legacy';
     const legacyBase = path.join(ROOT, 'projects', legacySlug);
     fs.mkdirSync(path.join(legacyBase, 'commits'), { recursive: true });
@@ -158,7 +146,7 @@ async function cleanupTemp() {
     fs.mkdirSync(path.join(legacyBase, 'modules'), { recursive: true });
     fs.writeFileSync(path.join(legacyBase, 'modules', 'foo.md'), 'legacy module\n');
 
-    r = await json('PUT', '/api/projects', { slug: legacySlug, config: { displayName: 'legacy' } });
+    r = await json('PUT', '/api/projects', { slug: legacySlug, config: { displayName: 'legacy', kbPath: legacyBase } });
     assert(r.res.ok, 'legacy upsert should succeed');
     r = await json('POST', `/api/projects/${legacySlug}/migrate-v2`);
     assert(r.res.ok, 'migrate-v2 should succeed');

package/_site/_test/knowledge-store-logs-supervision-test.js

@@ -0,0 +1,143 @@
+// Run: node _site/_test/knowledge-store-logs-supervision-test.js
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo } = require('./fixtures/make-git-repos');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const KNOWLEDGE_STORE_JSON = path.join(ROOT, 'knowledge-store.json');
+const LOGGING_JSON = path.join(ROOT, 'logging.json');
+const PORT = process.env.KB_TASK_012_013_TEST_PORT || '7814';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_SLUG = 'task-012-013-temp';
+const TEMP_ROOT = path.join(ROOT, '.tmp-task-012-013');
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+
+function backup(file) {
+  return fs.existsSync(file) ? fs.readFileSync(file, 'utf-8') : null;
+}
+
+function restore(file, content) {
+  if (content == null) fs.rmSync(file, { force: true });
+  else fs.writeFileSync(file, content, 'utf-8');
+}
+
+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(resolve => setTimeout(resolve, 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 () => {
+  const projectsBackup = backup(PROJECTS_JSON);
+  const storeBackup = backup(KNOWLEDGE_STORE_JSON);
+  const loggingBackup = backup(LOGGING_JSON);
+  fs.rmSync(TEMP_ROOT, { recursive: true, force: true });
+  fs.mkdirSync(TEMP_ROOT, { recursive: true });
+
+  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 = '';
+  let repo = null;
+  child.stdout.on('data', d => { serverOutput += d.toString(); });
+  child.stderr.on('data', d => { serverOutput += d.toString(); });
+
+  try {
+    await waitForServer();
+
+    const storeRoot = path.join(TEMP_ROOT, 'kb-store');
+    let r = await json('PUT', '/api/knowledge-store/config', {
+      rootPath: storeRoot,
+      git: { enabled: true, remoteUrl: 'https://example.invalid/kb.git', branch: 'main' },
+    });
+    assert(r.res.ok, 'knowledge store config save should succeed');
+    assert(r.data.config.rootPath === path.resolve(storeRoot), 'knowledge store root should persist');
+
+    repo = makeRepo({ kind: 'multi-commit' });
+    r = await json('PUT', '/api/projects', {
+      slug: TEMP_SLUG,
+      config: {
+        displayName: 'TASK 012 013 Temp',
+        localPath: repo.path,
+        gitPath: repo.path,
+        enabled: true,
+      },
+    });
+    assert(r.res.ok, 'project import should succeed');
+
+    r = await json('GET', '/api/projects');
+    assert(r.data[TEMP_SLUG].kbPath === path.join(storeRoot, TEMP_SLUG), 'new project should use configured knowledge store root');
+
+    r = await json('POST', `/api/projects/${TEMP_SLUG}/init`);
+    assert(r.res.ok, 'project init should succeed');
+    assert(fs.existsSync(path.join(storeRoot, TEMP_SLUG, 'README.md')), 'KB README should be created in external store');
+
+    const logRoot = path.join(TEMP_ROOT, 'logs');
+    r = await json('PUT', '/api/logging/config', {
+      rootPath: logRoot,
+      retentionDays: 7,
+      levels: ['info', 'warn', 'error'],
+    });
+    assert(r.res.ok, 'logging config save should succeed');
+    assert(fs.readdirSync(logRoot).some(file => file.endsWith('.log')), 'logging config update should write a daily .log file');
+
+    r = await json('GET', '/api/logs?level=info&q=logging_config_updated');
+    assert(r.res.ok, 'log query should succeed');
+    assert((r.data.logs || []).some(log => log.event === 'logging_config_updated'), 'log query should find logging_config_updated');
+
+    r = await json('GET', '/api/supervision/pending-commits');
+    assert(r.res.ok, 'pending commits endpoint should succeed');
+    const pendingItem = (r.data.items || []).find(item => item.slug === TEMP_SLUG);
+    assert(pendingItem, 'pending commits should include temp project');
+    assert(pendingItem.pendingCount >= 1, 'temp project should have pending commits before analysis');
+
+    r = await json('GET', '/api/supervision/issues');
+    assert(r.res.ok, 'issues endpoint should succeed');
+    assert(Array.isArray(r.data.issues), 'issues should be an array');
+
+    r = await json('POST', '/api/knowledge-store/migrate', { execute: false });
+    assert(r.res.ok, 'migration preview should succeed');
+    assert(Array.isArray(r.data.plan), 'migration preview should return plan');
+
+    console.log('TASK-012/TASK-013 knowledge store, logs, supervision test passed');
+  } catch (e) {
+    console.error('TASK-012/TASK-013 test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    child.kill();
+    try { if (typeof repo !== 'undefined' && repo.cleanup) repo.cleanup(); } catch {}
+    restore(PROJECTS_JSON, projectsBackup);
+    restore(KNOWLEDGE_STORE_JSON, storeBackup);
+    restore(LOGGING_JSON, loggingBackup);
+    fs.rmSync(TEMP_ROOT, { recursive: true, force: true });
+  }
+})();

package/_site/_test/project-control-panel-task14-test.js

@@ -0,0 +1,151 @@
+// Run: node _site/_test/project-control-panel-task14-test.js
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo, git } = require('./fixtures/make-git-repos');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const KNOWLEDGE_STORE_JSON = path.join(ROOT, 'knowledge-store.json');
+const PORT = process.env.KB_TASK14_TEST_PORT || '7815';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_SLUG = 'task-014-temp';
+const TEMP_ROOT = path.join(ROOT, '.tmp-task-014');
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+function backup(file) { return fs.existsSync(file) ? fs.readFileSync(file, 'utf-8') : null; }
+function restore(file, content) {
+  if (content == null) fs.rmSync(file, { force: true });
+  else fs.writeFileSync(file, content, 'utf-8');
+}
+
+async function rmWithRetry(target) {
+  for (let i = 0; i < 8; i++) {
+    try {
+      fs.rmSync(target, { recursive: true, force: true });
+      return;
+    } catch (e) {
+      if (i === 7) throw e;
+      await new Promise(resolve => setTimeout(resolve, 250));
+    }
+  }
+}
+
+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(resolve => setTimeout(resolve, 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 () => {
+  const projectsBackup = backup(PROJECTS_JSON);
+  const storeBackup = backup(KNOWLEDGE_STORE_JSON);
+  fs.rmSync(TEMP_ROOT, { recursive: true, force: true });
+  fs.mkdirSync(TEMP_ROOT, { recursive: true });
+  let repo = null;
+  let nonGit = null;
+
+  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 waitForServer();
+
+    const storeRoot = path.join(TEMP_ROOT, 'kb-store');
+    let r = await json('PUT', '/api/knowledge-store/config', { rootPath: storeRoot });
+    assert(r.res.ok, 'knowledge store config should save');
+
+    repo = makeRepo({ kind: 'multi-commit' });
+    r = await json('POST', '/api/projects/import-preflight', { localPath: repo.path });
+    assert(r.res.ok, 'preflight existing git should succeed');
+    assert(r.data.inspection.repoStatus === 'ok', 'existing git repo should be ok');
+    assert(r.data.needsGitInit === false, 'existing git should not need init');
+
+    nonGit = makeRepo({ kind: 'not-git' });
+    r = await json('POST', '/api/projects/import-preflight', { localPath: nonGit.path });
+    assert(r.res.ok, 'preflight non-git should return actionable result');
+    assert(r.data.needsGitInit === true, 'non-git should need git init');
+
+    r = await json('POST', '/api/projects/import-preflight', { localPath: path.join(TEMP_ROOT, 'missing') });
+    assert(!r.res.ok, 'preflight missing path should fail');
+
+    r = await json('POST', '/api/git/init', {
+      path: nonGit.path,
+      createInitialCommit: true,
+      remoteUrl: 'https://example.invalid/task-014.git',
+    });
+    assert(r.res.ok, 'git init should succeed');
+    assert(r.data.initialCommit === true, 'initial commit should be created');
+    assert(r.data.remoteConfigured === true, 'remote should be configured');
+    assert(git(nonGit.path, 'rev-parse --is-inside-work-tree') === 'true', 'non-git dir should now be git');
+    assert(git(nonGit.path, 'remote get-url origin') === 'https://example.invalid/task-014.git', 'remote origin should be set');
+
+    const firstCommit = repo.commits[repo.commits.length - 1].hash;
+    r = await json('PUT', '/api/projects', {
+      slug: TEMP_SLUG,
+      config: {
+        displayName: 'TASK 014 Temp',
+        localPath: repo.path,
+        gitPath: repo.path,
+        enabled: true,
+        aiProfileId: 'mock-agent',
+        goalStatus: 'accepted',
+        lastAnalyzedCommit: firstCommit,
+      },
+    });
+    assert(r.res.ok, 'project import should succeed');
+    r = await json('POST', `/api/projects/${TEMP_SLUG}/init`);
+    assert(r.res.ok, 'KB init should succeed');
+
+    r = await json('POST', `/api/projects/${TEMP_SLUG}/knowledge-update`, {});
+    assert(r.res.ok, `knowledge update should succeed: ${r.data.error || ''}`);
+    assert(r.data.scan && r.data.scan.pendingCount >= 1, 'knowledge update should scan pending commits');
+    assert(r.data.analysis && r.data.analysis.ok, 'knowledge update should run analysis');
+    assert(r.data.applyResult && r.data.applyResult.ok, 'safe commit drafts should auto-apply');
+
+    r = await json('GET', '/api/projects');
+    assert(r.data[TEMP_SLUG].lastAnalyzedCommit === repo.headCommit, 'lastAnalyzedCommit should advance to HEAD');
+
+    console.log('TASK-014 project control panel simplification test passed');
+  } catch (e) {
+    console.error('TASK-014 test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    child.kill();
+    await new Promise(r => setTimeout(r, 500));
+    try { if (repo && repo.cleanup) repo.cleanup(); } catch {}
+    try { if (nonGit && nonGit.cleanup) nonGit.cleanup(); } catch {}
+    restore(PROJECTS_JSON, projectsBackup);
+    restore(KNOWLEDGE_STORE_JSON, storeBackup);
+    await rmWithRetry(TEMP_ROOT);
+  }
+})();

package/_site/_test/task15-20-integration-test.js

@@ -0,0 +1,194 @@
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { makeRepo } = require('./fixtures/make-git-repos');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const SERVER = path.join(ROOT, '_site', 'server.js');
+const PROJECTS_JSON = path.join(ROOT, 'projects.json');
+const KNOWLEDGE_STORE_JSON = path.join(ROOT, 'knowledge-store.json');
+const LOGGING_JSON = path.join(ROOT, 'logging.json');
+const PORT = process.env.KB_TASK_15_20_PORT || '7820';
+const BASE_URL = `http://127.0.0.1:${PORT}`;
+const TEMP_ROOT = path.join(ROOT, '.tmp-task-15-20');
+const SLUG = 'task-015-020-temp';
+const LEGACY_SLUG = 'task-020-legacy-temp';
+
+function assert(cond, msg) { if (!cond) throw new Error(msg); }
+function backup(file) { return fs.existsSync(file) ? fs.readFileSync(file, 'utf-8') : null; }
+function restore(file, content) {
+  if (content == null) fs.rmSync(file, { force: true });
+  else fs.writeFileSync(file, content, 'utf-8');
+}
+async function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }
+async function rmWithRetry(target) {
+  for (let i = 0; i < 8; i++) {
+    try { fs.rmSync(target, { recursive: true, force: true }); return; }
+    catch (e) { if (i === 7) throw e; await sleep(250); }
+  }
+}
+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 sleep(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 () => {
+  const projectsBackup = backup(PROJECTS_JSON);
+  const storeBackup = backup(KNOWLEDGE_STORE_JSON);
+  const loggingBackup = backup(LOGGING_JSON);
+  fs.rmSync(TEMP_ROOT, { recursive: true, force: true });
+  fs.mkdirSync(TEMP_ROOT, { recursive: true });
+  const kbRoot = path.join(TEMP_ROOT, 'knowledge');
+  const logsRoot = path.join(TEMP_ROOT, 'logs');
+  const aiRoot = path.join(ROOT, '_site', '_ai');
+  fs.rmSync(path.join(aiRoot, SLUG), { recursive: true, force: true });
+  fs.rmSync(path.join(aiRoot, LEGACY_SLUG), { recursive: true, force: true });
+
+  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(); });
+
+  let repo = null;
+  try {
+    await waitForServer();
+    let r = await json('PUT', '/api/knowledge-store/config', { rootPath: kbRoot, git: { enabled: false } });
+    assert(r.res.ok, 'knowledge-store config should save');
+    r = await json('PUT', '/api/logging/config', { rootPath: logsRoot, retentionDays: 14 });
+    assert(r.res.ok, 'logging config should save');
+
+    repo = makeRepo({ kind: 'feature-commit' });
+    r = await json('PUT', '/api/projects', {
+      slug: SLUG,
+      config: {
+        displayName: 'TASK 015-020 Temp',
+        localPath: repo.path,
+        gitPath: repo.path,
+        aiProfileId: 'mock-agent',
+        goalStatus: 'accepted',
+        kbSchemaVersion: 'v3',
+      },
+    });
+    assert(r.res.ok, 'project import should succeed');
+
+    r = await json('POST', `/api/projects/${SLUG}/init`);
+    assert(r.res.ok && r.data.kbSchemaVersion === 'v3', 'init should create v3 KB');
+    const projects = JSON.parse(fs.readFileSync(PROJECTS_JSON, 'utf-8'));
+    const kbPath = projects[SLUG].kbPath;
+    const top = fs.readdirSync(kbPath).filter(name => !name.startsWith('.')).sort();
+    assert(JSON.stringify(top) === JSON.stringify(['ARCHITECTURE.md', 'GOAL.md', 'README.md', 'changes', 'modules']), `unexpected v3 top-level: ${top.join(', ')}`);
+    assert(!fs.existsSync(path.join(kbPath, '_ai')), 'v3 KB must not contain _ai');
+    assert(!fs.existsSync(path.join(kbPath, 'kb-manifest.json')), 'v3 KB must not contain manifest');
+
+    r = await json('POST', `/api/projects/${SLUG}/validate-kb`);
+    assert(r.res.ok && r.data.ok, `v3 validate should pass: ${JSON.stringify(r.data)}`);
+    r = await json('GET', `/api/projects/${SLUG}/pr-context`);
+    assert(r.res.ok && r.data.pack && r.data.pack.goal.path === 'GOAL.md', 'PR context should read V3 GOAL');
+
+    r = await json('POST', `/api/projects/${SLUG}/analyze/commits`);
+    assert(r.res.ok, `commit analysis should pass: ${JSON.stringify(r.data)}`);
+    const runId = r.data.runId;
+    assert(r.data.run.sourceBranch !== undefined, 'run should include sourceBranch key');
+    assert(r.data.run.sourceDefaultBranch !== undefined, 'run should include sourceDefaultBranch key');
+    assert(r.data.run.sourceRemote !== undefined, 'run should include sourceRemote key');
+    assert(fs.existsSync(path.join(aiRoot, SLUG, 'runs', `${runId}.json`)), 'run should live in _site/_ai/<slug>');
+    assert(fs.existsSync(path.join(aiRoot, SLUG, 'context-packs', runId, 'context-pack.json')), 'context pack should live in _site/_ai/<slug>');
+
+    const branch = r.data.run.sourceBranch || 'unknown (pre-TASK-016)';
+    r = await json('GET', `/api/projects/${SLUG}/drafts-by-branch?branch=${encodeURIComponent(branch)}`);
+    assert(r.res.ok && r.data.drafts.length > 0, 'drafts-by-branch should return branch drafts');
+    assert(r.data.drafts.every(d => d.sourceBranch === branch), 'drafts-by-branch should filter by branch');
+
+    const payloads = [];
+    for (const d of r.data.drafts.filter(d => d.path.startsWith('changes/'))) {
+      const raw = await json('GET', `/api/projects/${SLUG}/drafts/${d.runId}/raw?path=${encodeURIComponent(d.path)}`);
+      assert(raw.res.ok, `raw draft should load: ${d.path}`);
+      payloads.push({ path: d.path, content: raw.data.content, sourceBranch: d.sourceBranch, sourceHeadCommit: d.sourceHeadCommit });
+    }
+    assert(payloads.length > 0, 'should have changes draft payloads');
+    r = await json('POST', `/api/projects/${SLUG}/drafts/${runId}/apply`, { drafts: payloads, allowGoalEdit: false });
+    assert(r.res.ok && r.data.applied.length === payloads.length, 'V3 changes drafts should auto-apply');
+    const applied = fs.readFileSync(path.join(kbPath, payloads[0].path), 'utf-8');
+    assert(applied.includes('sourceBranch:'), 'applied V3 doc should include sourceBranch');
+    assert(fs.existsSync(path.join(kbPath, 'changes', '00-index.md')), 'changes index should regenerate');
+
+    r = await json('POST', `/api/projects/${SLUG}/drafts/${runId}/apply`, {
+      drafts: [{ path: 'GOAL.md', content: '# bad silent goal edit' }],
+      allowGoalEdit: false,
+    });
+    assert(!r.res.ok && r.res.status === 409, 'GOAL.md apply should require review');
+
+    const legacyKb = path.join(kbRoot, LEGACY_SLUG);
+    fs.mkdirSync(path.join(legacyKb, '_ai', 'runs'), { recursive: true });
+    fs.mkdirSync(path.join(legacyKb, 'commits'), { recursive: true });
+    fs.writeFileSync(path.join(legacyKb, 'README.md'), '# legacy\n');
+    fs.writeFileSync(path.join(legacyKb, 'project-goal.md'), '# legacy goal\n');
+    fs.writeFileSync(path.join(legacyKb, '_ai', 'runs', 'old.json'), '{"schema":"ai-run/v1"}\n');
+    for (let i = 0; i < 6; i++) fs.writeFileSync(path.join(legacyKb, 'commits', `2026-01-0${i + 1}_aaaaaa${i}_test.md`), `# commit ${i}\n`);
+    r = await json('PUT', '/api/projects', { slug: LEGACY_SLUG, config: { displayName: 'legacy', localPath: repo.path, gitPath: repo.path, kbPath: legacyKb, kbSchemaVersion: 'v2' } });
+    assert(r.res.ok, 'legacy project import should succeed');
+    r = await json('POST', `/api/projects/${LEGACY_SLUG}/migrate-v3`);
+    assert(r.res.ok, `migrate-v3 should pass: ${JSON.stringify(r.data)}`);
+    assert(!fs.existsSync(path.join(legacyKb, '_ai')), 'migrate-v3 should remove KB-local _ai');
+    assert(!fs.existsSync(path.join(legacyKb, 'commits')), 'migrate-v3 should remove legacy commits dir');
+    assert(fs.existsSync(path.join(aiRoot, LEGACY_SLUG, 'legacy-commits')), 'legacy commits should be backed up to app AI workspace');
+    assert(fs.readdirSync(path.join(legacyKb, 'changes')).some(name => /^legacy-change-/.test(name)), 'legacy commits should consolidate into changes');
+
+    r = await json('GET', `/api/projects/${SLUG}/remove-preview`);
+    assert(r.res.ok && r.data.preview.fileCount > 0, 'remove preview should include file count');
+    r = await json('POST', `/api/projects/${SLUG}/remove`, { deleteKb: false, reason: 'integration soft remove' });
+    assert(r.res.ok && r.data.removedKb === false, 'soft remove should not delete KB');
+    assert(fs.existsSync(kbPath), 'soft remove should keep KB on disk');
+    r = await json('PUT', '/api/projects', { slug: SLUG, config: { displayName: 'reimport', localPath: repo.path, gitPath: repo.path, kbPath, kbSchemaVersion: 'v3' } });
+    assert(r.res.ok, 'reimport after soft remove should work');
+    r = await json('POST', `/api/projects/${SLUG}/remove`, { deleteKb: true, reason: 'integration hard remove' });
+    assert(r.res.ok && r.data.removedKb === true, 'hard remove should delete KB');
+    assert(!fs.existsSync(kbPath), 'hard remove should remove KB path');
+
+    const logFiles = fs.readdirSync(logsRoot).filter(name => name.endsWith('.log'));
+    assert(logFiles.length > 0, 'structured log should be written');
+    const logText = logFiles.map(file => fs.readFileSync(path.join(logsRoot, file), 'utf-8')).join('\n');
+    assert(logText.includes('project_removed'), 'project removal should be logged');
+
+    console.log('TASK-015..020 integration test passed');
+  } catch (e) {
+    console.error('TASK-015..020 integration test failed:', e.message);
+    if (serverOutput) console.error(serverOutput);
+    process.exitCode = 1;
+  } finally {
+    child.kill();
+    await sleep(500);
+    try { if (repo && repo.cleanup) repo.cleanup(); } catch {}
+    restore(PROJECTS_JSON, projectsBackup);
+    restore(KNOWLEDGE_STORE_JSON, storeBackup);
+    restore(LOGGING_JSON, loggingBackup);
+    fs.rmSync(path.join(aiRoot, SLUG), { recursive: true, force: true });
+    fs.rmSync(path.join(aiRoot, LEGACY_SLUG), { recursive: true, force: true });
+    await rmWithRetry(TEMP_ROOT).catch(() => {});
+  }
+})();