ultra-builder-pro-cli 0.20.0 → 0.22.0

package/mcp-server/lib/git-bootstrap.cjs

@@ -5,10 +5,103 @@ const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 
 const GIT_MODES = new Set(['auto', 'initialize', 'skip']);
-// No trailing slash: isolated session worktrees expose `.ultra` as a symlink
-// to the central authority, and Git's directory-only pattern does not ignore
-// that symlink reliably.
-const ULTRA_IGNORE_LINE = '.ultra';
+// No trailing slash: isolated session worktrees expose only `.ultra/.runtime`
+// as a symlink, and Git's directory-only pattern does not ignore that symlink
+// reliably. Semantic and evidence artifacts elsewhere in `.ultra/` remain
+// trackable and travel with their task branch.
+const ULTRA_RUNTIME_IGNORE_LINE = '.ultra/.runtime';
+const ULTRA_LEGACY_STATE_IGNORE_LINES = Object.freeze([
+  '.ultra/[s]tate.db',
+  '.ultra/[s]tate.db-wal',
+  '.ultra/[s]tate.db-shm',
+]);
+const ULTRA_LEGACY_STATE_PROBES = Object.freeze([
+  '.ultra/' + 'state.db',
+  '.ultra/' + 'state.db-wal',
+  '.ultra/' + 'state.db-shm',
+]);
+const ULTRA_UNIGNORE_DIR_LINE = '!.ultra/';
+const ULTRA_UNIGNORE_CONTENT_LINE = '!.ultra/**';
+const LEGACY_BROAD_IGNORE_LINES = new Set(['.ultra', '.ultra/', '/.ultra', '/.ultra/']);
+const ULTRA_GIT_ARTIFACT_CLASSES = Object.freeze({
+  runtime: Object.freeze({
+    compatibility: ULTRA_LEGACY_STATE_PROBES,
+    authority: Object.freeze([
+      '.ultra/.runtime/state.db',
+      '.ultra/.runtime/state.db-wal',
+      '.ultra/.runtime/state.db-shm',
+    ]),
+    backups: Object.freeze([
+      '.ultra/.runtime/backups/state-db-2026-07-28.db',
+      '.ultra/.runtime/backups/legacy-state-2026-07-28/state.db',
+      '.ultra/.runtime/backups/projection-v4.5-2026-07-28/tasks/tasks.json',
+      '.ultra/.runtime/backups/backup-v4.4-2026-07-28/specs/product.md',
+    ]),
+    coordination: Object.freeze([
+      '.ultra/.runtime/collab/review.json',
+      '.ultra/.runtime/sessions/session/metadata.json',
+      '.ultra/.runtime/worktrees/session/marker',
+      '.ultra/.runtime/telemetry/events.jsonl',
+      '.ultra/.runtime/debug/trace.jsonl',
+      '.ultra/.runtime/checkpoint.json',
+      '.ultra/.runtime/orchestrator/orchestrator.pid',
+      '.ultra/.runtime/orchestrator/orchestrator.log',
+      '.ultra/.runtime/recovery/worktrees/session/sentinel',
+    ]),
+  }),
+  semantic: Object.freeze({
+    baseline: Object.freeze([
+      '.ultra/specs/discovery.md',
+      '.ultra/specs/product.md',
+      '.ultra/specs/architecture.md',
+      '.ultra/specs/research-distillate.md',
+    ]),
+    planning: Object.freeze([
+      '.ultra/plan.md',
+      '.ultra/plan.json',
+      '.ultra/tasks/tasks.json',
+      '.ultra/tasks/plan.md',
+      '.ultra/tasks/plan.json',
+    ]),
+    research: Object.freeze([
+      '.ultra/docs/research/README.md',
+      '.ultra/docs/research/workflow/step.md',
+    ]),
+    changes: Object.freeze([
+      '.ultra/changes/active/example/intent.md',
+      '.ultra/changes/active/example/plan.md',
+      '.ultra/changes/active/example/delta/spec.md',
+      '.ultra/changes/active/example/findings/review.md',
+      '.ultra/changes/active/example/evidence/build.json',
+      '.ultra/changes/active/example/reconciliation.json',
+      '.ultra/changes/active/example/verification.md',
+      '.ultra/changes/active/example/contexts/manifest.json',
+      '.ultra/changes/archive/example/intent.md',
+      '.ultra/changes/archive/example/plan.md',
+      '.ultra/changes/archive/example/evidence/release.json',
+    ]),
+    reports: Object.freeze([
+      '.ultra/reports/templates/test-report.json',
+      '.ultra/reports/templates/delivery-report.json',
+      '.ultra/reports/tests/workflow.json',
+      '.ultra/reports/delivery/workflow.json',
+      '.ultra/reports/test-report.json',
+      '.ultra/reports/delivery-report.json',
+    ]),
+    evidence: Object.freeze([
+      '.ultra/evidence/build.json',
+      '.ultra/findings/review.md',
+      '.ultra/reconciliation/change.md',
+      '.ultra/archive/change/evidence.json',
+    ]),
+  }),
+});
+const ULTRA_RUNTIME_PROBES = Object.freeze(
+  Object.values(ULTRA_GIT_ARTIFACT_CLASSES.runtime).flat(),
+);
+const ULTRA_SEMANTIC_PROBES = Object.freeze(
+  Object.values(ULTRA_GIT_ARTIFACT_CLASSES.semantic).flat(),
+);
 
 class GitBootstrapError extends Error {
   constructor(code, message, { cause } = {}) {
@@ -19,22 +112,63 @@ class GitBootstrapError extends Error {
   }
 }
 
-function runGit(rootDir, args) {
-  return spawnSync('git', args, {
+function runGit(rootDir, args, spawnGit = spawnSync) {
+  return spawnGit('git', args, {
     cwd: rootDir,
     encoding: 'utf8',
     stdio: ['ignore', 'pipe', 'pipe'],
   });
 }
 
-function gitValue(rootDir, args) {
-  const result = runGit(rootDir, args);
-  return result.status === 0 ? result.stdout.trim() : null;
+function gitValue(rootDir, args, spawnGit = spawnSync, {
+  absentStatuses = [],
+} = {}) {
+  const result = runGit(rootDir, args, spawnGit);
+  if (result?.error) {
+    throw new GitBootstrapError(
+      'GIT_DISCOVERY_FAILED',
+      `Git probe failed: ${result.error.message}`,
+      { cause: result.error },
+    );
+  }
+  if (result.status === 0) return String(result.stdout || '').trim();
+  if (absentStatuses.includes(result.status)) return null;
+  const detail = String(result.stderr || result.stdout || `exit ${result.status}`).trim();
+  throw new GitBootstrapError(
+    'GIT_DISCOVERY_FAILED',
+    `Git probe ${args.join(' ')} failed: ${detail}`,
+  );
+}
+
+function hasGitMetadata(rootDir) {
+  let current = path.resolve(rootDir);
+  while (true) {
+    if (fs.lstatSync(path.join(current, '.git'), { throwIfNoEntry: false })) return true;
+    const parent = path.dirname(current);
+    if (parent === current) return false;
+    current = parent;
+  }
 }
 
-function inspectGitRepository(rootDir) {
-  const repositoryRoot = gitValue(rootDir, ['rev-parse', '--show-toplevel']);
+function inspectGitRepository(rootDir, { spawnGit = spawnSync } = {}) {
+  const metadataPresent = hasGitMetadata(rootDir);
+  const result = runGit(rootDir, ['rev-parse', '--show-toplevel'], spawnGit);
+  const repositoryRoot = result?.status === 0 ? String(result.stdout || '').trim() : '';
   if (!repositoryRoot) {
+    const detail = String(
+      result?.error?.message || result?.stderr || result?.stdout || 'unknown Git probe failure',
+    ).trim();
+    const explicitlyNotRepository = !metadataPresent
+      && result?.status !== null
+      && result?.status !== 0
+      && /not a git repository/i.test(detail);
+    if (!explicitlyNotRepository) {
+      throw new GitBootstrapError(
+        'GIT_DISCOVERY_FAILED',
+        `cannot classify repository state: ${detail}`,
+        { cause: result?.error },
+      );
+    }
     return {
       present: false,
       repository_root: null,
@@ -45,9 +179,19 @@ function inspectGitRepository(rootDir) {
   return {
     present: true,
     repository_root: path.resolve(repositoryRoot),
-    branch: gitValue(rootDir, ['symbolic-ref', '--quiet', '--short', 'HEAD'])
-      || gitValue(rootDir, ['branch', '--show-current']),
-    head: gitValue(rootDir, ['rev-parse', '--verify', 'HEAD']),
+    branch: gitValue(
+      rootDir,
+      ['symbolic-ref', '--quiet', '--short', 'HEAD'],
+      spawnGit,
+      { absentStatuses: [1] },
+    )
+      || gitValue(rootDir, ['branch', '--show-current'], spawnGit),
+    head: gitValue(
+      rootDir,
+      ['rev-parse', '--verify', '--quiet', 'HEAD'],
+      spawnGit,
+      { absentStatuses: [1] },
+    ),
   };
 }
 
@@ -68,21 +212,229 @@ function initializeRepository(rootDir) {
   }
 }
 
-function containsUltraIgnore(contents, { requireSymlinkSafe = false } = {}) {
-  const accepted = requireSymlinkSafe
-    ? ['.ultra', '/.ultra']
-    : ['.ultra', '.ultra/', '/.ultra', '/.ultra/'];
-  return contents.split(/\r?\n/).some((line) => {
-    const value = line.trim();
-    return accepted.includes(value);
+function checkIgnoreStates(rootDir, probes, spawnGit = spawnSync) {
+  const unique = [...new Set(probes)];
+  if (unique.length === 0) return new Map();
+  const result = spawnGit(
+    'git',
+    ['check-ignore', '--no-index', '--stdin', '-z'],
+    {
+      cwd: rootDir,
+      encoding: 'utf8',
+      input: `${unique.join('\0')}\0`,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    },
+  );
+  if (result?.error || ![0, 1].includes(result?.status)) {
+    const detail = String(
+      result?.error?.message || result?.stderr || result?.stdout
+        || `exit ${String(result?.status)}`,
+    ).trim();
+    throw new GitBootstrapError(
+      'GITIGNORE_PROBE_FAILED',
+      `cannot classify Ultra artifacts: ${detail}`,
+      { cause: result?.error },
+    );
+  }
+  const ignored = new Set(
+    String(result.stdout || '').split('\0').filter(Boolean),
+  );
+  for (const output of ignored) {
+    if (!unique.includes(output)) {
+      throw new GitBootstrapError(
+        'GITIGNORE_PROBE_FAILED',
+        `Git returned an unexpected Ultra artifact path: ${output}`,
+      );
+    }
+  }
+  return new Map(unique.map((probe) => [
+    probe,
+    ignored.has(probe) ? 'ignored' : 'trackable',
+  ]));
+}
+
+function checkIgnoreState(rootDir, probe) {
+  return checkIgnoreStates(rootDir, [probe]).get(probe);
+}
+
+function scanManagedArtifacts(rootDir) {
+  const ultraRoot = path.join(rootDir, '.ultra');
+  const stat = fs.lstatSync(ultraRoot, { throwIfNoEntry: false });
+  if (!stat || stat.isSymbolicLink() || !stat.isDirectory()) {
+    return { runtime: [], semantic: [] };
+  }
+  const found = { runtime: [], semantic: [] };
+  const pending = fs.readdirSync(ultraRoot)
+    .map((entry) => path.join(ultraRoot, entry));
+  while (pending.length > 0) {
+    const candidate = pending.pop();
+    const entry = fs.lstatSync(candidate, { throwIfNoEntry: false });
+    if (!entry) continue;
+    const relative = path.relative(rootDir, candidate).split(path.sep).join('/');
+    const runtime = relative === '.ultra/.runtime'
+      || relative.startsWith('.ultra/.runtime/')
+      || ULTRA_LEGACY_STATE_PROBES.includes(relative);
+    found[runtime ? 'runtime' : 'semantic'].push(relative);
+    if (entry.isSymbolicLink() || !entry.isDirectory()) continue;
+    const parts = relative.split('/');
+    if (parts.length === 4
+        && parts[0] === '.ultra'
+        && parts[1] === '.runtime'
+        && parts[2] === 'worktrees') {
+      continue;
+    }
+    for (const child of fs.readdirSync(candidate)) {
+      pending.push(path.join(candidate, child));
+    }
+  }
+  return found;
+}
+
+function runtimeIsIgnored(rootDir) {
+  const runtimeEntry = fs.lstatSync(
+    path.join(rootDir, '.ultra', '.runtime'),
+    { throwIfNoEntry: false },
+  );
+  if (runtimeEntry?.isSymbolicLink()) {
+    // Git refuses to classify pathspecs beyond a symlink. For a task
+    // worktree the link itself is the complete runtime boundary, so proving
+    // the exact link ignored is both necessary and sufficient.
+    return checkIgnoreState(rootDir, '.ultra/.runtime') === 'ignored';
+  }
+  const actual = scanManagedArtifacts(rootDir).runtime;
+  const probes = [...new Set([...ULTRA_RUNTIME_PROBES, ...actual])];
+  const states = checkIgnoreStates(rootDir, probes);
+  return probes.every((probe) => states.get(probe) === 'ignored');
+}
+
+function semanticArtifactsAreTrackable(rootDir) {
+  const actual = scanManagedArtifacts(rootDir).semantic;
+  const probes = [...new Set([...ULTRA_SEMANTIC_PROBES, ...actual])];
+  const states = checkIgnoreStates(rootDir, probes);
+  return probes.every((probe) => states.get(probe) === 'trackable');
+}
+
+function rootRulesPreserveUltraBoundary(rootDir) {
+  const file = path.join(rootDir, '.gitignore');
+  const stat = fs.lstatSync(file, { throwIfNoEntry: false });
+  if (!stat) return true;
+  if (stat.isSymbolicLink() || !stat.isFile()) return false;
+  const rules = fs.readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'));
+  let lastUnsafe = -1;
+  let unignoreDir = -1;
+  let unignoreContent = -1;
+  let runtimeIgnore = -1;
+  const compatibilityIgnores = new Map(
+    ULTRA_LEGACY_STATE_IGNORE_LINES.map((rule) => [rule, -1]),
+  );
+  rules.forEach((rule, index) => {
+    const normalized = rule.replace(/^\/+/, '').replace(/\/+$/u, '');
+    if (rule === ULTRA_UNIGNORE_DIR_LINE) unignoreDir = index;
+    else if (rule === ULTRA_UNIGNORE_CONTENT_LINE) unignoreContent = index;
+    else if (normalized === ULTRA_RUNTIME_IGNORE_LINE) runtimeIgnore = index;
+    else if (compatibilityIgnores.has(normalized)) compatibilityIgnores.set(normalized, index);
+    else if (normalized.includes('.ultra')) lastUnsafe = index;
   });
+  if (lastUnsafe === -1) return true;
+  return unignoreDir > lastUnsafe
+    && unignoreContent > unignoreDir
+    && runtimeIgnore > unignoreContent
+    && [...compatibilityIgnores.values()].every((index) => index > unignoreContent);
 }
 
-function effectiveUltraIgnore(rootDir) {
-  return runGit(rootDir, ['check-ignore', '--quiet', '--no-index', '--', '.ultra']).status === 0;
+function effectiveUltraStorageBoundary(rootDir) {
+  return rootRulesPreserveUltraBoundary(rootDir)
+    && runtimeIsIgnored(rootDir)
+    && semanticArtifactsAreTrackable(rootDir);
 }
 
-function ensureUltraIgnored(rootDir, { requireSymlinkSafe = false } = {}) {
+function repositoryLocalRuntimePattern(rootDir, repository) {
+  const repositoryRoot = fs.realpathSync(repository.repository_root);
+  const projectRoot = fs.realpathSync(rootDir);
+  const relative = path.relative(repositoryRoot, projectRoot);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new GitBootstrapError(
+      'GIT_REPOSITORY_SCOPE_INVALID',
+      `project root is outside its reported Git repository: ${rootDir}`,
+    );
+  }
+  const components = relative ? relative.split(path.sep) : [];
+  return `/${[...components, '.ultra', '.runtime'].join('/')}`;
+}
+
+function repositoryLocalCompatibilityPatterns(rootDir, repository) {
+  const runtimePattern = repositoryLocalRuntimePattern(rootDir, repository);
+  const prefix = runtimePattern.slice(0, -'.runtime'.length);
+  return ULTRA_LEGACY_STATE_IGNORE_LINES.map((line) => (
+    `${prefix}${line.slice('.ultra/'.length)}`
+  ));
+}
+
+function ensureLocalRuntimeIgnored(rootDir, repository) {
+  const result = runGit(rootDir, ['rev-parse', '--git-path', 'info/exclude']);
+  if (result.status !== 0) {
+    throw new GitBootstrapError(
+      'GITEXCLUDE_UNAVAILABLE',
+      `cannot resolve repository-local exclude file: ${(result.stderr || result.stdout).trim()}`,
+    );
+  }
+  const reported = result.stdout.trim();
+  const file = path.isAbsolute(reported) ? reported : path.resolve(rootDir, reported);
+  let stat = null;
+  try { stat = fs.lstatSync(file); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  if (stat && (stat.isSymbolicLink() || !stat.isFile())) {
+    throw new GitBootstrapError(
+      'GITEXCLUDE_UNSAFE',
+      `refusing to update non-regular repository-local exclude file: ${file}`,
+    );
+  }
+  const existed = stat !== null;
+  const before = existed ? fs.readFileSync(file, 'utf8') : null;
+  if (runtimeIsIgnored(rootDir)) {
+    return { changed: false, path: file, rollback: { existed, before } };
+  }
+  const managedPattern = repositoryLocalRuntimePattern(rootDir, repository);
+  const compatibilityPatterns = repositoryLocalCompatibilityPatterns(rootDir, repository);
+  const preserved = (before || '')
+    .split(/\r?\n/)
+    .filter((line) => line.trim() !== '# Ultra Builder Pro local runtime')
+    .filter((line) => line.trim() !== ULTRA_RUNTIME_IGNORE_LINE)
+    .filter((line) => line.trim() !== managedPattern)
+    .filter((line) => !compatibilityPatterns.includes(line.trim()))
+    .join('\n')
+    .replace(/\n+$/u, '');
+  const prefix = preserved ? `${preserved}\n` : '';
+  const separator = prefix && !prefix.endsWith('\n\n') ? '\n' : '';
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(
+    file,
+    `${prefix}${separator}# Ultra Builder Pro local runtime\n`
+      + `${managedPattern}\n${compatibilityPatterns.join('\n')}\n`,
+  );
+  return { changed: true, path: file, rollback: { existed, before } };
+}
+
+function rollbackFileMutation(mutation) {
+  if (!mutation?.changed) return [];
+  try {
+    if (mutation.rollback.existed) {
+      fs.writeFileSync(mutation.path, mutation.rollback.before);
+    } else {
+      fs.rmSync(mutation.path, { force: true });
+    }
+    return [];
+  } catch (error) {
+    return [`${mutation.path}: ${error.message}`];
+  }
+}
+
+function ensureUltraRuntimeIgnored(rootDir) {
   const file = path.join(rootDir, '.gitignore');
   let stat = null;
   try { stat = fs.lstatSync(file); }
@@ -99,23 +451,35 @@ function ensureUltraIgnored(rootDir, { requireSymlinkSafe = false } = {}) {
     }
   }
   const before = existed ? fs.readFileSync(file, 'utf8') : null;
-  if (!requireSymlinkSafe && effectiveUltraIgnore(rootDir)) {
+  if (effectiveUltraStorageBoundary(rootDir)) {
     return {
       changed: false,
       path: file,
       rollback: { existed, before },
     };
   }
-  if (before !== null && containsUltraIgnore(before, { requireSymlinkSafe })) {
-    return {
-      changed: false,
-      path: file,
-      rollback: { existed, before },
-    };
-  }
-  const prefix = before && !before.endsWith('\n') ? `${before}\n` : (before || '');
+  const preserved = (before || '')
+    .split(/\r?\n/)
+    .filter((line) => !LEGACY_BROAD_IGNORE_LINES.has(line.trim()))
+    .filter((line) => ![
+      ULTRA_RUNTIME_IGNORE_LINE,
+      `/${ULTRA_RUNTIME_IGNORE_LINE}`,
+      `${ULTRA_RUNTIME_IGNORE_LINE}/`,
+      `/${ULTRA_RUNTIME_IGNORE_LINE}/`,
+      ULTRA_UNIGNORE_DIR_LINE,
+      ULTRA_UNIGNORE_CONTENT_LINE,
+      ...ULTRA_LEGACY_STATE_IGNORE_LINES,
+    ].includes(line.trim()))
+    .join('\n')
+    .replace(/\n+$/u, '');
+  const prefix = preserved ? `${preserved}\n` : '';
   const separator = prefix && !prefix.endsWith('\n\n') ? '\n' : '';
-  const next = `${prefix}${separator}# Ultra Builder Pro local authority\n${ULTRA_IGNORE_LINE}\n`;
+  const next = `${prefix}${separator}`
+    + '# Ultra Builder Pro semantic artifacts are trackable; runtime state is local\n'
+    + `${ULTRA_UNIGNORE_DIR_LINE}\n`
+    + `${ULTRA_UNIGNORE_CONTENT_LINE}\n`
+    + `${ULTRA_RUNTIME_IGNORE_LINE}\n`
+    + `${ULTRA_LEGACY_STATE_IGNORE_LINES.join('\n')}\n`;
   fs.writeFileSync(file, next);
   return {
     changed: true,
@@ -124,18 +488,63 @@ function ensureUltraIgnored(rootDir, { requireSymlinkSafe = false } = {}) {
   };
 }
 
-function assertUltraIgnored(rootDir) {
-  const result = runGit(rootDir, ['check-ignore', '--quiet', '--no-index', '--', '.ultra']);
-  if (result.status === 0) return;
-  const detail = result.status === 1
-    ? 'the effective Git rules re-include .ultra'
-    : (result.stderr || result.stdout || 'Git could not evaluate the rule').trim();
+function assertUltraStorageBoundary(rootDir) {
+  if (effectiveUltraStorageBoundary(rootDir)) return;
   throw new GitBootstrapError(
     'GITIGNORE_INEFFECTIVE',
-    `Ultra authority is not ignored by Git: ${detail}`,
+    'Git rules must ignore .ultra/.runtime while keeping semantic .ultra artifacts trackable',
   );
 }
 
+function ensureExistingProjectStorageBoundary(rootDir) {
+  const repository = inspectGitRepository(rootDir);
+  if (!repository.present) {
+    return {
+      status: 'not_a_repository',
+      repository,
+      gitignore_changed: false,
+      gitignore_path: null,
+    };
+  }
+  let gitignore;
+  let localExclude;
+  try {
+    if (effectiveUltraStorageBoundary(rootDir)) {
+      return {
+        status: 'ready',
+        repository,
+        gitignore_changed: false,
+        gitignore_path: null,
+        local_exclude_changed: false,
+        local_exclude_path: null,
+      };
+    }
+    if (semanticArtifactsAreTrackable(rootDir)) {
+      localExclude = ensureLocalRuntimeIgnored(rootDir, repository);
+      if (!effectiveUltraStorageBoundary(rootDir)) {
+        rollbackFileMutation(localExclude);
+        localExclude = null;
+        gitignore = ensureUltraRuntimeIgnored(rootDir);
+      }
+    } else {
+      gitignore = ensureUltraRuntimeIgnored(rootDir);
+    }
+    assertUltraStorageBoundary(rootDir);
+    return {
+      status: 'ready',
+      repository,
+      gitignore_changed: Boolean(gitignore?.changed),
+      gitignore_path: gitignore?.path || null,
+      local_exclude_changed: Boolean(localExclude?.changed),
+      local_exclude_path: localExclude?.path || null,
+    };
+  } catch (error) {
+    rollbackFileMutation(localExclude);
+    rollbackGitBootstrap(rootDir, { created_repository: false, gitignore });
+    throw error;
+  }
+}
+
 function rollbackGitBootstrap(rootDir, internal) {
   const errors = [];
   if (!internal) return errors;
@@ -194,12 +603,8 @@ function bootstrapGit(rootDir, { mode = 'auto' } = {}) {
       initializeRepository(rootDir);
       internal.created_repository = true;
     }
-    internal.gitignore = ensureUltraIgnored(rootDir, {
-      // A repository created in this call has no tracked baseline to preserve,
-      // so its ignore rule can be made safe for the session authority symlink.
-      requireSymlinkSafe: internal.created_repository,
-    });
-    assertUltraIgnored(rootDir);
+    internal.gitignore = ensureUltraRuntimeIgnored(rootDir);
+    assertUltraStorageBoundary(rootDir);
     const after = inspectGitRepository(rootDir);
     if (!after.present) {
       throw new GitBootstrapError(
@@ -234,7 +639,13 @@ function bootstrapGit(rootDir, { mode = 'auto' } = {}) {
 module.exports = {
   GitBootstrapError,
   GIT_MODES,
+  ULTRA_GIT_ARTIFACT_CLASSES,
+  ULTRA_RUNTIME_PROBES,
+  ULTRA_SEMANTIC_PROBES,
   bootstrapGit,
+  assertUltraStorageBoundary,
+  effectiveUltraStorageBoundary,
+  ensureExistingProjectStorageBoundary,
   inspectGitRepository,
   rollbackGitBootstrap,
 };