@sanqianx/project-knowledge 5.0.24 → 5.0.25

package/_site/_test/project-domain-scope-retrieval-test.js

@@ -0,0 +1,214 @@
+'use strict';
+// PRJ-011: changing the domain of a project updates the retrieval scope.
+//
+// The steps of the case are "change the domain of the project, then run a
+// project / domain retrieval". The expectations are:
+//   1. the scope follows the registration update;
+//   2. the absolute knowledge path does not move.
+//
+// The instance is an isolated product server with its own data directory and
+// its own knowledge root. The knowledge engine is the real vendored module;
+// the three other modules are local fixtures that answer 503, so only the
+// engine participates.
+//
+// Boundary: the vector index is not part of this fixture, so the retrieval
+// answers from the current knowledge files only. The scope expansion and the
+// registration update are the behaviour under test; the ranking channel is
+// explicitly the lexical one, which the answer reports itself.
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { spawnServer } = require('./helpers/spawn-server');
+const { createModuleFixture, createUpstreamProxy } = require('./helpers/module-fixture');
+const freePort = require('./helpers/free-port');
+const { applyDriverIsolation } = require('./helpers/parallel-qa-engine-endpoint-isolate');
+const { guardedCreateEngineServer } = require('./helpers/parallel-qa-engine-endpoint-guard');
+
+const ROOT = path.resolve(__dirname, '../..');
+
+function git(cwd, args) {
+  const result = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+  assert.equal(result.status, 0, `git ${args.join(' ')} failed: ${result.stderr}`);
+  return String(result.stdout || '').trim();
+}
+
+function makeRepo(root, name) {
+  const repo = path.join(root, name);
+  fs.mkdirSync(repo, { recursive: true });
+  git(repo, ['init', '-q', '-b', 'main']);
+  git(repo, ['config', 'user.email', 'domain@local.invalid']);
+  git(repo, ['config', 'user.name', 'Domain Regression']);
+  fs.writeFileSync(path.join(repo, 'README.md'), `# ${name}\n`);
+  git(repo, ['add', '.']); git(repo, ['commit', '-qm', 'baseline']);
+  return repo;
+}
+
+async function waitForHealth(base, timeoutMs = 20000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(`${base}/api/health`, { signal: AbortSignal.timeout(2000) });
+      if (response.ok) return;
+    } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('Timed out waiting for the isolated server on ' + base);
+}
+
+async function main() {
+  // Driver isolation FIRST: the environment is rebuilt from a system whitelist
+  // with every product surface pointed at a per-run layout, before any product
+  // module is required.
+  const applied = applyDriverIsolation({ prefix: 'pk-qa-prj-domain' });
+  const fixture = fs.mkdtempSync(path.join(applied.layout.temp, 'pk-prj-domain-'));
+  const dataDir = path.join(fixture, 'data');
+  const knowledgeRoot = path.join(fixture, 'knowledge');
+  const repoA = makeRepo(fixture, 'repo-domain-a');
+  const repoB = makeRepo(fixture, 'repo-domain-b');
+  const knowledgeA = path.join(knowledgeRoot, '领域项目');
+  const knowledgeB = path.join(knowledgeRoot, '另一领域项目');
+  fs.mkdirSync(knowledgeA, { recursive: true }); fs.mkdirSync(knowledgeB, { recursive: true });
+
+  const engineToken = crypto.randomBytes(24).toString('hex');
+  // OWN fixtures first (offline by design — the lexical channel is the
+  // behaviour under test), then the engine constructed against them: the
+  // coordinator ignores env and would otherwise fall back to LIVE 8787/8790.
+  const terminal = createModuleFixture({ kind: 'terminal' });
+  const vectorHub = createModuleFixture({ kind: 'vectorHub' });
+  const eventBridge = createModuleFixture({ kind: 'eventBridge' });
+  for (const fixtureService of [terminal, vectorHub, eventBridge]) {
+    await fixtureService.start();
+    fixtureService.setOnline(false);
+  }
+  const engine = guardedCreateEngineServer({ dataDir: path.join(fixture, 'engine'), runtimeToken: engineToken, debug: true, consume: false, vectorUrl: vectorHub.url, bridgeUrl: eventBridge.url });
+  await engine.ready;
+  await new Promise(resolve => engine.server.listen(0, '127.0.0.1', resolve));
+  const engineUrl = `http://127.0.0.1:${engine.server.address().port}`;
+  const engineProxy = createUpstreamProxy({ target: engineUrl, token: engineToken, tag: 'engine' });
+  await engineProxy.start();
+
+  const port = await freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const server = spawnServer({
+    root: ROOT,
+    port,
+    dataDir,
+    tag: 'project-domain',
+    analysisOwner: 'engine',
+    extraEnv: {
+      KB_MODULES_REGISTER: '1',
+      KB_MODULES_AUTOSTART: '0',
+      KB_KNOWLEDGE_ENGINE_URL: engineProxy.url,
+      KB_TERMINAL_URL: terminal.url,
+      KB_VECTORHUB_URL: vectorHub.url,
+      KB_EVENTBRIDGE_URL: eventBridge.url,
+    },
+  });
+  const api = async (method, route, body) => {
+    const response = await fetch(base + route, {
+      method,
+      headers: body === undefined ? undefined : { 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(20000),
+    });
+    return { status: response.status, body: await response.json() };
+  };
+  const engineApi = async (method, route, body) => {
+    const response = await fetch(engineUrl + route, {
+      method,
+      headers: body === undefined ? undefined : { 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(20000),
+    });
+    return { status: response.status, body: await response.json() };
+  };
+
+  try {
+    await waitForHealth(base);
+    assert.equal((await api('PATCH', '/api/settings', { knowledge: { rootPath: knowledgeRoot } })).status, 200);
+
+    // Two real domains. The product registers them as shared scopes with the
+    // engine, so a domain retrieval has something to expand to.
+    const first = await api('POST', '/api/domains', { name: '领域一' });
+    assert.equal(first.status, 201, JSON.stringify(first.body));
+    const domainA = first.body.domain.id;
+    const second = await api('POST', '/api/domains', { name: '领域二' });
+    assert.equal(second.status, 201, JSON.stringify(second.body));
+    const domainB = second.body.domain.id;
+    assert.ok(domainA && domainB && domainA !== domainB);
+
+    const scopesBefore = (await engineApi('GET', '/api/snapshot?summary=1&limit=1')).body.sharedScopes;
+    assert.ok(scopesBefore.some(scope => scope.kind === 'domain' && scope.domainId === domainA), 'the engine knows the first domain scope');
+    assert.ok(scopesBefore.some(scope => scope.kind === 'domain' && scope.domainId === domainB), 'the engine knows the second domain scope');
+    const scopePathsBefore = Object.fromEntries(scopesBefore.map(scope => [scope.id, scope.knowledgePath]));
+
+    const importedA = await api('POST', '/api/projects/import', { localPath: repoA, knowledgePath: knowledgeA, displayName: '领域项目', domainId: domainA });
+    assert.equal(importedA.status, 201, JSON.stringify(importedA.body));
+    const projectA = importedA.body.projectId;
+    assert.equal(importedA.body.project.config.domainId, domainA, 'the first project starts in the first domain');
+    const importedB = await api('POST', '/api/projects/import', { localPath: repoB, knowledgePath: knowledgeB, displayName: '另一领域项目', domainId: domainB });
+    assert.equal(importedB.status, 201, JSON.stringify(importedB.body));
+    const projectB = importedB.body.projectId;
+    assert.equal(importedB.body.project.config.domainId, domainB, 'the second project starts in the second domain');
+
+    // The knowledge file is written after the import: a new project's
+    // knowledge directory has to be empty when the project is registered.
+    const knowledgeFile = path.join(knowledgeA, 'note.md');
+    fs.writeFileSync(knowledgeFile, '# 领域笔记\n\n这是一条属于项目的知识记录。\n');
+    const knowledgeBytes = fs.readFileSync(knowledgeFile);
+
+    // A real domain retrieval through the product, answered by the real engine.
+    const before = await api('POST', '/api/knowledge/search', { projectId: projectA, query: '领域笔记', scope: 'domain' });
+    assert.equal(before.status, 200, JSON.stringify(before.body));
+    // The answer reports the scopes it scanned, one entry per scope.
+    const scopeIds = result => (result.health?.scopes || []).map(scope => scope.projectId);
+    assert.ok(scopeIds(before.body).includes(domainA), 'the retrieval runs in the domain of the project');
+    assert.equal(scopeIds(before.body).includes(domainB), false, 'the retrieval does not reach the other domain');
+    assert.equal(scopeIds(before.body).includes(projectB), false, 'the retrieval does not reach the project of the other domain');
+    assert.ok(before.body.results.length >= 1, 'the retrieval answers from the current knowledge files');
+    assert.ok(before.body.results.some(row => row.scope_project_id === projectA && String(row.snippet || '').includes('领域笔记')), 'the answer points at the knowledge file of the project');
+    assert.deepEqual(before.body.retrievalModes, ['lexical'], 'the answer reports the lexical channel it used');
+
+    // Change the domain of the first project.
+    const changed = await api('PATCH', `/api/projects/${encodeURIComponent(projectA)}`, { domainId: domainB });
+    assert.equal(changed.status, 200, JSON.stringify(changed.body));
+    assert.equal(changed.body.config.domainId, domainB, 'the product records the new domain');
+
+    // The registration in the real engine follows the change.
+    const registration = (await engineApi('GET', '/api/projects')).body.projects.find(project => project.projectId === projectA);
+    assert.ok(registration, 'the engine keeps the project registration');
+    assert.equal(registration.domainId, domainB, 'the engine registration carries the new domain');
+
+    // 1. The scope follows the registration update.
+    const after = await api('POST', '/api/knowledge/search', { projectId: projectA, query: '领域笔记', scope: 'domain' });
+    assert.equal(after.status, 200, JSON.stringify(after.body));
+    assert.ok(scopeIds(after.body).includes(domainB), 'the retrieval now runs in the new domain');
+    assert.equal(scopeIds(after.body).includes(domainA), false, 'the retrieval no longer reaches the old domain');
+    assert.ok(scopeIds(after.body).includes(projectB), 'the retrieval now reaches the project of the new domain');
+    assert.ok(after.body.results.some(row => row.scope_project_id === projectA && String(row.snippet || '').includes('领域笔记')), 'the project knowledge is still reachable');
+
+    // 2. The absolute knowledge path does not move.
+    const projected = (await api('GET', '/api/projects/projection')).body.projects.find(project => project.projectId === projectA);
+    assert.equal(path.resolve(projected.knowledgePath), path.resolve(knowledgeA), 'the knowledge path stays the same absolute path');
+    assert.deepEqual(fs.readFileSync(knowledgeFile), knowledgeBytes, 'the knowledge file bytes do not change');
+    assert.ok(fs.existsSync(path.join(knowledgeA, 'note.md')), 'the knowledge file stays where it is');
+    const scopesAfter = (await engineApi('GET', '/api/snapshot?summary=1&limit=1')).body.sharedScopes;
+    for (const scope of scopesAfter) {
+      assert.equal(scope.knowledgePath, scopePathsBefore[scope.id], `the shared scope path of ${scope.id} does not move`);
+    }
+    assert.ok(fs.existsSync(path.join(knowledgeRoot, '_shared')), 'the shared knowledge root stays where it is');
+
+    console.log('project-domain-scope-retrieval-test PASS (the domain retrieval scope follows the registration update; the absolute knowledge path does not move)');
+  } finally {
+    await server.cleanup();
+    await engine.close().catch(() => {});
+    await engineProxy.close();
+    for (const fixtureService of [terminal, vectorHub, eventBridge]) await fixtureService.close();
+    fs.rmSync(fixture, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });

package/_site/_test/project-git-init-confirm-test.js

@@ -0,0 +1,115 @@
+'use strict';
+// PRJ-008: Git initialization needs an explicit user confirmation.
+//
+// The steps of the case are "select a directory that is not a Git repository,
+// then request the import with and without the initialization confirmation".
+// Two expectations are covered:
+//   1. without an explicit confirmation no `git init` may happen;
+//   2. the initialization only happens inside the fixture the user selected.
+//
+// The instance is an isolated product server with its own data directory and
+// its own knowledge root. Nothing outside the fixture directory is touched.
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { spawnServer } = require('./helpers/spawn-server');
+const freePort = require('./helpers/free-port');
+
+const ROOT = path.resolve(__dirname, '../..');
+
+function git(cwd, args) {
+  const result = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+  return { status: result.status, stdout: String(result.stdout || '').trim(), stderr: String(result.stderr || '').trim() };
+}
+
+async function waitForHealth(base, timeoutMs = 20000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(`${base}/api/health`, { signal: AbortSignal.timeout(2000) });
+      if (response.ok) return;
+    } catch {}
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  throw new Error('Timed out waiting for the isolated server on ' + base);
+}
+
+function findGitDirectories(root, depth = 0) {
+  const found = [];
+  if (depth > 3) return found;
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const absolute = path.join(root, entry.name);
+    if (entry.name === '.git') { found.push(absolute); continue; }
+    found.push(...findGitDirectories(absolute, depth + 1));
+  }
+  return found;
+}
+
+async function main() {
+  const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-prj-gitinit-'));
+  const dataDir = path.join(fixture, 'data');
+  const knowledgeRoot = path.join(fixture, 'knowledge');
+  const selected = path.join(fixture, 'selected-project');
+  const neighbour = path.join(fixture, 'neighbour-project');
+  fs.mkdirSync(selected); fs.mkdirSync(neighbour);
+  fs.writeFileSync(path.join(selected, 'README.md'), '# selected\n');
+  fs.writeFileSync(path.join(neighbour, 'README.md'), '# neighbour\n');
+
+  const port = await freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const server = spawnServer({ root: ROOT, port, dataDir, tag: 'project-git-init' });
+  const api = async (method, route, body) => {
+    const response = await fetch(base + route, {
+      method,
+      headers: body === undefined ? undefined : { 'Content-Type': 'application/json' },
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(15000),
+    });
+    return { status: response.status, body: await response.json() };
+  };
+  try {
+    await waitForHealth(base);
+    assert.equal((await api('PATCH', '/api/settings', { knowledge: { rootPath: knowledgeRoot } })).status, 200);
+
+    // The preflight reports that a Git initialization is planned. The
+    // directory itself stays untouched: the preflight never mutates state.
+    const preflight = await api('POST', '/api/projects/preflight-import', { localPath: selected, knowledgePath: path.join(knowledgeRoot, 'selected'), displayName: '选定目录' });
+    assert.equal(preflight.status, 200, JSON.stringify(preflight.body));
+    assert.equal(preflight.body.plannedGitInit, true, 'the preflight must report the planned Git initialization');
+    assert.equal(preflight.body.checks.git.status, 'non-git', 'the preflight must report the directory as a non-Git directory');
+    assert.equal(fs.existsSync(path.join(selected, '.git')), false, 'the preflight must not initialize the repository');
+
+    // Without the explicit confirmation the import is refused and no Git
+    // repository is created anywhere.
+    const refused = await api('POST', '/api/projects/import', { localPath: selected, knowledgePath: path.join(knowledgeRoot, 'selected'), displayName: '选定目录' });
+    assert.equal(refused.status, 400, JSON.stringify(refused.body));
+    assert.equal(refused.body.error.code, 'INVALID_ARGUMENT');
+    assert.match(refused.body.error.message, /初始化/, 'the refusal must name the missing Git initialization confirmation');
+    assert.equal(fs.existsSync(path.join(selected, '.git')), false, 'a refused import must not run git init');
+    assert.deepEqual(findGitDirectories(fixture), [], 'a refused import must not create a Git repository anywhere in the fixture');
+    assert.equal((await api('GET', '/api/projects/aggregated')).body.projects.length, 0, 'a refused import must not register a project');
+
+    // With the explicit confirmation the initialization happens inside the
+    // selected fixture only.
+    const imported = await api('POST', '/api/projects/import', { localPath: selected, knowledgePath: path.join(knowledgeRoot, 'selected'), displayName: '选定目录', confirmGitInit: true });
+    assert.equal(imported.status, 201, JSON.stringify(imported.body));
+    assert.equal(fs.existsSync(path.join(selected, '.git')), true, 'the confirmed import must initialize the selected directory');
+    assert.equal(fs.existsSync(path.join(neighbour, '.git')), false, 'the neighbouring directory must stay untouched');
+    assert.deepEqual(findGitDirectories(fixture), [path.join(selected, '.git')], 'exactly the selected fixture may hold a Git repository');
+    const inside = git(selected, ['rev-parse', '--is-inside-work-tree']);
+    assert.equal(inside.status, 0, inside.stderr);
+    assert.equal(inside.stdout, 'true');
+    assert.equal(path.resolve(imported.body.project.config.repoPath), path.resolve(selected), 'the registered workspace path is the selected fixture');
+    assert.equal((await api('GET', '/api/projects/aggregated')).body.projects.length, 1, 'the confirmed import registers exactly one project');
+    console.log('project-git-init-confirm-test PASS (no git init without confirmation; initialization confined to the selected fixture)');
+  } finally {
+    await server.cleanup();
+    fs.rmSync(fixture, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  }
+}
+
+main().catch(error => { console.error(error.stack || error.message); process.exitCode = 1; });

package/_site/_test/project-goal-editor-test.js

@@ -1,145 +1,145 @@
-// _site/_test/project-goal-editor-test.js
-//
-// T13: Project Goal editor.
-//   GET /api/projects/:id/goal  -> read GOAL.md from project knowledge path
-//   PUT /api/projects/:id/goal  -> atomic write GOAL.md
-// Verifies:
-//   - missing GOAL.md returns exists=false;
-//   - PUT creates the file atomically;
-//   - subsequent GET returns the persisted content;
-//   - empty content allowed (no auto-template);
-//   - the file is scoped to the project's own knowledgePath (no
-//     cross-project writes);
-//   - 413 when content exceeds 256KB.
-
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const { spawnServer } = require('./helpers/spawn-server');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const sitePort = 8000 + (process.pid % 200);
-const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-goal-' + process.pid + '-'));
-const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-goal-repo-' + process.pid + '-'));
-
-function git(args) {
-  const result = spawnSync('git', ['-C', repo, ...args], {
-    encoding: 'utf8', windowsHide: true,
-    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
-  });
-  if (result.status !== 0) throw new Error(result.stderr || `git ${args.join(' ')} failed: ${result.status}`);
-  return String(result.stdout || '').trim();
-}
-
-async function serverFetch(url, init, timeoutMs = 10000) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetch(url, { ...init, signal: controller.signal });
-    const text = await response.text();
-    return { status: response.status, body: text ? JSON.parse(text) : {} };
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-(async () => {
-  git(['init', '-q', '-b', 'main']);
-  git(['config', 'user.email', 'goal@example.local']);
-  git(['config', 'user.name', 'Goal']);
-  fs.writeFileSync(path.join(repo, 'README.md'), '# goal\n');
-  git(['add', 'README.md']);
-  git(['commit', '-q', '-m', 'baseline']);
-  const knowledgeRoot = path.join(dataDir, 'knowledge');
-  fs.mkdirSync(knowledgeRoot, { recursive: true });
-  const server = spawnServer({
-    root: ROOT, port: sitePort, dataDir, tag: 'goal',
-    extraEnv: { KB_AUTOMATION_FAKE_CLAUDE: '1', KB_EMBEDDING_FAKE: '1', KB_SKIP_MIGRATION: '1' },
-  });
-  try {
-    for (let attempt = 0; attempt < 100; attempt += 1) {
-      try { const r = await serverFetch(`http://127.0.0.1:${sitePort}/api/health`); if (r.body.ok) break; } catch {}
-      await new Promise(resolve => setTimeout(resolve, 100));
-    }
-    await serverFetch(`http://127.0.0.1:${sitePort}/api/settings`, {
-      method: 'PATCH', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ knowledge: { rootPath: knowledgeRoot } }),
-    });
-    await serverFetch(`http://127.0.0.1:${sitePort}/api/ai-profiles`, {
-      method: 'PUT', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        schema: 'ai-profiles/v1', defaultProfileId: 'fake',
-        profiles: [{ id: 'fake', name: 'Fake', enabled: true, vendor: 'anthropic', model: 'fake', apiKeyUpdate: { mode: 'replace', value: 'k' } }],
-      }),
-    });
-    const importR = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/import`, {
-      method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ localPath: repo, aiProfileId: 'fake' }),
-    });
-    assert.strictEqual(importR.status, 201, JSON.stringify(importR.body));
-    const projectId = importR.body.projectId;
-    const knowledgePath = importR.body.config.knowledgePath;
-
-    // Case 1: GET on missing GOAL.md returns exists=false
-    let r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, undefined);
-    assert.strictEqual(r.status, 200);
-    assert.strictEqual(r.body.exists, false);
-    assert.strictEqual(r.body.content, '');
-
-    // Case 2: PUT creates the file atomically with the supplied content
-    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
-      method: 'PUT', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ content: '# Project Goal\n\nBuild a knowledge base for v4.1.22 -> main recovery.\n' }),
-    });
-    assert.strictEqual(r.status, 200, JSON.stringify(r.body));
-    const goalPath = path.join(knowledgePath, 'GOAL.md');
-    assert(fs.existsSync(goalPath), 'GOAL.md must be created');
-    assert(fs.readFileSync(goalPath, 'utf8').includes('v4.1.22'), 'goal content must include the user-supplied text');
-
-    // Case 3: GET now returns the persisted content
-    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, undefined);
-    assert.strictEqual(r.status, 200);
-    assert.strictEqual(r.body.exists, true);
-    assert(r.body.content.includes('v4.1.22'));
-
-    // Case 4: empty content is allowed (no auto-template)
-    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
-      method: 'PUT', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ content: '' }),
-    });
-    assert.strictEqual(r.status, 200);
-    assert.strictEqual(fs.readFileSync(goalPath, 'utf8'), '', 'empty content must clear the file');
-
-    // Case 5: writes are scoped to the project's own knowledgePath
-    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
-      method: 'PUT', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ content: 'real content\n' }),
-    });
-    assert.strictEqual(r.status, 200);
-    const otherFiles = fs.readdirSync(knowledgePath).filter(name => name !== 'GOAL.md');
-    assert.deepStrictEqual(otherFiles, [], 'only GOAL.md must be created in the project knowledge path');
-
-    // Case 6: 413 when content exceeds 256KB
-    const huge = 'x'.repeat(257 * 1024);
-    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
-      method: 'PUT', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ content: huge }),
-    });
-    assert.strictEqual(r.status, 413);
-
-    // Case 7: GET on a non-existent project returns 404
-    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/does-not-exist/goal`, undefined);
-    assert.strictEqual(r.status, 404);
-  } finally {
-    server.child.kill();
-    await new Promise(resolve => server.child.once('exit', resolve));
-    fs.rmSync(dataDir, { recursive: true, force: true });
-    fs.rmSync(repo, { recursive: true, force: true });
-  }
-  console.log('project-goal-editor-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exit(1);
+// _site/_test/project-goal-editor-test.js
+//
+// T13: Project Goal editor.
+//   GET /api/projects/:id/goal  -> read GOAL.md from project knowledge path
+//   PUT /api/projects/:id/goal  -> atomic write GOAL.md
+// Verifies:
+//   - missing GOAL.md returns exists=false;
+//   - PUT creates the file atomically;
+//   - subsequent GET returns the persisted content;
+//   - empty content allowed (no auto-template);
+//   - the file is scoped to the project's own knowledgePath (no
+//     cross-project writes);
+//   - 413 when content exceeds 256KB.
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { spawnServer } = require('./helpers/spawn-server');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const sitePort = 8000 + (process.pid % 200);
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-goal-' + process.pid + '-'));
+const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-goal-repo-' + process.pid + '-'));
+
+function git(args) {
+  const result = spawnSync('git', ['-C', repo, ...args], {
+    encoding: 'utf8', windowsHide: true,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+  });
+  if (result.status !== 0) throw new Error(result.stderr || `git ${args.join(' ')} failed: ${result.status}`);
+  return String(result.stdout || '').trim();
+}
+
+async function serverFetch(url, init, timeoutMs = 10000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    const text = await response.text();
+    return { status: response.status, body: text ? JSON.parse(text) : {} };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+(async () => {
+  git(['init', '-q', '-b', 'main']);
+  git(['config', 'user.email', 'goal@example.local']);
+  git(['config', 'user.name', 'Goal']);
+  fs.writeFileSync(path.join(repo, 'README.md'), '# goal\n');
+  git(['add', 'README.md']);
+  git(['commit', '-q', '-m', 'baseline']);
+  const knowledgeRoot = path.join(dataDir, 'knowledge');
+  fs.mkdirSync(knowledgeRoot, { recursive: true });
+  const server = spawnServer({
+    root: ROOT, port: sitePort, dataDir, tag: 'goal',
+    extraEnv: { KB_AUTOMATION_FAKE_CLAUDE: '1', KB_EMBEDDING_FAKE: '1', KB_SKIP_MIGRATION: '1' },
+  });
+  try {
+    for (let attempt = 0; attempt < 100; attempt += 1) {
+      try { const r = await serverFetch(`http://127.0.0.1:${sitePort}/api/health`); if (r.body.ok) break; } catch {}
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    await serverFetch(`http://127.0.0.1:${sitePort}/api/settings`, {
+      method: 'PATCH', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ knowledge: { rootPath: knowledgeRoot } }),
+    });
+    await serverFetch(`http://127.0.0.1:${sitePort}/api/ai-profiles`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        schema: 'ai-profiles/v1', defaultProfileId: 'fake',
+        profiles: [{ id: 'fake', name: 'Fake', enabled: true, vendor: 'anthropic', model: 'fake', apiKeyUpdate: { mode: 'replace', value: 'k' } }],
+      }),
+    });
+    const importR = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/import`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ localPath: repo, aiProfileId: 'fake' }),
+    });
+    assert.strictEqual(importR.status, 201, JSON.stringify(importR.body));
+    const projectId = importR.body.projectId;
+    const knowledgePath = importR.body.config.knowledgePath;
+
+    // Case 1: GET on missing GOAL.md returns exists=false
+    let r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, undefined);
+    assert.strictEqual(r.status, 200);
+    assert.strictEqual(r.body.exists, false);
+    assert.strictEqual(r.body.content, '');
+
+    // Case 2: PUT creates the file atomically with the supplied content
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: '# Project Goal\n\nBuild a knowledge base for v4.1.22 -> main recovery.\n' }),
+    });
+    assert.strictEqual(r.status, 200, JSON.stringify(r.body));
+    const goalPath = path.join(knowledgePath, 'GOAL.md');
+    assert(fs.existsSync(goalPath), 'GOAL.md must be created');
+    assert(fs.readFileSync(goalPath, 'utf8').includes('v4.1.22'), 'goal content must include the user-supplied text');
+
+    // Case 3: GET now returns the persisted content
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, undefined);
+    assert.strictEqual(r.status, 200);
+    assert.strictEqual(r.body.exists, true);
+    assert(r.body.content.includes('v4.1.22'));
+
+    // Case 4: empty content is allowed (no auto-template)
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: '' }),
+    });
+    assert.strictEqual(r.status, 200);
+    assert.strictEqual(fs.readFileSync(goalPath, 'utf8'), '', 'empty content must clear the file');
+
+    // Case 5: writes are scoped to the project's own knowledgePath
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: 'real content\n' }),
+    });
+    assert.strictEqual(r.status, 200);
+    const otherFiles = fs.readdirSync(knowledgePath).filter(name => name !== 'GOAL.md');
+    assert.deepStrictEqual(otherFiles, [], 'only GOAL.md must be created in the project knowledge path');
+
+    // Case 6: 413 when content exceeds 256KB
+    const huge = 'x'.repeat(257 * 1024);
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/${projectId}/goal`, {
+      method: 'PUT', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ content: huge }),
+    });
+    assert.strictEqual(r.status, 413);
+
+    // Case 7: GET on a non-existent project returns 404
+    r = await serverFetch(`http://127.0.0.1:${sitePort}/api/projects/does-not-exist/goal`, undefined);
+    assert.strictEqual(r.status, 404);
+  } finally {
+    server.child.kill();
+    await new Promise(resolve => server.child.once('exit', resolve));
+    fs.rmSync(dataDir, { recursive: true, force: true });
+    fs.rmSync(repo, { recursive: true, force: true });
+  }
+  console.log('project-goal-editor-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exit(1);
 });