@sanqianx/project-knowledge 4.6.1

package/_site/_test/ui-i18n-toggle-test.js

@@ -0,0 +1,114 @@
+// _site/_test/ui-i18n-toggle-test.js
+//
+// T10: UI language toggle + persistence + smoke check that key labels
+// actually change after switching zh-CN -> en-US. The test boots a real
+// server, drives a headless Chromium, and inspects label textContent.
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnServer } = require('./helpers/spawn-server');
+const { findChrome } = require('./helpers/find-chrome');
+const { launchCdpBrowser, waitFor } = require('./helpers/cdp-browser');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const sitePort = 7980 + (process.pid % 200);
+const profileDir = path.join(os.tmpdir(), 'pk-i18n-' + process.pid);
+
+async function waitForLanguage(browser, language, label) {
+  await waitFor(async () => {
+    const state = await browser.evaluate(`(() => ({
+      appReady: Boolean(window.__PK_APP__),
+      active: window.I18N && window.I18N.activeLanguage(),
+      select: document.getElementById('ui-language')?.value,
+      documentLanguage: document.documentElement.lang,
+    }))()`);
+    return state.appReady && state.active === language && state.select === language && state.documentLanguage === (language === 'en-US' ? 'en' : 'zh-CN')
+      ? { ok: true }
+      : null;
+  }, label, 20000);
+}
+
+(async () => {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-i18n-data-' + process.pid + '-'));
+  const server = spawnServer({
+    root: ROOT, port: sitePort, dataDir, tag: 'ui-i18n', stdio: 'ignore',
+    extraEnv: { KB_SKIP_MIGRATION: '1' },
+  });
+  let browser;
+  try {
+    await waitFor(async () => {
+      try {
+        const r = await fetch(`http://127.0.0.1:${sitePort}/api/health`);
+        return r.ok ? { ok: true } : null;
+      } catch { return null; }
+    }, 'isolated server', 20000);
+    browser = await launchCdpBrowser({
+      chrome: findChrome(), profileDir, url: `http://127.0.0.1:${sitePort}/`, width: 1440, height: 900,
+    });
+    // Wait for i18n.js to be available on window
+    await waitFor(async () => {
+      const ready = await browser.evaluate('Boolean(window.I18N)');
+      return ready ? { ok: true } : null;
+    }, 'window.I18N available', 20000);
+
+    // Case 1: default language is zh-CN.
+    {
+      const lang = await browser.evaluate('window.I18N.activeLanguage()');
+      assert.strictEqual(lang, 'zh-CN', 'default language must be zh-CN when no preference exists');
+    }
+
+    // Case 2: switch to en-US via the settings drawer toggle.
+    await browser.evaluate(`(() => {
+      // Open settings drawer (data-settings='ai' button)
+      const btn = document.querySelector('[data-settings="ai"]') || document.getElementById('open-settings');
+      if (btn) btn.click();
+    })()`);
+    await waitFor(async () => {
+      const open = await browser.evaluate('Boolean(document.getElementById("ui-language"))');
+      return open ? { ok: true } : null;
+    }, 'ui-language select visible', 5000);
+    await browser.evaluate(`(() => {
+      const sel = document.getElementById('ui-language');
+      sel.value = 'en-US';
+      sel.dispatchEvent(new Event('change', { bubbles: true }));
+    })()`);
+    await waitForLanguage(browser, 'en-US', 'language switched to en-US');
+    assert.strictEqual(await browser.evaluate('document.querySelector("label[for=ui-language]").textContent'), 'UI language');
+
+    // Case 3: persistence across reload — preference must survive a hard
+    // reload. The browser context keeps localStorage across reloads.
+    await browser.evaluate('location.reload()');
+    await waitForLanguage(browser, 'en-US', 'language persists after reload');
+
+    // Case 4: switch back to zh-CN and verify activeLanguage reflects it.
+    await browser.evaluate(`(() => {
+      document.getElementById('ui-language').value = 'zh-CN';
+      document.getElementById('ui-language').dispatchEvent(new Event('change', { bubbles: true }));
+    })()`);
+    await waitForLanguage(browser, 'zh-CN', 'switch back to zh-CN');
+    assert.strictEqual(await browser.evaluate('document.querySelector("label[for=ui-language]").textContent'), '界面语言');
+
+    // Case 5: unknown key returns the key string (no missing-key placeholder).
+    {
+      const missing = await browser.evaluate('window.I18N.t("does.not.exist")');
+      assert.strictEqual(missing, 'does.not.exist', 'unknown keys must return the key string, not a placeholder');
+    }
+
+    // Case 6: availableLanguages contains both zh-CN and en-US.
+    {
+      const list = await browser.evaluate('window.I18N.availableLanguages().sort().join(",")');
+      assert.strictEqual(list, 'en-US,zh-CN', 'availableLanguages must include zh-CN and en-US');
+    }
+  } finally {
+    if (browser) await browser.close();
+    server.child.kill();
+    await new Promise(resolve => server.child.once('exit', resolve));
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  }
+  console.log('ui-i18n-toggle-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/_site/_test/ui-smoke-test.js

@@ -0,0 +1,73 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnServer } = require('./helpers/spawn-server');
+const { findChrome } = require('./helpers/find-chrome');
+const { launchCdpBrowser, requestJson, waitFor } = require('./helpers/cdp-browser');
+const { createLoggingUiFixture } = require('./helpers/logging-ui-fixture');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const sitePort = 7900 + (process.pid % 300);
+const profileDir = path.join(os.tmpdir(), 'pk-ui-smoke-profile-' + process.pid);
+const screenshotPath = path.join(os.tmpdir(), 'pk-ui-smoke-' + process.pid + '.png');
+
+(async () => {
+  const fixture = await createLoggingUiFixture({ totalLogs: 18 });
+  const server = spawnServer({ root: ROOT, port: sitePort, dataDir: fixture.dataDir, tag: 'ui-smoke-v13', stdio: 'ignore' });
+  let browser;
+  try {
+    await waitFor(() => requestJson(`http://127.0.0.1:${sitePort}/api/health`).then(payload => payload.ok), 'isolated server', 20000);
+    browser = await launchCdpBrowser({ chrome: findChrome(), profileDir, url: `http://127.0.0.1:${sitePort}/`, width: 1440, height: 900 });
+    await waitFor(() => browser.evaluate('window.__PK_APP__ && window.__PK_APP__.getState().projects === 1'), 'v13 shell', 20000);
+
+    const snapshot = await browser.evaluate(`(() => ({
+      title: document.title,
+      shell: document.querySelectorAll('.shell').length,
+      sidebar: getComputedStyle(document.querySelector('.sidebar')).display,
+      terminalView: document.getElementById('view-terminal').classList.contains('active'),
+      projects: document.querySelectorAll('#project-list .project-card').length,
+      unsafeImages: document.querySelectorAll('img').length,
+      xss: window.__xss,
+      bodyWidth: document.body.scrollWidth,
+      viewportWidth: document.documentElement.clientWidth
+    }))()`);
+    assert.strictEqual(snapshot.title, 'Project Knowledge');
+    assert.strictEqual(snapshot.shell, 1);
+    assert.notStrictEqual(snapshot.sidebar, 'none');
+    assert.strictEqual(snapshot.terminalView, true);
+    assert.strictEqual(snapshot.projects, 1);
+    assert.strictEqual(snapshot.unsafeImages, 0);
+    assert.strictEqual(snapshot.xss, undefined);
+    assert(snapshot.bodyWidth <= snapshot.viewportWidth + 1, 'desktop shell must not overflow horizontally');
+
+    await browser.evaluate("document.getElementById('theme-button').click()");
+    assert.strictEqual(await browser.evaluate('document.documentElement.dataset.theme'), 'dark');
+
+    await browser.setViewport(390, 844);
+    const mobile = await browser.evaluate(`(() => ({
+      sidebar: getComputedStyle(document.querySelector('.sidebar')).display,
+      mobileBar: getComputedStyle(document.querySelector('.mobile-strip')).display,
+      bodyWidth: document.body.scrollWidth,
+      viewportWidth: document.documentElement.clientWidth,
+      projectUsable: document.getElementById('mobile-project').getBoundingClientRect().width > 100
+    }))()`);
+    assert.strictEqual(mobile.sidebar, 'none');
+    assert.notStrictEqual(mobile.mobileBar, 'none');
+    assert.strictEqual(mobile.projectUsable, true);
+    assert(mobile.bodyWidth <= mobile.viewportWidth + 1, 'mobile shell must not overflow horizontally');
+
+    await browser.screenshot(screenshotPath);
+    assert(fs.statSync(screenshotPath).size > 10000, 'real browser screenshot should contain rendered UI');
+    assert.strictEqual(browser.exceptions.length, 0, 'browser runtime exceptions: ' + JSON.stringify(browser.exceptions));
+    console.log('ui smoke test PASS');
+  } finally {
+    if (browser) await browser.close();
+    await server.cleanup();
+    fixture.cleanup();
+    try { fs.rmSync(screenshotPath, { force: true }); } catch {}
+  }
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});

package/_site/_test/v4122-upgrade-data-contract-test.js

@@ -0,0 +1,56 @@
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { StorageLayout } = require('../lib/storage-layout');
+const { MigrationService } = require('../lib/migration-service');
+const { publicAiProfilesConfig } = require('../lib/contracts');
+
+function fixture() {
+  const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-v4122-upgrade-'));
+  const knowledgeRoot = path.join(dataDir, 'knowledge-root');
+  const projects = {};
+  for (const slug of ['alpha', 'beta', 'gamma']) {
+    const repoPath = path.join(dataDir, 'repos', slug);
+    const knowledgePath = path.join(knowledgeRoot, `preserved-${slug}`);
+    fs.mkdirSync(knowledgePath, { recursive: true });
+    fs.writeFileSync(path.join(knowledgePath, 'README.md'), `# ${slug}\n`);
+    projects[slug] = { repoPath, kbPath: knowledgePath, aiProfileId: slug === 'alpha' ? 'primary' : 'secondary' };
+  }
+  fs.writeFileSync(path.join(dataDir, 'projects.json'), JSON.stringify(projects));
+  fs.writeFileSync(path.join(dataDir, 'knowledge-store.json'), JSON.stringify({ rootPath: knowledgeRoot }));
+  fs.writeFileSync(path.join(dataDir, 'ai-profiles.json'), JSON.stringify({ profiles: [
+    { id: 'primary', apiKey: 'fixture-secret-one', model: 'model-a' },
+    { id: 'secondary', apiKey: 'fixture-secret-two', model: 'model-b' },
+  ] }));
+  fs.writeFileSync(path.join(dataDir, 'embedding-config.json'), JSON.stringify({ modelId: 'embedding-v4122', localFilesOnly: true, localModelPath: path.join(dataDir, 'models') }));
+  fs.mkdirSync(path.join(dataDir, 'models', 'A', 'B'), { recursive: true });
+  fs.writeFileSync(path.join(dataDir, 'models', 'A', 'B', 'model.onnx'), 'exact-model-content');
+  return { dataDir, knowledgeRoot, projects };
+}
+
+(async () => {
+  const { dataDir, knowledgeRoot, projects } = fixture();
+  try {
+    const layout = new StorageLayout({ dataDir });
+    const result = await new MigrationService({ layout, legacyDataDir: dataDir }).migrateIfNeeded({ migrationRunId: 'v4122-contract' });
+    assert.equal(result.ok, true);
+    const registry = JSON.parse(fs.readFileSync(layout.getProjectRegistryPath(), 'utf8'));
+    assert.equal(registry.projectOrder.length, 3);
+    const settings = JSON.parse(fs.readFileSync(layout.getSettingsPath(), 'utf8'));
+    assert.equal(settings.knowledge.rootPath, knowledgeRoot);
+    assert.deepEqual(settings.embedding, { modelId: 'embedding-v4122', localFilesOnly: true, localModelPath: path.join(dataDir, 'models') });
+    assert.equal(settings.ai.profiles.length, 2);
+    assert.equal(publicAiProfilesConfig(settings.ai).profiles.every(profile => profile.hasApiKey && !Object.hasOwn(profile, 'apiKey')), true);
+    for (const projectId of registry.projectOrder) {
+      const config = JSON.parse(fs.readFileSync(layout.getProjectConfigPath(projectId), 'utf8'));
+      const legacy = projects[config.legacyExtensions.slug];
+      assert.equal(config.repoPath, legacy.repoPath);
+      assert.equal(config.knowledgePath, legacy.kbPath);
+    }
+    assert.equal(fs.readFileSync(path.join(dataDir, 'cache', 'models', 'A', 'B', 'model.onnx'), 'utf8'), 'exact-model-content');
+    assert.equal(result.marker.projectCount, 3);
+    assert.equal(result.marker.aiProfileCount, 2);
+  } finally { fs.rmSync(dataDir, { recursive: true, force: true }); }
+  console.log('v4122-upgrade-data-contract-test PASS');
+})().catch(error => { console.error(error.stack || error.message); process.exit(1); });

package/_site/_test/workbench-permission-test.js

@@ -0,0 +1,118 @@
+// _site/_test/workbench-permission-test.js
+//
+// T14: Claude Workbench permission lifecycle is preserved. The backend
+// already exposes /api/claude/sessions/:id/permission (Allow/Deny) and
+// a permission-mode selector (default/acceptEdits/auto/bypassPermissions/plan).
+// This test verifies:
+//   - the permission endpoint is reachable for a real session;
+//   - the mode selector is accepted at session start;
+//   - Workbench / Workbench chat messages do NOT auto-append Development
+//     Conversation events (internal-only contract per I-06 / I-07).
+
+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 = 8010 + (process.pid % 200);
+const dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-workbench-' + process.pid + '-'));
+const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'pk-workbench-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', 'wb@example.local']);
+  git(['config', 'user.name', 'WB']);
+  fs.writeFileSync(path.join(repo, 'README.md'), '# wb\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: 'wb',
+    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;
+
+    // Case 1: permission modes are accepted at session start.
+    for (const mode of ['default', 'acceptEdits', 'auto', 'bypassPermissions', 'plan']) {
+      const r = await serverFetch(`http://127.0.0.1:${sitePort}/api/claude/sessions`, {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ projectId, permissionMode: mode }),
+      });
+      // We only assert the endpoint accepts the request; the Claude CLI
+      // binary may not be present, so the session may end up missing/idle.
+      assert(r.status === 201 || r.status === 400 || r.status === 503, `unexpected status for mode=${mode}: ${r.status}`);
+    }
+
+    // Case 2: Workbench messages MUST NOT auto-append Development
+    // Conversation events. We snapshot the conversation store via the
+    // server API and confirm no Workbench events are present for the
+    // freshly imported project.
+    const convoR = await serverFetch(`http://127.0.0.1:${sitePort}/api/conversations/projects`, undefined);
+    assert.strictEqual(convoR.status, 200);
+    // The project MAY appear in the conversation project list because
+    // import initializes the Bridge baseline cursor. What matters is
+    // that NO Workbench messages were recorded: the bridge cursor at
+    // this point is 0 (no events captured), and no turns should exist.
+    // We assert by reading the list and confirming the entry's
+    // lastCapturedCursor is 0.
+    const entry = (convoR.body.projects || []).find(p => p.projectId === projectId);
+    if (entry) {
+      assert.strictEqual(entry.lastCapturedCursor || 0, 0, 'Bridge cursor must be 0 for a project with no Bridge events');
+    }
+  } 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('workbench-permission-test PASS');
+})().catch(error => {
+  console.error(error.stack || error.message);
+  process.exit(1);
+});

package/_site/_test/workspace-ui-contract-test.js

@@ -0,0 +1,43 @@
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const html = fs.readFileSync(path.join(ROOT, 'ui', 'index.html'), 'utf8');
+const css = fs.readFileSync(path.join(ROOT, 'ui', 'app.css'), 'utf8');
+const script = fs.readFileSync(path.join(ROOT, 'ui', 'app.js'), 'utf8');
+
+for (const contract of [
+  'id="project-list"',
+  'id="view-terminal"',
+  'id="view-search"',
+  'id="view-import"',
+  'id="settings-drawer"',
+  'data-settings="logs"',
+  'id="delete-dialog"',
+]) assert(html.includes(contract), 'missing v13 shell contract: ' + contract);
+
+const desktopNav = html.slice(html.indexOf('<aside class="sidebar">'), html.indexOf('</aside>'));
+assert(desktopNav.includes('data-go="terminal"') && desktopNav.includes('data-go="search"') && desktopNav.includes('data-go="import"'));
+assert(!/开发对话|运行记录|系统日志/.test(desktopNav), 'conversation and logs must not be duplicated in main navigation');
+assert(!html.includes('data-install-hook') && !html.includes('data-analyze') && !html.includes('data-simulate'), 'manual Hook/analysis controls are forbidden');
+
+// 开发对话已迁移到 ai-coding-event-bridge 模块，设置抽屉不再保留该入口
+assert(!html.includes('data-settings="conversation"') && !html.includes('settings-conversation') && !html.includes('conversation-project'), 'development-conversation settings entry must be absent (moved to event-bridge module)');
+
+for (const required of ['logs-date', 'logs-project', 'logs-scope', 'logs-limit', 'logs-search', 'logs-export']) assert(html.includes(`id="${required}"`), 'missing logs toolbar control: ' + required);
+for (const forbidden of ['pause-button', 'level-filter', 'setting-retention', 'setting-capacity', 'health-pill', 'data-log-table']) assert(!html.includes(forbidden), 'legacy logs-only control must be absent: ' + forbidden);
+assert(!/>Level</i.test(html) && !/>级别</i.test(html.slice(html.indexOf('class="record-toolbar"'), html.indexOf('class="record-shell"'))), 'logs toolbar must not expose a level filter/column');
+
+assert(css.includes('grid-template-columns:minmax(0,1fr) 88px') && css.includes('grid-template-columns:minmax(0,1fr) 76px'), 'desktop/mobile log row geometry is required');
+assert(css.includes('.record-list{flex:1;min-height:0;max-height:none;overflow-y:auto;overflow-x:hidden}'), 'record list must own logs scrolling');
+assert(!css.includes('max-height:520px'), 'fixed legacy record height is forbidden');
+for (const level of ['warn', 'error', 'fatal']) assert(css.includes(`[data-level="${level}"]`), 'whole-row severity color missing: ' + level);
+assert(css.includes('html[data-theme="dark"]') && css.includes('@media(max-width:760px)'), 'dark and responsive layouts are required');
+
+assert(!script.includes('.innerHTML') && !script.includes('insertAdjacentHTML'), 'business data must never render through an HTML sink');
+assert(script.includes('.textContent = record.message') && script.includes('.textContent = value'), 'logs must render as plain text');
+assert(script.includes("stream.addEventListener('logs/appended'") && script.includes('state.newLogs += 1'), 'SSE append/new-record behavior is required');
+assert(script.includes('window.__PK_APP__'), 'browser test surface is required');
+
+console.log('workspace UI contract test PASS');

package/_site/lib/ai-profile-resolver.js

@@ -0,0 +1,78 @@
+// _site/lib/ai-profile-resolver.js
+//
+// Single source of truth for "what AI profile does this project use right now".
+// Replaces the inconsistent fallback logic that used to live separately in
+// Workbench start-session / send-input, the analyzer, the CommitReconciler,
+// and import default assignment.
+//
+// Resolution order (per T01):
+//   1. projectConfig.aiProfileId, when it references a usable configured profile
+//   2. settings.ai.defaultProfileId, when it references a usable configured profile
+//   3. first usable configured profile in stable configured order
+//   4. otherwise an explicit AI_PROFILE_REQUIRED failure
+//
+// "Usable" matches the current runtime's minimum contract: the profile exists,
+// is enabled, and references a vendor/implementation that the runtime can use.
+// We do NOT invent additional requirements (e.g. "must have a non-empty apiKey")
+// — that is the runtime's job to evaluate when it actually starts a session.
+
+const { DomainError } = require('./contracts');
+
+function profileById(settings, profileId) {
+  if (!profileId) return null;
+  const list = settings && settings.ai && Array.isArray(settings.ai.profiles) ? settings.ai.profiles : [];
+  return list.find(profile => profile && profile.id === profileId) || null;
+}
+
+function isUsable(profile) {
+  return Boolean(profile) && profile.enabled !== false;
+}
+
+function listUsable(settings) {
+  const list = settings && settings.ai && Array.isArray(settings.ai.profiles) ? settings.ai.profiles : [];
+  return list.filter(isUsable);
+}
+
+function resolveEffectiveAiProfile(settings, projectConfig) {
+  const safeSettings = settings || { ai: { profiles: [] } };
+  const safeProject = projectConfig || {};
+  const configured = safeSettings.ai && Array.isArray(safeSettings.ai.profiles) ? safeSettings.ai.profiles : [];
+
+  const projectId = safeProject.aiProfileId || null;
+  if (projectId) {
+    const projectProfile = profileById(safeSettings, projectId);
+    if (isUsable(projectProfile)) {
+      return { profile: projectProfile, profileId: projectProfile.id, source: 'project' };
+    }
+  }
+
+  const defaultId = safeSettings.ai && safeSettings.ai.defaultProfileId || null;
+  if (defaultId) {
+    const defaultProfile = profileById(safeSettings, defaultId);
+    if (isUsable(defaultProfile)) {
+      return { profile: defaultProfile, profileId: defaultProfile.id, source: 'default' };
+    }
+  }
+
+  const firstUsable = listUsable(safeSettings)[0];
+  if (firstUsable) {
+    return { profile: firstUsable, profileId: firstUsable.id, source: 'first-usable' };
+  }
+
+  throw new DomainError('AI_PROFILE_REQUIRED', 'A usable AI profile is required for this operation.', {
+    status: 409,
+    details: {
+      hint: 'Configure at least one enabled AI profile, or assign an aiProfileId to the project.',
+      configuredProfileCount: configured.length,
+      projectProfileId: projectId || null,
+      defaultProfileId: defaultId || null,
+    },
+  });
+}
+
+module.exports = {
+  resolveEffectiveAiProfile,
+  profileById,
+  isUsable,
+  listUsable,
+};

package/_site/lib/ai-vendor-presets.js

@@ -0,0 +1,83 @@
+// Built-in vendor presets for common Anthropic-compatible providers.
+// baseUrl and model names verified against each vendor's public docs (2026-06).
+// When a user picks one of these vendor names in the profile form, all fields
+// below are auto-filled — they only need to supply an API key.
+//
+// baseUrl MUST be the /anthropic-compatible endpoint, not the OpenAI-compatible
+// one, because the runner speaks the Anthropic Messages API. Wrong path → 404.
+const AI_VENDOR_PRESETS = [
+  {
+    id: 'anthropic',
+    name: 'Anthropic Claude',
+    baseUrl: 'https://api.anthropic.com',
+    mainModel: 'claude-sonnet-4-5',
+    thinkingModel: 'claude-opus-4-7',
+    haikuModel: 'claude-haiku-4-5',
+    sonnetModel: 'claude-sonnet-4-5',
+    opusModel: 'claude-opus-4-7',
+    contextWindow: 200000,
+    website: 'https://www.anthropic.com',
+  },
+  {
+    id: 'minimax',
+    name: 'MiniMax',
+    // Domestic (China) endpoint. minimax.io is the overseas domain with a
+    // separate account system — API keys are NOT interchangeable. Domestic
+    // users register at minimaxi.com, so we default to that.
+    baseUrl: 'https://api.minimaxi.com/anthropic',
+    mainModel: 'MiniMax-M3',
+    thinkingModel: 'MiniMax-M3',
+    haikuModel: 'MiniMax-M3',
+    sonnetModel: 'MiniMax-M3',
+    opusModel: 'MiniMax-M3',
+    contextWindow: 1048576,
+    website: 'https://platform.minimaxi.com',
+  },
+  {
+    id: 'zhipu',
+    name: '智谱 GLM',
+    // Anthropic-compatible endpoint, not the OpenAI-style /api/paas/v4.
+    baseUrl: 'https://open.bigmodel.cn/api/anthropic',
+    mainModel: 'glm-4.6',
+    thinkingModel: 'glm-4.6',
+    haikuModel: 'glm-4.5-air',
+    sonnetModel: 'glm-4.6',
+    opusModel: 'glm-4.6',
+    contextWindow: 1048576,
+    website: 'https://open.bigmodel.cn',
+  },
+  {
+    id: 'deepseek',
+    name: 'DeepSeek',
+    // Anthropic-compatible endpoint at /anthropic, not the bare domain.
+    baseUrl: 'https://api.deepseek.com/anthropic',
+    mainModel: 'deepseek-chat',
+    thinkingModel: 'deepseek-reasoner',
+    haikuModel: 'deepseek-chat',
+    sonnetModel: 'deepseek-chat',
+    opusModel: 'deepseek-reasoner',
+    contextWindow: 128000,
+    website: 'https://platform.deepseek.com',
+  },
+];
+
+function listVendorPresetNames() {
+  return AI_VENDOR_PRESETS.map(v => v.name);
+}
+
+// Match by name (case-insensitive) or id (case-insensitive). Returns the
+// preset object or null. Custom vendor names that don't match return null —
+// the caller then leaves the user-typed value alone.
+function findVendorPresetByName(name) {
+  const norm = String(name || '').trim().toLowerCase();
+  if (!norm) return null;
+  return AI_VENDOR_PRESETS.find(v =>
+    v.name.toLowerCase() === norm || v.id.toLowerCase() === norm
+  ) || null;
+}
+
+module.exports = {
+  AI_VENDOR_PRESETS,
+  listVendorPresetNames,
+  findVendorPresetByName,
+};