@work-graph/cli 0.2.0

package/vendor/src/workGraphPhasePromoteReadyQueue.mjs

@@ -0,0 +1,159 @@
+import {
+  evaluatePromoteReadyEligibility,
+  isPromotableBacklogItem,
+} from './workGraphRuntime.mjs';
+
+export const PHASE_8_PLUS_ANCHORS = [
+  'phase-8-agent-prompt-eval-tools',
+  'phase-9-ui-operator-shell',
+  'phase-10-ci-e2e-release-gates',
+  'phase-11-gbc-gfs-gvm-deferred',
+];
+
+const PRIORITY_ORDER = new Map([
+  ['critical', 0],
+  ['high', 1],
+  ['medium', 2],
+  ['low', 3],
+]);
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export function extractPhaseNumberFromWorkId(workId) {
+  const match = String(workId ?? '').match(/^phase-(\d+)/u);
+  return match ? Number(match[1]) : null;
+}
+
+export function extractPhaseNumberFromLabels(labels = {}) {
+  const targetPhase = String(labels['migration.target_phase'] ?? '').trim();
+  const fromTarget = extractPhaseNumberFromWorkId(targetPhase);
+  if (fromTarget !== null) {
+    return fromTarget;
+  }
+
+  return null;
+}
+
+export function buildPhaseAffinityIndex(items) {
+  const itemById = new Map(items.map((item) => [item.id, item]));
+  const affinity = new Map();
+
+  for (const item of items) {
+    const direct = extractPhaseNumberFromWorkId(item.id) ?? extractPhaseNumberFromLabels(item.labels);
+    if (direct !== null) {
+      affinity.set(item.id, direct);
+    }
+  }
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const item of items) {
+      if (affinity.has(item.id)) {
+        continue;
+      }
+
+      const deps = item.dependsOn ?? [];
+      const depPhases = deps
+        .map((depId) => affinity.get(depId))
+        .filter((phase) => Number.isInteger(phase));
+
+      if (depPhases.length > 0) {
+        affinity.set(item.id, Math.min(...depPhases));
+        changed = true;
+        continue;
+      }
+
+      if (PHASE_8_PLUS_ANCHORS.some((anchorId) => deps.includes(anchorId))) {
+        const anchorPhase = Math.min(
+          ...PHASE_8_PLUS_ANCHORS
+            .filter((anchorId) => deps.includes(anchorId))
+            .map((anchorId) => extractPhaseNumberFromWorkId(anchorId) ?? 99),
+        );
+        affinity.set(item.id, anchorPhase);
+        changed = true;
+      }
+    }
+  }
+
+  for (const anchorId of PHASE_8_PLUS_ANCHORS) {
+    const phase = extractPhaseNumberFromWorkId(anchorId);
+    if (phase !== null) {
+      affinity.set(anchorId, phase);
+    }
+  }
+
+  return { affinity, itemById };
+}
+
+export function resolveWorkItemPhase(item, affinityIndex) {
+  return affinityIndex.affinity.get(item.id)
+    ?? extractPhaseNumberFromWorkId(item.id)
+    ?? extractPhaseNumberFromLabels(item.labels);
+}
+
+export function isWorkItemAtLeastMinPhase(item, affinityIndex, minPhase = 8) {
+  const phase = resolveWorkItemPhase(item, affinityIndex);
+  return Number.isInteger(phase) && phase >= minPhase;
+}
+
+/** @deprecated Prefer {@link isWorkItemAtLeastMinPhase} with explicit minPhase. */
+export function isPhase8PlusWorkItem(item, affinityIndex) {
+  return isWorkItemAtLeastMinPhase(item, affinityIndex, 8);
+}
+
+export function comparePromoteQueueItems(left, right) {
+  const byPriority = (PRIORITY_ORDER.get(left.priority) ?? 9) - (PRIORITY_ORDER.get(right.priority) ?? 9);
+  if (byPriority !== 0) {
+    return byPriority;
+  }
+
+  return compareText(left.id, right.id);
+}
+
+export function buildPhasePromoteReadyQueue(items, options = {}) {
+  const minPhase = Number.isInteger(options.minPhase) ? options.minPhase : 8;
+  const limit = Number.isInteger(options.limit) ? options.limit : 12;
+  const affinityIndex = buildPhaseAffinityIndex(items);
+
+  const backlogPhaseItems = items.filter(
+    (item) => item.status === 'backlog' && isWorkItemAtLeastMinPhase(item, affinityIndex, minPhase),
+  );
+
+  const promotable = backlogPhaseItems
+    .filter((item) => isPromotableBacklogItem(items, item))
+    .map((item) => ({
+      workId: item.id,
+      title: item.title,
+      priority: item.priority,
+      phase: affinityIndex.affinity.get(item.id) ?? null,
+      dependsOn: [...(item.dependsOn ?? [])],
+      nextAction: item.nextAction,
+    }))
+    .sort(comparePromoteQueueItems)
+    .slice(0, limit);
+
+  const blocked = backlogPhaseItems
+    .filter((item) => !isPromotableBacklogItem(items, item))
+    .map((item) => {
+      const eligibility = evaluatePromoteReadyEligibility(items, item.id);
+      return {
+        workId: item.id,
+        title: item.title,
+        phase: affinityIndex.affinity.get(item.id) ?? null,
+        error: eligibility.error ?? 'not_promotable',
+        unsatisfiedDependencies: eligibility.unsatisfiedDependencies ?? [],
+      };
+    })
+    .sort((left, right) => compareText(left.workId, right.workId));
+
+  return {
+    schema: 'workgraph.promote-ready-queue.v1',
+    minPhase,
+    phaseAnchors: [...PHASE_8_PLUS_ANCHORS],
+    queue: promotable,
+    blocked,
+    backlogCount: backlogPhaseItems.length,
+    promotableCount: promotable.length,
+  };
+}

package/vendor/src/workGraphProjectHost.mjs

@@ -0,0 +1,149 @@
+import { resolve } from 'node:path';
+
+import {
+  defaultRegistryPath,
+  findWorkspace,
+  listWorkspaces,
+  readWorkspaceRegistry,
+  registerWorkspace,
+  resolveWorkspaceRoot,
+  setActiveWorkspace,
+  slugFromRoot,
+} from './workspaceRegistry.mjs';
+
+export function createWorkGraphHostState(options = {}) {
+  const hostRoot = resolve(options.hostRoot ?? options.cwd ?? process.cwd());
+  return {
+    hostRoot,
+    registryPath: options.registryPath ?? defaultRegistryPath(options),
+    activeProjectId: null,
+    initialized: false,
+  };
+}
+
+export function resolveRepoRootFromEnv() {
+  const fromEnv = String(process.env.WG_PROJECT_ROOT ?? '').trim();
+  return fromEnv === '' ? null : resolve(fromEnv);
+}
+
+export async function ensureHostStateInitialized(hostState, options = {}) {
+  if (hostState.initialized) {
+    return hostState;
+  }
+
+  const hostRoot = hostState.hostRoot;
+  let registry = await readWorkspaceRegistry({ registryPath: hostState.registryPath });
+
+  const hostSlug = slugFromRoot(hostRoot);
+  if (!findWorkspace(registry, hostSlug)) {
+    registry = await registerWorkspace({
+      id: hostSlug,
+      root: hostRoot,
+      label: options.hostLabel ?? 'Work Graph',
+    }, { registryPath: hostState.registryPath });
+  }
+
+  const envRoot = resolveRepoRootFromEnv();
+  if (envRoot) {
+    const envId = slugFromRoot(envRoot);
+    registry = await registerWorkspace({
+      id: envId,
+      root: envRoot,
+      label: options.envLabel ?? basenameOrSlug(envRoot),
+    }, { registryPath: hostState.registryPath });
+    registry = await setActiveWorkspace(envId, { registryPath: hostState.registryPath });
+  }
+
+  hostState.activeProjectId = registry.activeProjectId
+    ?? findWorkspace(registry, hostSlug)?.id
+    ?? hostSlug;
+  hostState._registryCache = registry;
+  hostState.initialized = true;
+  return hostState;
+}
+
+function basenameOrSlug(root) {
+  const parts = resolve(root).split(/[\\/]/u);
+  return parts[parts.length - 1] || slugFromRoot(root);
+}
+
+export function resolveWorkGraphRequestContext(hostState, url, options = {}) {
+  if (!hostState?.initialized) {
+    throw new Error('hostState is not initialized');
+  }
+
+  const queryProjectId = url?.searchParams?.get('projectId')?.trim() || null;
+  const queryRepoRoot = url?.searchParams?.get('repoRoot')?.trim() || null;
+  const projectId = queryProjectId || hostState.activeProjectId;
+  let repoRoot = queryRepoRoot ? resolve(queryRepoRoot) : null;
+
+  if (!repoRoot && projectId) {
+    const registry = hostState._registryCache ?? { workspaces: [] };
+    repoRoot = resolveWorkspaceRoot(registry, projectId);
+  }
+
+  if (!repoRoot) {
+    repoRoot = hostState.hostRoot;
+  }
+
+  return {
+    hostRoot: hostState.hostRoot,
+    registryPath: hostState.registryPath,
+    activeProjectId: hostState.activeProjectId,
+    projectId: projectId ?? slugFromRoot(repoRoot),
+    repoRoot,
+    backlogPath: options.backlogPath,
+    journalPath: options.journalPath,
+    auditPath: options.auditPath,
+  };
+}
+
+export async function refreshHostRegistryCache(hostState) {
+  const registry = await readWorkspaceRegistry({ registryPath: hostState.registryPath });
+  hostState._registryCache = registry;
+  hostState.activeProjectId = registry.activeProjectId ?? hostState.activeProjectId;
+  return registry;
+}
+
+export async function buildWorkspacesApiResponse(hostState) {
+  await refreshHostRegistryCache(hostState);
+  const payload = await listWorkspaces({ registryPath: hostState.registryPath });
+  const active = findWorkspace(
+    { workspaces: payload.workspaces },
+    hostState.activeProjectId,
+  );
+  return {
+    ...payload,
+    activeProjectId: hostState.activeProjectId,
+    activeRepoRoot: active?.root ?? hostState.hostRoot,
+    hostRoot: hostState.hostRoot,
+  };
+}
+
+export async function switchHostWorkspace(hostState, projectId) {
+  const registry = await setActiveWorkspace(projectId, { registryPath: hostState.registryPath });
+  hostState._registryCache = registry;
+  hostState.activeProjectId = registry.activeProjectId;
+  const active = findWorkspace(registry, hostState.activeProjectId);
+  return {
+    ok: true,
+    schema: 'workgraph.workspace.switch.v1',
+    activeProjectId: hostState.activeProjectId,
+    activeRepoRoot: active?.root ?? hostState.hostRoot,
+  };
+}
+
+export async function registerHostWorkspace(hostState, input = {}) {
+  const registry = await registerWorkspace(input, { registryPath: hostState.registryPath });
+  hostState._registryCache = registry;
+  if (!hostState.activeProjectId) {
+    hostState.activeProjectId = registry.activeProjectId;
+  }
+  const entry = findWorkspace(registry, String(input.id ?? input.projectId ?? slugFromRoot(input.root ?? input.path)));
+  return {
+    ok: true,
+    schema: 'workgraph.workspace.register.v1',
+    workspace: entry,
+    activeProjectId: hostState.activeProjectId,
+  };
+}

package/vendor/src/workGraphProjectInit.mjs

@@ -0,0 +1,392 @@
+import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+import {
+  buildDoctorReport,
+  defaultEngineRootFromCliModule,
+  importBacklogUiServer,
+  importMcpServer,
+  resolveEngineRoot,
+} from './workGraphEngineRoot.mjs';
+
+export {
+  buildDoctorReport,
+  defaultEngineRootFromCliModule,
+  importBacklogUiServer,
+  importMcpServer,
+  resolveEngineRoot,
+};
+
+const CONFIG_SCHEMA_V1 = 'workgraph.project.config.v1';
+const CONFIG_SCHEMA_V2 = 'workgraph.project.config.v2';
+const DEFAULT_CLI_VERSION = '0.2.0';
+const DEFAULT_MCP_VERSION = '0.2.0';
+
+const INDEX_STUB = `#Index<[
+WorkItems:
+]>
+`;
+const MAIN_BVC_STUB = `#Architecture_Main<[
+Базис:
+  Каркас architecture/main.bvc создан через work-graph init.
+]>
+`;
+
+export function buildProjectConfig({ projectRoot, engineRoot, label, id, uiPort, schemaVersion = 2 } = {}) {
+  const root = resolve(projectRoot);
+  const config = {
+    schema: schemaVersion === 1 ? CONFIG_SCHEMA_V1 : CONFIG_SCHEMA_V2,
+    projectRoot: root,
+    projectId: id ?? slugFromPath(root),
+    label: label ?? basename(root),
+    uiPort: uiPort ?? 4177,
+    createdAt: new Date().toISOString(),
+  };
+  if (schemaVersion === 1 && engineRoot) {
+    config.engineRoot = resolve(engineRoot);
+  }
+  return config;
+}
+
+export function slugFromPath(root) {
+  const name = basename(resolve(root));
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/gu, '-')
+    .replace(/^-+|-+$/gu, '') || 'project';
+}
+
+export function buildRunUiScriptContent() {
+  return `#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+
+const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const config = JSON.parse(readFileSync(join(projectRoot, '.work-graph/config.json'), 'utf8'));
+
+process.env.WG_PROJECT_ROOT = projectRoot;
+process.env.WORKGRAPH_ROOT = projectRoot;
+
+function resolveInstallRoot() {
+  if (process.env.WORKGRAPH_ENGINE_ROOT) {
+    return resolve(process.env.WORKGRAPH_ENGINE_ROOT);
+  }
+  if (config.engineRoot) {
+    console.warn('[work-graph] config.engineRoot устарел — используйте npm packages');
+    return resolve(config.engineRoot);
+  }
+  const require = createRequire(join(projectRoot, 'package.json'));
+  const cliPkg = require.resolve('@work-graph/cli/package.json');
+  return dirname(cliPkg);
+}
+
+function resolveUiModule(installRoot) {
+  const candidates = [
+    join(installRoot, 'vendor/src/workGraphBacklogUiServer.mjs'),
+    join(installRoot, 'src/workGraphBacklogUiServer.mjs'),
+  ];
+  for (const candidate of candidates) {
+    try {
+      readFileSync(candidate);
+      return candidate;
+    } catch {
+      // try next
+    }
+  }
+  throw new Error('workGraphBacklogUiServer.mjs не найден — npm install -D @work-graph/cli');
+}
+
+const installRoot = resolveInstallRoot();
+const { startBacklogUiServer } = await import(pathToFileURL(resolveUiModule(installRoot)).href);
+
+const port = Number(process.env.WORKGRAPH_BACKLOG_UI_PORT ?? config.uiPort ?? 4177);
+const { host, port: boundPort } = await startBacklogUiServer({
+  hostRoot: projectRoot,
+  cwd: projectRoot,
+  hostLabel: config.label,
+  port,
+});
+
+console.log(\`Work Graph UI (\${config.label ?? projectRoot}): http://\${host}:\${boundPort}/\`);
+`;
+}
+
+export function buildRunMcpScriptContent() {
+  return `#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+
+const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const config = JSON.parse(readFileSync(join(projectRoot, '.work-graph/config.json'), 'utf8'));
+
+process.env.WG_PROJECT_ROOT = projectRoot;
+process.env.WORKGRAPH_ROOT = projectRoot;
+
+function resolveInstallRoot() {
+  if (process.env.WORKGRAPH_ENGINE_ROOT) {
+    return resolve(process.env.WORKGRAPH_ENGINE_ROOT);
+  }
+  if (config.engineRoot) {
+    console.warn('[work-graph] config.engineRoot устарел — используйте npm packages');
+    return resolve(config.engineRoot);
+  }
+  const require = createRequire(join(projectRoot, 'package.json'));
+  const cliPkg = require.resolve('@work-graph/cli/package.json');
+  return dirname(cliPkg);
+}
+
+function resolveMcpModule(installRoot) {
+  const candidates = [
+    join(installRoot, 'vendor/packages/workgraph-mcp/src/index.mjs'),
+    join(installRoot, 'packages/workgraph-mcp/src/index.mjs'),
+  ];
+  for (const candidate of candidates) {
+    try {
+      readFileSync(candidate);
+      return candidate;
+    } catch {
+      // try next
+    }
+  }
+  throw new Error('workgraph-mcp entry не найден — npm install -D @work-graph/mcp');
+}
+
+const installRoot = resolveInstallRoot();
+await import(pathToFileURL(resolveMcpModule(installRoot)).href);
+`;
+}
+
+export function buildCursorRuleContent({ label } = {}) {
+  const projectLabel = label ?? 'этот проект';
+  return `---
+description: Work Graph — канон и бэклог в intent/ (${projectLabel})
+alwaysApply: true
+---
+
+# Work Graph в проекте
+
+- Канон задач: \`intent/**/work/*.work.bvc\`, индекс \`intent/index.bvc\`.
+- Trackable work — только через \`work.id\`; не дублировать в чат-todo.
+- Перед закрытием задачи — \`Свидетельства:\` в atom и проверки из \`Проверки:\`.
+- UI: \`npm run workgraph:ui\` → http://127.0.0.1:4177/
+- MCP: сервер \`workgraph\` в \`.cursor/mcp.json\` (если настроен при init).
+
+Установка: \`npx @work-graph/cli init .\` или «установи Work Graph в этот проект».
+`;
+}
+
+export function mergePackageJsonScripts(existingJson, scripts, devDependencies = {}) {
+  const pkg = existingJson ? JSON.parse(existingJson) : { name: 'project', version: '0.0.0', private: true };
+  pkg.scripts = { ...(pkg.scripts ?? {}), ...scripts };
+  if (Object.keys(devDependencies).length > 0) {
+    pkg.devDependencies = { ...(pkg.devDependencies ?? {}), ...devDependencies };
+  }
+  return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+
+export function mergeCursorMcpConfig(existingJson, {
+  projectRootVar = '${workspaceFolder}',
+  useNpxMcp = true,
+} = {}) {
+  const base = existingJson ? JSON.parse(existingJson) : { mcpServers: {} };
+  if (!base.mcpServers || typeof base.mcpServers !== 'object') {
+    base.mcpServers = {};
+  }
+  if (useNpxMcp) {
+    base.mcpServers.workgraph = {
+      type: 'stdio',
+      command: 'npx',
+      args: ['-y', '@work-graph/mcp'],
+      env: {
+        WORKGRAPH_ROOT: projectRootVar,
+        WG_PROJECT_ROOT: projectRootVar,
+      },
+    };
+  } else {
+    base.mcpServers.workgraph = {
+      type: 'stdio',
+      command: 'node',
+      args: [`${projectRootVar}/.work-graph/run-mcp.mjs`],
+      env: {
+        WORKGRAPH_ROOT: projectRootVar,
+        WG_PROJECT_ROOT: projectRootVar,
+      },
+    };
+  }
+  return `${JSON.stringify(base, null, 2)}\n`;
+}
+
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function writeIfMissing(path, content) {
+  if (await pathExists(path)) {
+    return { path, written: false };
+  }
+  await writeFile(path, content, 'utf8');
+  return { path, written: true };
+}
+
+export async function readProjectConfig(projectRoot) {
+  const configPath = join(resolve(projectRoot), '.work-graph/config.json');
+  if (!(await pathExists(configPath))) {
+    return null;
+  }
+  const raw = await readFile(configPath, 'utf8');
+  return JSON.parse(raw);
+}
+
+export async function initWorkGraphProject(options = {}) {
+  const projectRoot = resolve(options.projectRoot ?? process.cwd());
+  const label = options.label ?? basename(projectRoot);
+  const projectId = options.id ?? slugFromPath(projectRoot);
+  const npmFirst = options.npmFirst !== false && !options.engineRoot;
+  const engineRoot = options.engineRoot
+    ? resolve(options.engineRoot)
+    : (options.cliModuleUrl ? defaultEngineRootFromCliModule(options.cliModuleUrl) : null);
+
+  await mkdir(join(projectRoot, 'intent'), { recursive: true });
+  await mkdir(join(projectRoot, 'charter'), { recursive: true });
+  await mkdir(join(projectRoot, 'architecture'), { recursive: true });
+  await mkdir(join(projectRoot, '.work-graph'), { recursive: true });
+  await mkdir(join(projectRoot, '.cursor/rules'), { recursive: true });
+
+  const config = buildProjectConfig({
+    projectRoot,
+    engineRoot: npmFirst ? undefined : engineRoot,
+    label,
+    id: projectId,
+    uiPort: options.uiPort,
+    schemaVersion: npmFirst ? 2 : 1,
+  });
+
+  const configPath = join(projectRoot, '.work-graph/config.json');
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+
+  const runUiPath = join(projectRoot, '.work-graph/run-ui.mjs');
+  const runMcpPath = join(projectRoot, '.work-graph/run-mcp.mjs');
+  await writeFile(runUiPath, buildRunUiScriptContent(), 'utf8');
+  await writeFile(runMcpPath, buildRunMcpScriptContent(), 'utf8');
+
+  const canonWrites = [];
+  canonWrites.push(await writeIfMissing(join(projectRoot, 'intent/index.bvc'), INDEX_STUB));
+  canonWrites.push(await writeIfMissing(join(projectRoot, 'architecture/main.bvc'), MAIN_BVC_STUB));
+
+  const cliVersion = options.cliVersion ?? DEFAULT_CLI_VERSION;
+  const mcpVersion = options.mcpVersion ?? DEFAULT_MCP_VERSION;
+
+  const pkgPath = join(projectRoot, 'package.json');
+  const pkgScripts = {
+    'workgraph:ui': 'node .work-graph/run-ui.mjs',
+    'workgraph:mcp': 'node .work-graph/run-mcp.mjs',
+    'workgraph:doctor': 'work-graph doctor',
+  };
+  let packageJsonWritten = false;
+  if (options.mergePackageJson !== false) {
+    const existingPkg = (await pathExists(pkgPath)) ? await readFile(pkgPath, 'utf8') : null;
+    const devDeps = npmFirst
+      ? { '@work-graph/cli': `^${cliVersion}`, '@work-graph/mcp': `^${mcpVersion}` }
+      : {};
+    await writeFile(pkgPath, mergePackageJsonScripts(existingPkg, pkgScripts, devDeps), 'utf8');
+    packageJsonWritten = true;
+  }
+
+  const mcpPath = join(projectRoot, '.cursor/mcp.json');
+  let mcpWritten = false;
+  if (options.mergeMcp !== false) {
+    const existingMcp = (await pathExists(mcpPath)) ? await readFile(mcpPath, 'utf8') : null;
+    await writeFile(mcpPath, mergeCursorMcpConfig(existingMcp, { useNpxMcp: npmFirst }), 'utf8');
+    mcpWritten = true;
+  }
+
+  const rulePath = join(projectRoot, '.cursor/rules/work-graph-project.mdc');
+  let ruleWritten = false;
+  if (options.writeCursorRule !== false) {
+    const wrote = await writeIfMissing(rulePath, buildCursorRuleContent({ label }));
+    ruleWritten = wrote.written;
+  }
+
+  const nextSteps = npmFirst
+    ? [
+      'npm install',
+      'npm run workgraph:ui',
+      'Открыть http://127.0.0.1:4177/',
+      'Перезагрузить MCP в Cursor (workgraph)',
+    ]
+    : [
+      'npm run workgraph:ui',
+      'Открыть http://127.0.0.1:4177/',
+      'Перезагрузить MCP в Cursor (workgraph)',
+    ];
+
+  return {
+    ok: true,
+    schema: npmFirst ? 'workgraph.cli.init.v2' : 'workgraph.cli.init.v1',
+    npmFirst,
+    projectRoot,
+    engineRoot: engineRoot ?? null,
+    configPath,
+    projectId,
+    label,
+    packageJsonWritten,
+    mcpWritten,
+    ruleWritten,
+    canonWrites,
+    nextSteps,
+  };
+}
+
+export async function startProjectUiFromCwd(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const config = await readProjectConfig(cwd);
+  if (!config) {
+    throw new Error('нет .work-graph/config.json — сначала выполните work-graph init');
+  }
+
+  const projectRoot = resolve(config.projectRoot ?? cwd);
+  const engineRoot = resolveEngineRoot({
+    projectRoot,
+    config,
+    cliModuleUrl: options.cliModuleUrl,
+  });
+
+  process.env.WG_PROJECT_ROOT = projectRoot;
+  process.env.WORKGRAPH_ROOT = projectRoot;
+
+  const { startBacklogUiServer } = await importBacklogUiServer(engineRoot);
+
+  const port = Number(options.port ?? process.env.WORKGRAPH_BACKLOG_UI_PORT ?? config.uiPort ?? 4177);
+  return startBacklogUiServer({
+    hostRoot: projectRoot,
+    cwd: projectRoot,
+    hostLabel: config.label,
+    port,
+  });
+}
+
+export async function runWorkGraphDoctor(options = {}) {
+  const projectRoot = resolve(options.cwd ?? process.cwd());
+  const config = await readProjectConfig(projectRoot);
+  let engineRoot = null;
+  try {
+    engineRoot = resolveEngineRoot({
+      projectRoot,
+      config: config ?? {},
+      cliModuleUrl: options.cliModuleUrl,
+    });
+  } catch {
+    engineRoot = null;
+  }
+  return buildDoctorReport({ projectRoot, config, engineRoot });
+}