sdd-agent-platform 0.4.1 → 0.5.0

package/node_modules/@sdd-agent-platform/core/src/delegation.ts

@@ -1,26 +1,26 @@
-export * from './delegation/model.js';
-export * from './delegation/queue.js';
-export { persistDelegation } from './delegation/run-state.js';
-export {
-  DELEGATION_STATE_MACHINE_VERSION,
-  DELEGATION_STATUSES,
-  TERMINAL_DELEGATION_STATUSES,
-  getDelegationStateMachine,
-  validateDelegationStateTransition
-} from './delegation/state-machine.js';
-export type {
-  ContractValidationIssue as DelegationStateContractValidationIssue,
-  DelegationStateMachine,
-  DelegationStateTransition,
-  DelegationStateTransitionValidation
-} from './delegation/state-machine.js';
-export {
-  createDelegationRecord,
-  isDelegationStale,
-  isDelegationTerminal,
-  validateDelegationRecord
-} from './delegation/validation.js';
-export type {
-  ContractValidationIssue as DelegationRecordContractValidationIssue,
-  DelegationValidationReport
-} from './delegation/validation.js';
+export * from './delegation/model.js';
+export * from './delegation/queue.js';
+export { persistDelegation } from './delegation/run-state.js';
+export {
+  DELEGATION_STATE_MACHINE_VERSION,
+  DELEGATION_STATUSES,
+  TERMINAL_DELEGATION_STATUSES,
+  getDelegationStateMachine,
+  validateDelegationStateTransition
+} from './delegation/state-machine.js';
+export type {
+  ContractValidationIssue as DelegationStateContractValidationIssue,
+  DelegationStateMachine,
+  DelegationStateTransition,
+  DelegationStateTransitionValidation
+} from './delegation/state-machine.js';
+export {
+  createDelegationRecord,
+  isDelegationStale,
+  isDelegationTerminal,
+  validateDelegationRecord
+} from './delegation/validation.js';
+export type {
+  ContractValidationIssue as DelegationRecordContractValidationIssue,
+  DelegationValidationReport
+} from './delegation/validation.js';

package/node_modules/@sdd-agent-platform/core/src/doctor/checks/ai-entries.ts

@@ -1,28 +1,28 @@
-import { checkAiToolEntryDrift } from '../../ai-tools.js';
-import type { DoctorCheck } from '../model.js';
-
-export async function inspectAiToolEntryEvidence(projectRoot: string): Promise<DoctorCheck[]> {
-  const results = await checkAiToolEntryDrift(projectRoot);
-  const checks = results.flatMap((result) => result.entries.map((entry): DoctorCheck => {
-    const check = `ai_entry_${entry.id}`;
-    const message = `${entry.relativePath}: ${entry.message}`;
-    if (entry.status === 'unchanged') {
-      return { level: 'PASS', check, message };
-    }
-    if (entry.status === 'missing' || entry.status === 'drifted') {
-      return { level: 'FAIL', check, message, action: entry.action ?? 'Run sdd update.' };
-    }
-    if (entry.status === 'user-modified') {
-      return { level: 'FAIL', check, message, action: entry.action ?? 'Review manually; sdd update will not overwrite user-modified entries by default.' };
-    }
-    if (entry.status === 'foreign' || entry.status === 'conflict') {
-      return { level: 'FAIL', check, message, action: entry.action ?? 'Review the target file before running sdd update.' };
-    }
-    return { level: 'WARN', check, message, action: entry.action };
-  }));
-
-  if (checks.length === 0) {
-    checks.push({ level: 'WARN', check: 'ai_entries', message: 'No AI tool adapters selected for drift inspection.', action: 'Run sdd init --ai claude-code if Claude Code entries are required.' });
-  }
-  return checks;
-}
+import { checkAiToolEntryDrift } from '../../ai-tools.js';
+import type { DoctorCheck } from '../model.js';
+
+export async function inspectAiToolEntryEvidence(projectRoot: string): Promise<DoctorCheck[]> {
+  const results = await checkAiToolEntryDrift(projectRoot);
+  const checks = results.flatMap((result) => result.entries.map((entry): DoctorCheck => {
+    const check = `ai_entry_${entry.id}`;
+    const message = `${entry.relativePath}: ${entry.message}`;
+    if (entry.status === 'unchanged') {
+      return { level: 'PASS', check, message };
+    }
+    if (entry.status === 'missing' || entry.status === 'drifted') {
+      return { level: 'FAIL', check, message, action: entry.action ?? 'Run sdd update.' };
+    }
+    if (entry.status === 'user-modified') {
+      return { level: 'FAIL', check, message, action: entry.action ?? 'Review manually; sdd update will not overwrite user-modified entries by default.' };
+    }
+    if (entry.status === 'foreign' || entry.status === 'conflict') {
+      return { level: 'FAIL', check, message, action: entry.action ?? 'Review the target file before running sdd update.' };
+    }
+    return { level: 'WARN', check, message, action: entry.action };
+  }));
+
+  if (checks.length === 0) {
+    checks.push({ level: 'WARN', check: 'ai_entries', message: 'No AI tool adapters selected for drift inspection.', action: 'Run sdd init --ai claude-code if Claude Code entries are required.' });
+  }
+  return checks;
+}

package/node_modules/@sdd-agent-platform/core/src/doctor/checks/document-chain.ts

@@ -1,112 +1,104 @@
-import { readFile } from 'node:fs/promises';
-import { messageFromError } from '../../contracts/issues.js';
-import { resolveSddContext } from '../../sdd-docs/context.js';
-import { parseSddBranch, type SddTaskSourceLocation } from '../../sdd-docs/task-parser.js';
-import { inspectVerifyContract } from '../../verification/verify-contract.js';
-import { buildTaskRiskProfile } from '../../task-risk-profile.js';
-import type { DoctorCheck } from '../model.js';
-
-export async function inspectDocumentChainEvidence(projectRoot: string, branch?: string | null): Promise<DoctorCheck[]> {
-  try {
-    const context = await resolveSddContext(projectRoot, branch ? { branch, branchSource: 'cli_option' } : {});
-    const model = await parseSddBranch(projectRoot, context.branch);
-    if (!model.documents.specExists || !model.documents.tasksExists) {
-      return [{
-        level: 'WARN',
-        check: 'document_chain',
-        message: `Document chain skipped for ${context.branch}; spec.md or tasks.md is missing.`,
-        action: 'Create specs/<branch>/spec.md and tasks.md before document-chain verification.'
-      }];
-    }
-
-    const checks: DoctorCheck[] = [];
-    const specRaw = await readFile(model.specPath, 'utf8');
-    const specAcceptanceIds = extractSpecAcceptanceIds(specRaw);
-    if (specAcceptanceIds.size === 0) {
-      checks.push({
-        level: 'WARN',
-        check: 'document_chain_spec_acceptance',
-        message: `No AC-* acceptance IDs found in ${sourceLocationEvidence({ filePath: model.specPath, heading: null, lineStart: 1, lineEnd: 1 })}.`,
-        action: 'Add stable acceptance IDs such as AC-1 in spec.md.'
-      });
-    }
-
-    for (const task of model.tasks) {
-      for (const ref of task.acceptanceRefs) {
-        if (!specAcceptanceIds.has(ref)) {
-          checks.push({
-            level: 'FAIL',
-            check: 'document_chain_acceptance_ref',
-            message: `Task ${task.id} references missing spec acceptance ${ref}.`,
-            action: 'Fix acceptance_refs or add the referenced AC ID to spec.md.'
-          });
-        }
-      }
-
-      if (isHighRiskTask(task)) {
-        if (task.requiredArtifacts.length === 0) {
-          checks.push({
-            level: 'FAIL',
-            check: 'document_chain_high_risk_evidence',
-            message: `High-risk task ${task.id} has no required_artifacts.`,
-            action: 'Declare reviewer and validator artifacts before high-risk execution.'
-          });
-        }
-        if (!task.requiredArtifacts.some((artifact) => /review/i.test(artifact)) || !task.requiredArtifacts.some((artifact) => /validation|validator/i.test(artifact))) {
-          checks.push({
-            level: 'WARN',
-            check: 'document_chain_high_risk_evidence',
-            message: `High-risk task ${task.id} should require explicit reviewer and validator evidence artifacts.`,
-            action: 'Add artifacts/review-<task>.md and artifacts/validation-<task>.md or equivalent evidence paths.'
-          });
-        }
-        if (task.verificationAvailability.length === 0) {
-          checks.push({
-            level: 'WARN',
-            check: 'document_chain_high_risk_verification',
-            message: `High-risk task ${task.id} has no verification_availability.`,
-            action: 'Declare available unit/build/inspect/manual verification before high-risk execution.'
-          });
-        }
-      }
-    }
-
-    const verifyInspection = await inspectVerifyContract(projectRoot, branch ? { branch, branchSource: 'cli_option' } : {});
-    for (const issue of verifyInspection.issues) {
-      checks.push({
-        level: issue.level === 'FAIL' ? 'FAIL' : 'WARN',
-        check: issue.field === 'verify.md' ? 'document_chain_verify_missing' : 'document_chain_verify_contract',
-        message: issue.message,
-        action: issue.action
-      });
-    }
-
-    if (checks.length === 0) {
-      checks.push({
-        level: 'PASS',
-        check: 'document_chain',
-        message: `Spec acceptance IDs, task evidence links, and verify.md contract are consistent for ${context.branch}.`
-      });
-    }
-    return checks;
-  } catch (error) {
-    return [{
-      level: 'WARN',
-      check: 'document_chain',
-      message: `Document chain could not be inspected: ${messageFromError(error)}`,
-      action: 'Run sdd tasks gaps, sdd verifies inspect, and inspect specs/<branch>/spec.md/tasks.md manually.'
-    }];
-  }
-}
-
-function extractSpecAcceptanceIds(raw: string): Set<string> {
-  return new Set(Array.from(raw.matchAll(/\bAC-[A-Za-z0-9._-]+\b/g)).map((match) => match[0]));
-}
-
-function isHighRiskTask(task: Parameters<typeof buildTaskRiskProfile>[0]): boolean {
-  return buildTaskRiskProfile(task).riskLevel === 'high';
-}
-
-function sourceLocationEvidence(source: SddTaskSourceLocation): string {
-  return `${source.filePath}:${source.lineStart}-${source.lineEnd}`;
-}
+import { readFile } from 'node:fs/promises';
+import { messageFromError } from '../../contracts/issues.js';
+import { resolveSddContext } from '../../sdd-docs/context.js';
+import { parseSddBranch, type SddTaskSourceLocation } from '../../sdd-docs/task-parser.js';
+
+import { buildTaskRiskProfile } from '../../task-risk-profile.js';
+import type { DoctorCheck } from '../model.js';
+
+export async function inspectDocumentChainEvidence(projectRoot: string, branch?: string | null): Promise<DoctorCheck[]> {
+  try {
+    const context = await resolveSddContext(projectRoot, branch ? { branch, branchSource: 'cli_option' } : {});
+    const model = await parseSddBranch(projectRoot, context.branch);
+    if (!model.documents.specExists || !model.documents.tasksExists) {
+      return [{
+        level: 'WARN',
+        check: 'document_chain',
+        message: `Document chain skipped for ${context.branch}; spec.md or tasks.md is missing.`,
+        action: 'Create specs/<branch>/spec.md and tasks.md before document-chain verification.'
+      }];
+    }
+
+    const checks: DoctorCheck[] = [];
+    const specRaw = await readFile(model.specPath, 'utf8');
+    const specAcceptanceIds = extractSpecAcceptanceIds(specRaw);
+    if (specAcceptanceIds.size === 0) {
+      checks.push({
+        level: 'WARN',
+        check: 'document_chain_spec_acceptance',
+        message: `No AC-* acceptance IDs found in ${sourceLocationEvidence({ filePath: model.specPath, heading: null, lineStart: 1, lineEnd: 1 })}.`,
+        action: 'Add stable acceptance IDs such as AC-1 in spec.md.'
+      });
+    }
+
+    for (const task of model.tasks) {
+      for (const ref of task.acceptanceRefs) {
+        if (!specAcceptanceIds.has(ref)) {
+          checks.push({
+            level: 'FAIL',
+            check: 'document_chain_acceptance_ref',
+            message: `Task ${task.id} references missing spec acceptance ${ref}.`,
+            action: 'Fix acceptance_refs or add the referenced AC ID to spec.md.'
+          });
+        }
+      }
+
+      if (isHighRiskTask(task)) {
+        if (task.requiredArtifacts.length === 0) {
+          checks.push({
+            level: 'FAIL',
+            check: 'document_chain_high_risk_evidence',
+            message: `High-risk task ${task.id} has no required_artifacts.`,
+            action: 'Declare reviewer and validator artifacts before high-risk execution.'
+          });
+        }
+        if (!task.requiredArtifacts.some((artifact) => /review/i.test(artifact)) || !task.requiredArtifacts.some((artifact) => /validation|validator/i.test(artifact))) {
+          checks.push({
+            level: 'WARN',
+            check: 'document_chain_high_risk_evidence',
+            message: `High-risk task ${task.id} should require explicit reviewer and validator evidence artifacts.`,
+            action: 'Add artifacts/review-<task>.md and artifacts/validation-<task>.md or equivalent evidence paths.'
+          });
+        }
+        if (task.verificationAvailability.length === 0) {
+          checks.push({
+            level: 'WARN',
+            check: 'document_chain_high_risk_verification',
+            message: `High-risk task ${task.id} has no verification_availability.`,
+            action: 'Declare available unit/build/inspect/manual verification before high-risk execution.'
+          });
+        }
+      }
+    }
+
+
+
+    if (checks.length === 0) {
+      checks.push({
+        level: 'PASS',
+        check: 'document_chain',
+        message: `Spec acceptance IDs, task evidence links, and execute evidence contract are consistent for ${context.branch}.`
+      });
+    }
+    return checks;
+  } catch (error) {
+    return [{
+      level: 'WARN',
+      check: 'document_chain',
+      message: `Document chain could not be inspected: ${messageFromError(error)}`,
+      action: 'Run sdd tasks inspect <task_id>, sdd execute --branch <branch> --json, and inspect specs/<branch>/spec.md/tasks.md manually.'
+    }];
+  }
+}
+
+function extractSpecAcceptanceIds(raw: string): Set<string> {
+  return new Set(Array.from(raw.matchAll(/\bAC-[A-Za-z0-9._-]+\b/g)).map((match) => match[0]));
+}
+
+function isHighRiskTask(task: Parameters<typeof buildTaskRiskProfile>[0]): boolean {
+  return buildTaskRiskProfile(task).riskLevel === 'high';
+}
+
+function sourceLocationEvidence(source: SddTaskSourceLocation): string {
+  return `${source.filePath}:${source.lineStart}-${source.lineEnd}`;
+}

package/node_modules/@sdd-agent-platform/core/src/doctor/checks/local-run-index.ts

@@ -1,27 +1,27 @@
-import { inspectLocalRunIndex } from '../../run-state/run-index.js';
-import type { DoctorCheck } from '../model.js';
-
-export async function inspectLocalRunIndexEvidence(projectRoot: string): Promise<DoctorCheck[]> {
-  const inspection = await inspectLocalRunIndex(projectRoot);
-  if (!inspection.exists) {
-    return [{
-      level: 'WARN',
-      check: 'local_run_index',
-      message: 'Local run index projection is missing; runtime.sqlite remains the source of truth.',
-      action: 'Run sdd run index rebuild to create the derived index.'
-    }];
-  }
-  if (!inspection.valid) {
-    return inspection.issues.map((issue) => ({
-      level: 'WARN' as const,
-      check: 'local_run_index',
-      message: issue.message,
-      action: issue.recommendation
-    }));
-  }
-  return [{
-    level: 'PASS',
-    check: 'local_run_index',
-    message: `Local run index is current with ${inspection.index?.runs.length ?? 0} run(s), ${inspection.index?.delegations.length ?? 0} delegation(s), and ${inspection.index?.artifacts.length ?? 0} artifact(s).`
-  }];
-}
+import { inspectLocalRunIndex } from '../../run-state/run-index.js';
+import type { DoctorCheck } from '../model.js';
+
+export async function inspectLocalRunIndexEvidence(projectRoot: string): Promise<DoctorCheck[]> {
+  const inspection = await inspectLocalRunIndex(projectRoot);
+  if (!inspection.exists) {
+    return [{
+      level: 'WARN',
+      check: 'local_run_index',
+      message: 'Local run index projection is missing; runtime.sqlite remains the source of truth.',
+      action: 'Run sdd run index rebuild to create the derived index.'
+    }];
+  }
+  if (!inspection.valid) {
+    return inspection.issues.map((issue) => ({
+      level: 'WARN' as const,
+      check: 'local_run_index',
+      message: issue.message,
+      action: issue.recommendation
+    }));
+  }
+  return [{
+    level: 'PASS',
+    check: 'local_run_index',
+    message: `Local run index is current with ${inspection.index?.runs.length ?? 0} run(s), ${inspection.index?.delegations.length ?? 0} delegation(s), and ${inspection.index?.artifacts.length ?? 0} artifact(s).`
+  }];
+}

package/node_modules/@sdd-agent-platform/core/src/doctor/checks/project.ts

@@ -1,84 +1,84 @@
-import { execFile } from 'node:child_process';
-import { constants } from 'node:fs';
-import { access } from 'node:fs/promises';
-import path from 'node:path';
-import { promisify } from 'node:util';
-import { PROJECT_CONFIG_CONTRACT } from '../../contracts.js';
-import { messageFromError } from '../../contracts/issues.js';
-import { readProjectConfig as readProjectConfigFile } from '../../config/project-config.js';
-import { getProjectConfigPath, getRunsDir } from '../../runtime-paths.js';
-import type { ProjectAgentRuntimeConfig } from '../../router/agent-runtime.js';
-import { parseAgentRuntimeConfig } from '../../router/agent-runtime-config.js';
-import { exists } from '../../storage/json-io.js';
-import type { DoctorCheck } from '../model.js';
-
-const execFileAsync = promisify(execFile);
-
-export async function inspectGitRepository(projectRoot: string): Promise<DoctorCheck[]> {
-  const gitRoot = await getGitRoot(projectRoot);
-  return [gitRoot
-    ? { level: 'PASS', check: 'git_repo', message: `Git repository detected at ${gitRoot}` }
-    : { level: 'FAIL', check: 'git_repo', message: 'Current directory is not inside a Git repository; doctor and run-index checks expect git context.', action: 'Run from a project Git repository, or run git init first for a fresh temporary/project sandbox.' }];
-}
-
-export async function inspectProjectConfig(projectRoot: string): Promise<{ exists: boolean; checks: DoctorCheck[] }> {
-  const configPath = getProjectConfigPath(projectRoot);
-  if (!(await exists(configPath))) {
-    return {
-      exists: false,
-      checks: [{ level: 'FAIL', check: 'project_config', message: '.sdd/project.yml is missing.', action: 'Run sdd init.' }]
-    };
-  }
-
-  try {
-    await readProjectConfigFile<ProjectAgentRuntimeConfig>(projectRoot, parseAgentRuntimeConfig);
-    return {
-      exists: true,
-      checks: [{ level: 'PASS', check: 'project_config', message: `.sdd/project.yml is readable and uses ${PROJECT_CONFIG_CONTRACT}.` }]
-    };
-  } catch (error) {
-    return {
-      exists: true,
-      checks: [{ level: 'FAIL', check: 'project_config', message: `Cannot parse .sdd/project.yml: ${messageFromError(error)}`, action: 'Run sdd init or fix the required project.yml keys.' }]
-    };
-  }
-}
-
-export async function inspectRunsDirectoryAccess(projectRoot: string): Promise<{ available: boolean; checks: DoctorCheck[] }> {
-  const runsDir = getRunsDir(projectRoot);
-  if (!(await exists(runsDir))) {
-    return {
-      available: false,
-      checks: [{ level: 'WARN', check: 'runs_dir', message: '.sdd/runs does not exist yet.', action: 'Run sdd init or sdd run create.' }]
-    };
-  }
-
-  try {
-    await access(runsDir, constants.R_OK | constants.W_OK);
-    return {
-      available: true,
-      checks: [{ level: 'PASS', check: 'runs_dir', message: '.sdd/runs exists and is readable/writable.' }]
-    };
-  } catch {
-    return {
-      available: false,
-      checks: [{ level: 'FAIL', check: 'runs_dir', message: '.sdd/runs is not readable/writable.', action: 'Fix filesystem permissions for .sdd/runs.' }]
-    };
-  }
-}
-
-export async function inspectSpecsDirectory(projectRoot: string): Promise<DoctorCheck[]> {
-  const specsDir = path.join(projectRoot, 'specs');
-  return [await exists(specsDir)
-    ? { level: 'PASS', check: 'specs_dir', message: 'specs directory exists.' }
-    : { level: 'WARN', check: 'specs_dir', message: 'specs directory is missing.', action: 'Create specs/<branch>/ documents before full SDD execution.' }];
-}
-
-async function getGitRoot(projectRoot: string): Promise<string | null> {
-  try {
-    const result = await execFileAsync('git', ['-C', projectRoot, 'rev-parse', '--show-toplevel']);
-    return result.stdout.trim();
-  } catch {
-    return null;
-  }
-}
+import { execFile } from 'node:child_process';
+import { constants } from 'node:fs';
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { PROJECT_CONFIG_CONTRACT } from '../../contracts.js';
+import { messageFromError } from '../../contracts/issues.js';
+import { readProjectConfig as readProjectConfigFile } from '../../config/project-config.js';
+import { getProjectConfigPath, getRunsDir } from '../../runtime-paths.js';
+import type { ProjectAgentRuntimeConfig } from '../../router/agent-runtime.js';
+import { parseAgentRuntimeConfig } from '../../router/agent-runtime-config.js';
+import { exists } from '../../storage/json-io.js';
+import type { DoctorCheck } from '../model.js';
+
+const execFileAsync = promisify(execFile);
+
+export async function inspectGitRepository(projectRoot: string): Promise<DoctorCheck[]> {
+  const gitRoot = await getGitRoot(projectRoot);
+  return [gitRoot
+    ? { level: 'PASS', check: 'git_repo', message: `Git repository detected at ${gitRoot}` }
+    : { level: 'FAIL', check: 'git_repo', message: 'Current directory is not inside a Git repository; doctor and run-index checks expect git context.', action: 'Run from a project Git repository, or run git init first for a fresh temporary/project sandbox.' }];
+}
+
+export async function inspectProjectConfig(projectRoot: string): Promise<{ exists: boolean; checks: DoctorCheck[] }> {
+  const configPath = getProjectConfigPath(projectRoot);
+  if (!(await exists(configPath))) {
+    return {
+      exists: false,
+      checks: [{ level: 'FAIL', check: 'project_config', message: '.sdd/project.yml is missing.', action: 'Run sdd init.' }]
+    };
+  }
+
+  try {
+    await readProjectConfigFile<ProjectAgentRuntimeConfig>(projectRoot, parseAgentRuntimeConfig);
+    return {
+      exists: true,
+      checks: [{ level: 'PASS', check: 'project_config', message: `.sdd/project.yml is readable and uses ${PROJECT_CONFIG_CONTRACT}.` }]
+    };
+  } catch (error) {
+    return {
+      exists: true,
+      checks: [{ level: 'FAIL', check: 'project_config', message: `Cannot parse .sdd/project.yml: ${messageFromError(error)}`, action: 'Run sdd init or fix the required project.yml keys.' }]
+    };
+  }
+}
+
+export async function inspectRunsDirectoryAccess(projectRoot: string): Promise<{ available: boolean; checks: DoctorCheck[] }> {
+  const runsDir = getRunsDir(projectRoot);
+  if (!(await exists(runsDir))) {
+    return {
+      available: false,
+      checks: [{ level: 'WARN', check: 'runs_dir', message: '.sdd/runs does not exist yet.', action: 'Run sdd init or sdd run create.' }]
+    };
+  }
+
+  try {
+    await access(runsDir, constants.R_OK | constants.W_OK);
+    return {
+      available: true,
+      checks: [{ level: 'PASS', check: 'runs_dir', message: '.sdd/runs exists and is readable/writable.' }]
+    };
+  } catch {
+    return {
+      available: false,
+      checks: [{ level: 'FAIL', check: 'runs_dir', message: '.sdd/runs is not readable/writable.', action: 'Fix filesystem permissions for .sdd/runs.' }]
+    };
+  }
+}
+
+export async function inspectSpecsDirectory(projectRoot: string): Promise<DoctorCheck[]> {
+  const specsDir = path.join(projectRoot, 'specs');
+  return [await exists(specsDir)
+    ? { level: 'PASS', check: 'specs_dir', message: 'specs directory exists.' }
+    : { level: 'WARN', check: 'specs_dir', message: 'specs directory is missing.', action: 'Create specs/<branch>/ documents before full SDD execution.' }];
+}
+
+async function getGitRoot(projectRoot: string): Promise<string | null> {
+  try {
+    const result = await execFileAsync('git', ['-C', projectRoot, 'rev-parse', '--show-toplevel']);
+    return result.stdout.trim();
+  } catch {
+    return null;
+  }
+}