@sanqianx/project-knowledge 5.0.24 → 5.0.25

package/_site/_test/project-import-duplicate-alias-test.js

@@ -0,0 +1,134 @@
+'use strict';
+// PRJ-005: importing the same repository twice is refused, and the existing
+// project keeps its data.
+//
+// The platform contract decides what "the same repository" means: a path is
+// compared after resolution, after trailing separators are stripped, and on
+// Windows after lower-casing. A spelling alias of an imported path must
+// therefore be refused as a duplicate as well, while a genuinely different
+// repository must still import.
+
+const assert = require('node:assert/strict');
+const crypto = require('node:crypto');
+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' } });
+  assert.equal(result.status, 0, `git ${args.join(' ')} failed: ${result.stderr}`);
+  return String(result.stdout || '').trim();
+}
+
+function sha256(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+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', 'duplicate@local.invalid']);
+  git(repo, ['config', 'user.name', 'Duplicate 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() {
+  const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-prj-duplicate-'));
+  const dataDir = path.join(fixture, 'data');
+  const knowledgeRoot = path.join(fixture, 'knowledge');
+  const repo = makeRepo(fixture, 'repo-a');
+  const otherRepo = makeRepo(fixture, 'repo-b');
+  const knowledge = path.join(knowledgeRoot, 'a');
+  const otherKnowledge = path.join(knowledgeRoot, 'b');
+  fs.mkdirSync(knowledge, { recursive: true }); fs.mkdirSync(otherKnowledge, { recursive: true });
+
+  const port = await freePort();
+  const base = `http://127.0.0.1:${port}`;
+  const server = spawnServer({ root: ROOT, port, dataDir, tag: 'project-import-duplicate' });
+  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);
+
+    const first = await api('POST', '/api/projects/import', { localPath: repo, knowledgePath: knowledge, displayName: '仓库 A' });
+    assert.equal(first.status, 201, JSON.stringify(first.body));
+    const projectId = first.body.projectId;
+    const projectDir = path.join(dataDir, 'projects', projectId);
+    const configPath = path.join(projectDir, 'config.json');
+    const statePath = path.join(projectDir, 'state.json');
+    const configBefore = sha256(configPath);
+    const stateBefore = sha256(statePath);
+    const knowledgeBefore = fs.readdirSync(knowledge).sort();
+
+    // The same path spelled exactly the same way is refused.
+    const exact = await api('POST', '/api/projects/import', { localPath: repo, displayName: '重复' });
+    assert.equal(exact.status, 409, 'a repeated import is refused');
+    assert.equal(exact.body.error.code, 'INVALID_ARGUMENT');
+    assert.match(exact.body.error.message, /already imported/i);
+
+    // Spelling aliases of the same directory are the same path under the
+    // platform contract: resolution plus trailing-separator stripping plus
+    // lower-casing on Windows.
+    const aliases = [
+      { name: 'trailing separator', value: repo + path.sep },
+      { name: 'separator variant', value: repo.replace(/\\/g, '/') },
+    ];
+    if (process.platform === 'win32') {
+      aliases.push({ name: 'case variant', value: repo.toUpperCase() });
+    }
+    for (const alias of aliases) {
+      const refused = await api('POST', '/api/projects/import', { localPath: alias.value, displayName: '别名' });
+      assert.equal(refused.status, 409, `the ${alias.name} alias must be refused as a duplicate`);
+      assert.equal(refused.body.error.code, 'INVALID_ARGUMENT');
+    }
+
+    // The refused attempts must not touch the registered project.
+    assert.equal(sha256(configPath), configBefore, 'the project configuration is unchanged after the refused duplicates');
+    assert.equal(sha256(statePath), stateBefore, 'the project state is unchanged after the refused duplicates');
+    assert.deepEqual(fs.readdirSync(knowledge).sort(), knowledgeBefore, 'the knowledge directory is unchanged after the refused duplicates');
+    const aggregated = await api('GET', '/api/projects/aggregated');
+    assert.equal(aggregated.body.projects.length, 1, 'a refused duplicate must not register a second project');
+    assert.equal(aggregated.body.projects[0].projectId, projectId);
+
+    // A different repository is still importable: the refusal is about this
+    // path, not about importing at all.
+    const second = await api('POST', '/api/projects/import', { localPath: otherRepo, knowledgePath: otherKnowledge, displayName: '仓库 B' });
+    assert.equal(second.status, 201, JSON.stringify(second.body));
+    assert.notEqual(second.body.projectId, projectId);
+    assert.equal((await api('GET', '/api/projects/aggregated')).body.projects.length, 2, 'a different repository registers its own project');
+    console.log('project-import-duplicate-alias-test PASS (duplicate refused, alias refused by the platform path contract, existing project data intact)');
+  } 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-import-unicode-restart-test.js

@@ -0,0 +1,140 @@
+'use strict';
+// PRJ-004: a repository whose path contains Chinese characters and spaces.
+//
+// Three expectations are covered: the stored paths are normalized absolute
+// paths, the managed Hook really runs, and the absolute knowledge path stays
+// the same after the isolated instance is restarted. The restart only touches
+// this fixture's own instance; no running desktop is stopped or replaced.
+
+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' } });
+  assert.equal(result.status, 0, `git ${args.join(' ')} failed: ${result.stderr}`);
+  return String(result.stdout || '').trim();
+}
+
+function resolveShell() {
+  const execPath = spawnSync('git', ['--exec-path'], { encoding: 'utf8', windowsHide: true }).stdout.trim();
+  if (!execPath) return 'sh';
+  const root = path.resolve(execPath, '..', '..', '..');
+  for (const candidate of [path.join(root, 'bin', 'sh.exe'), path.join(root, 'usr', 'bin', 'sh.exe')]) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return 'sh';
+}
+
+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 makeApi(base) {
+  return 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() };
+  };
+}
+
+async function main() {
+  const fixture = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-prj-unicode-'));
+  const dataDir = path.join(fixture, 'data');
+  const repo = path.join(fixture, '中文 空格项目');
+  const knowledgeRoot = path.join(fixture, '知识根');
+  const knowledge = path.join(knowledgeRoot, '项目知识');
+  fs.mkdirSync(repo); fs.mkdirSync(knowledgeRoot); fs.mkdirSync(knowledge);
+  git(repo, ['init', '-q', '-b', 'main']);
+  git(repo, ['config', 'user.email', 'unicode@local.invalid']);
+  git(repo, ['config', 'user.name', 'Unicode Regression']);
+  fs.writeFileSync(path.join(repo, '说明.md'), '# 中文路径\n');
+  git(repo, ['add', '.']); git(repo, ['commit', '-qm', 'baseline']);
+  const baseline = git(repo, ['rev-parse', 'HEAD']);
+
+  const firstPort = await freePort();
+  const firstBase = `http://127.0.0.1:${firstPort}`;
+  const first = spawnServer({ root: ROOT, port: firstPort, dataDir, tag: 'project-import-unicode' });
+  let second = null;
+  try {
+    await waitForHealth(firstBase);
+    const api = makeApi(firstBase);
+    // The settings route keeps the operator's spelling of the root; every
+    // consumer resolves it, so a trailing separator still names one directory.
+    const configured = await api('PATCH', '/api/settings', { knowledge: { rootPath: knowledgeRoot + path.sep } });
+    assert.equal(configured.status, 200, JSON.stringify(configured.body));
+    assert.equal(path.isAbsolute(configured.body.settings.knowledge.rootPath), true, 'the knowledge root is stored as an absolute path');
+    assert.equal(path.resolve(configured.body.settings.knowledge.rootPath), path.resolve(knowledgeRoot), 'the stored knowledge root resolves to the configured directory');
+
+    const imported = await api('POST', '/api/projects/import', { localPath: repo, knowledgePath: knowledge, displayName: '中文 项目' });
+    assert.equal(imported.status, 201, JSON.stringify(imported.body));
+    const projectId = imported.body.projectId;
+
+    const config = imported.body.project.config;
+    assert.equal(config.repoPath, path.resolve(repo), 'the workspace path is stored normalized');
+    assert.equal(config.knowledgePath, path.resolve(knowledge), 'the knowledge path is stored normalized');
+    assert.equal(path.isAbsolute(config.repoPath), true);
+    assert.equal(path.isAbsolute(config.knowledgePath), true);
+    assert.ok(config.repoPath.includes('中文 空格项目'), 'the Chinese and spaced segments survive');
+    assert.ok(config.knowledgePath.includes('项目知识'), 'the Chinese knowledge segment survives');
+    assert.equal(git(repo, ['rev-parse', 'HEAD']), baseline, 'the import does not move HEAD');
+
+    // The managed Hook must exist and be runnable.
+    const hookPath = path.join(repo, '.git', 'hooks', 'post-commit');
+    assert.ok(fs.existsSync(hookPath), 'the managed Hook is installed');
+    const hookText = fs.readFileSync(hookPath, 'utf8');
+    assert.ok(hookText.includes(`# PROJECT-KNOWLEDGE-HOOK `), 'the Hook carries the managed marker');
+    assert.ok(hookText.includes(projectId), 'the Hook belongs to the imported project');
+    const hookRun = spawnSync(resolveShell(), [hookPath], { cwd: repo, encoding: 'utf8', windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+    assert.equal(hookRun.status, 0, `the Hook must run successfully: ${hookRun.stderr}`);
+    const logDir = path.join(dataDir, 'logs', 'projects', projectId);
+    const logFiles = fs.existsSync(logDir) ? fs.readdirSync(logDir).filter(name => name.endsWith('.jsonl')) : [];
+    assert.ok(logFiles.length > 0, 'running the Hook leaves a durable log entry');
+    const hookLog = logFiles.map(name => fs.readFileSync(path.join(logDir, name), 'utf8')).join('');
+    assert.match(hookLog, /hook\./, 'the log entry records the Hook execution');
+
+    // Restart the fixture instance only: same data directory, new port.
+    first.child.kill();
+    await new Promise(resolve => first.child.once('close', resolve));
+    const secondPort = await freePort();
+    const secondBase = `http://127.0.0.1:${secondPort}`;
+    second = spawnServer({ root: ROOT, port: secondPort, dataDir, tag: 'project-import-unicode-restart' });
+    await waitForHealth(secondBase);
+    const restartedApi = makeApi(secondBase);
+    const reopened = await restartedApi('GET', `/api/projects/${projectId}`);
+    assert.equal(reopened.status, 200, JSON.stringify(reopened.body));
+    assert.equal(reopened.body.project.config.repoPath, path.resolve(repo), 'the workspace path is unchanged after the restart');
+    assert.equal(reopened.body.project.config.knowledgePath, path.resolve(knowledge), 'the absolute knowledge path is unchanged after the restart');
+    const settingsAfterRestart = await restartedApi('GET', '/api/settings');
+    assert.equal(path.resolve(settingsAfterRestart.body.settings.knowledge.rootPath), path.resolve(knowledgeRoot), 'the knowledge root is unchanged after the restart');
+    const aggregated = await restartedApi('GET', '/api/projects/aggregated');
+    assert.equal(aggregated.body.projects.length, 1, 'the project is still registered after the restart');
+    assert.equal(aggregated.body.projects[0].knowledgePath, path.resolve(knowledge), 'the registered knowledge path is still absolute and identical');
+    assert.ok(fs.existsSync(knowledge), 'the knowledge directory still exists on disk');
+    console.log('project-import-unicode-restart-test PASS (normalized paths, runnable Hook, stable absolute knowledge path across a fixture-only restart)');
+  } finally {
+    await second?.cleanup();
+    try { await first.cleanup(); } catch {}
+    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-lifecycle-transaction-test.js

@@ -1,106 +1,106 @@
-const assert = require('assert');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-const { StorageLayout } = require('../lib/storage-layout');
-const { SettingsStore } = require('../lib/settings-store');
-const { ProjectRegistryStore } = require('../lib/project-registry-store');
-const { ProjectStore } = require('../lib/project-store');
-const { ProjectLifecycleService } = require('../lib/project-lifecycle-service');
-const realHookManager = require('../lib/hook-manager');
-
-const ROOT = path.resolve(__dirname, '..', '..');
-const TRIGGER = path.join(ROOT, '_site', 'scripts', 'hook-trigger.js');
-
-function git(repo, 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`);
-  return String(result.stdout || '').trim();
-}
-
-function createRepo(root, name, withCommit = true) {
-  const repo = path.join(root, name);
-  fs.mkdirSync(repo, { recursive: true });
-  git(repo, ['init', '--initial-branch=main']);
-  git(repo, ['config', 'user.email', 'life@example.invalid']);
-  git(repo, ['config', 'user.name', 'Lifecycle Test']);
-  if (withCommit) {
-    fs.writeFileSync(path.join(repo, 'README.md'), `# ${name}\n`);
-    git(repo, ['add', 'README.md']);
-    git(repo, ['commit', '-m', 'initial']);
-  }
-  return repo;
-}
-
-(async () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-lifecycle-'));
-  const dataDir = path.join(root, 'data');
-  const knowledgeRoot = path.join(root, 'knowledge');
-  const layout = new StorageLayout({ dataDir });
-  const settings = new SettingsStore({ layout });
-  const registry = new ProjectRegistryStore({ layout });
-  const projects = new ProjectStore({ layout });
-  await settings.initialize({ knowledge: { rootPath: knowledgeRoot } });
-  await registry.initialize();
-  const lifecycle = new ProjectLifecycleService({
-    layout,
-    settingsStore: settings,
-    registryStore: registry,
-    projectStore: projects,
-    triggerScriptPath: TRIGGER,
-    bridgeAdapter: { async getHighWatermark() { return { status: 'captured', cursor: 73 }; } },
-  });
-
-  const repo = createRepo(root, 'repo-a');
-  const claude = path.join(repo, 'CLAUDE.md');
-  fs.writeFileSync(claude, '# user only\n');
-  const imported = await lifecycle.importProject({ localPath: repo, projectId: 'project-life-a', storageName: 'repo-a-stable' });
-  assert.strictEqual(imported.ok, true);
-  assert.strictEqual(imported.config.aiProfileId, null, 'import must not require an AI profile');
-  assert.strictEqual(imported.state.trackingStartCommit, git(repo, ['rev-parse', 'HEAD']));
-  assert.strictEqual(imported.state.conversationBaselineCursor, 73, 'import must freeze the current Bridge cursor as its conversation baseline');
-  assert.deepStrictEqual(fs.readdirSync(imported.config.knowledgePath), [], 'import must not create TODO knowledge files');
-  assert.strictEqual(fs.readFileSync(claude, 'utf8'), '# user only\n');
-  assert.strictEqual(realHookManager.readHookStatus({ repoPath: repo, projectId: imported.projectId }).installed, true);
-  await assert.rejects(lifecycle.importProject({ localPath: repo }), /already imported/);
-
-  const conflictRepo = createRepo(root, 'repo-conflict');
-  const conflictPath = path.join(knowledgeRoot, 'conflict-stable');
-  fs.mkdirSync(conflictPath, { recursive: true });
-  fs.writeFileSync(path.join(conflictPath, 'user.md'), 'do not overwrite');
-  await assert.rejects(lifecycle.importProject({ localPath: conflictRepo, projectId: 'project-conflict', storageName: 'conflict-stable' }), error => error.code === 'MIGRATION_TARGET_CONFLICT');
-  assert(!registry.listIds().includes('project-conflict'));
-  assert.strictEqual(fs.readFileSync(path.join(conflictPath, 'user.md'), 'utf8'), 'do not overwrite');
-
-  const failingRepo = createRepo(root, 'repo-failing');
-  const failingHooks = { ...realHookManager, installHook() { throw new Error('injected Hook failure'); } };
-  const failingLifecycle = new ProjectLifecycleService({ layout, settingsStore: settings, registryStore: registry, projectStore: projects, triggerScriptPath: TRIGGER, hookManager: failingHooks });
-  await assert.rejects(failingLifecycle.importProject({ localPath: failingRepo, projectId: 'project-failing', storageName: 'failing-stable' }));
-  assert(!registry.listIds().includes('project-failing'));
-  assert(!fs.existsSync(layout.getProjectMetadataDir('project-failing')));
-  assert(!fs.existsSync(path.join(knowledgeRoot, 'failing-stable')));
-
-  const emptyRepo = createRepo(root, 'repo-empty', false);
-  const empty = await lifecycle.importProject({ localPath: emptyRepo, projectId: 'project-empty', storageName: 'empty-stable' });
-  assert.strictEqual(empty.state.trackingMode, 'empty-repo');
-  assert.strictEqual(empty.state.trackingStartCommit, null);
-
-  const failingDelete = new ProjectLifecycleService({
-    layout, settingsStore: settings, registryStore: registry, projectStore: projects, triggerScriptPath: TRIGGER,
-    hookManager: { ...realHookManager, uninstallHook() { throw new Error('injected uninstall failure'); } },
-  });
-  await assert.rejects(failingDelete.deleteProject(imported.projectId));
-  assert(registry.listIds().includes(imported.projectId), 'Hook uninstall failure must preserve registration');
-
-  const knowledgePath = imported.config.knowledgePath;
-  const deleted = await lifecycle.deleteProject(imported.projectId);
-  assert.strictEqual(deleted.removedKnowledge, false);
-  assert(fs.existsSync(knowledgePath), 'default delete must preserve external knowledge directory');
-  assert(!registry.listIds().includes(imported.projectId));
-
-  console.log('project-lifecycle-transaction-test PASS');
-})().catch(error => {
-  console.error(error.stack || error.message);
-  process.exitCode = 1;
-});
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { StorageLayout } = require('../lib/storage-layout');
+const { SettingsStore } = require('../lib/settings-store');
+const { ProjectRegistryStore } = require('../lib/project-registry-store');
+const { ProjectStore } = require('../lib/project-store');
+const { ProjectLifecycleService } = require('../lib/project-lifecycle-service');
+const realHookManager = require('../lib/hook-manager');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const TRIGGER = path.join(ROOT, '_site', 'scripts', 'hook-trigger.js');
+
+function git(repo, 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`);
+  return String(result.stdout || '').trim();
+}
+
+function createRepo(root, name, withCommit = true) {
+  const repo = path.join(root, name);
+  fs.mkdirSync(repo, { recursive: true });
+  git(repo, ['init', '--initial-branch=main']);
+  git(repo, ['config', 'user.email', 'life@example.invalid']);
+  git(repo, ['config', 'user.name', 'Lifecycle Test']);
+  if (withCommit) {
+    fs.writeFileSync(path.join(repo, 'README.md'), `# ${name}\n`);
+    git(repo, ['add', 'README.md']);
+    git(repo, ['commit', '-m', 'initial']);
+  }
+  return repo;
+}
+
+(async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-lifecycle-'));
+  const dataDir = path.join(root, 'data');
+  const knowledgeRoot = path.join(root, 'knowledge');
+  const layout = new StorageLayout({ dataDir });
+  const settings = new SettingsStore({ layout });
+  const registry = new ProjectRegistryStore({ layout });
+  const projects = new ProjectStore({ layout });
+  await settings.initialize({ knowledge: { rootPath: knowledgeRoot } });
+  await registry.initialize();
+  const lifecycle = new ProjectLifecycleService({
+    layout,
+    settingsStore: settings,
+    registryStore: registry,
+    projectStore: projects,
+    triggerScriptPath: TRIGGER,
+    bridgeAdapter: { async getHighWatermark() { return { status: 'captured', cursor: 73 }; } },
+  });
+
+  const repo = createRepo(root, 'repo-a');
+  const claude = path.join(repo, 'CLAUDE.md');
+  fs.writeFileSync(claude, '# user only\n');
+  const imported = await lifecycle.importProject({ localPath: repo, projectId: 'project-life-a', storageName: 'repo-a-stable' });
+  assert.strictEqual(imported.ok, true);
+  assert.strictEqual(imported.config.aiProfileId, null, 'import must not require an AI profile');
+  assert.strictEqual(imported.state.trackingStartCommit, git(repo, ['rev-parse', 'HEAD']));
+  assert.strictEqual(imported.state.conversationBaselineCursor, 73, 'import must freeze the current Bridge cursor as its conversation baseline');
+  assert.deepStrictEqual(fs.readdirSync(imported.config.knowledgePath), [], 'import must not create TODO knowledge files');
+  assert.strictEqual(fs.readFileSync(claude, 'utf8'), '# user only\n');
+  assert.strictEqual(realHookManager.readHookStatus({ repoPath: repo, projectId: imported.projectId }).installed, true);
+  await assert.rejects(lifecycle.importProject({ localPath: repo }), /already imported/);
+
+  const conflictRepo = createRepo(root, 'repo-conflict');
+  const conflictPath = path.join(knowledgeRoot, 'conflict-stable');
+  fs.mkdirSync(conflictPath, { recursive: true });
+  fs.writeFileSync(path.join(conflictPath, 'user.md'), 'do not overwrite');
+  await assert.rejects(lifecycle.importProject({ localPath: conflictRepo, projectId: 'project-conflict', storageName: 'conflict-stable' }), error => error.code === 'MIGRATION_TARGET_CONFLICT');
+  assert(!registry.listIds().includes('project-conflict'));
+  assert.strictEqual(fs.readFileSync(path.join(conflictPath, 'user.md'), 'utf8'), 'do not overwrite');
+
+  const failingRepo = createRepo(root, 'repo-failing');
+  const failingHooks = { ...realHookManager, installHook() { throw new Error('injected Hook failure'); } };
+  const failingLifecycle = new ProjectLifecycleService({ layout, settingsStore: settings, registryStore: registry, projectStore: projects, triggerScriptPath: TRIGGER, hookManager: failingHooks });
+  await assert.rejects(failingLifecycle.importProject({ localPath: failingRepo, projectId: 'project-failing', storageName: 'failing-stable' }));
+  assert(!registry.listIds().includes('project-failing'));
+  assert(!fs.existsSync(layout.getProjectMetadataDir('project-failing')));
+  assert(!fs.existsSync(path.join(knowledgeRoot, 'failing-stable')));
+
+  const emptyRepo = createRepo(root, 'repo-empty', false);
+  const empty = await lifecycle.importProject({ localPath: emptyRepo, projectId: 'project-empty', storageName: 'empty-stable' });
+  assert.strictEqual(empty.state.trackingMode, 'empty-repo');
+  assert.strictEqual(empty.state.trackingStartCommit, null);
+
+  const failingDelete = new ProjectLifecycleService({
+    layout, settingsStore: settings, registryStore: registry, projectStore: projects, triggerScriptPath: TRIGGER,
+    hookManager: { ...realHookManager, uninstallHook() { throw new Error('injected uninstall failure'); } },
+  });
+  await assert.rejects(failingDelete.deleteProject(imported.projectId));
+  assert(registry.listIds().includes(imported.projectId), 'Hook uninstall failure must preserve registration');
+
+  const knowledgePath = imported.config.knowledgePath;
+  const deleted = await lifecycle.deleteProject(imported.projectId);
+  assert.strictEqual(deleted.removedKnowledge, false);
+  assert(fs.existsSync(knowledgePath), 'default delete must preserve external knowledge directory');
+  assert(!registry.listIds().includes(imported.projectId));
+
+  console.log('project-lifecycle-transaction-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});