@uniqbit/mate-core 0.15.5 → 0.16.0-canary.0

package/src/lib/orchestrator/companion-git-sync.ts

@@ -1,10 +1,19 @@
 // Git index and merge operations must remain sequential.
 // oxlint-disable no-await-in-loop
-import { execFile as execFileCallback } from "node:child_process";
+import { execFile as execFileCallback, spawn as spawnChild } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 
+import {
+  describeGitFailure,
+  gitEnvironment,
+  isAuthenticationFailure,
+  outputLines,
+  resolveUpstreamTargetWith,
+  type GitResult,
+} from "../../runtime/companion-git";
+import { recordCompanionSync } from "../../runtime/companion-git-state";
 import { LaunchPreflightError } from "./types";
 
 const execFile = promisify(execFileCallback);
@@ -12,13 +21,17 @@ const execFile = promisify(execFileCallback);
 /** Bounded but far above any diagnostic output; default 1 MiB kills git mid-merge on large trees. */
 const GIT_MAX_BUFFER = 64 * 1024 * 1024;
 
-export interface GitCommandResult {
-  status: number;
-  stdout: string;
-  stderr: string;
-}
+export type GitCommandResult = GitResult;
+
+export { describeGitFailure };
 
-export type GitRunner = (args: readonly string[], cwd: string) => Promise<GitCommandResult>;
+export type GitExecutionMode = "captured" | "interactive";
+
+export type GitRunner = (
+  args: readonly string[],
+  cwd: string,
+  mode?: GitExecutionMode,
+) => Promise<GitCommandResult>;
 
 export interface CompanionGitSyncResult {
   skipped: boolean;
@@ -69,19 +82,39 @@ export class CompanionGitSyncError extends LaunchPreflightError {
 }
 
 export const companionGitSyncDeps: { runGit: GitRunner } = {
-  runGit: async (args, cwd) => {
+  runGit: async (args, cwd, mode = "captured") => {
+    const captured = gitEnvironment(process.env);
+    const { GIT_TERMINAL_PROMPT: _prompt, ...interactive } = captured;
+    const env = mode === "captured" ? captured : interactive;
+
+    if (mode === "interactive") {
+      return new Promise((resolve) => {
+        let settled = false;
+        const finish = (result: GitCommandResult) => {
+          if (settled) return;
+          settled = true;
+          resolve(result);
+        };
+
+        const child = spawnChild("git", [...args], {
+          cwd,
+          env,
+          stdio: "inherit",
+        });
+        child.once("error", (error) => {
+          finish({ status: 1, stdout: "", stderr: error.message });
+        });
+        child.once("close", (status) => {
+          finish({ status: status ?? 1, stdout: "", stderr: "" });
+        });
+      });
+    }
+
     try {
-      const {
-        GIT_DIR: _gitDir,
-        GIT_WORK_TREE: _gitWorkTree,
-        GIT_COMMON_DIR: _gitCommonDir,
-        GIT_INDEX_FILE: _gitIndexFile,
-        ...gitEnv
-      } = process.env;
       const result = await execFile("git", [...args], {
         cwd,
         encoding: "utf8",
-        env: gitEnv,
+        env,
         maxBuffer: GIT_MAX_BUFFER,
       });
       return { status: 0, stdout: String(result.stdout), stderr: String(result.stderr) };
@@ -114,32 +147,14 @@ function isManagedPath(filePath: string): boolean {
   return MANAGED_ROOTS.some((root) => normalized === root || normalized.startsWith(`${root}/`));
 }
 
-function outputLines(stdout: string): string[] {
-  return stdout
-    .split("\n")
-    .map((line) => line.trim())
-    .filter(Boolean);
-}
-
-/** Matches Git progress-meter lines such as `Updating files:  76% (11340/14790)` or `..., done.` */
-const GIT_PROGRESS_LINE = /^\S.*?: +\d+% \(\d+\/\d+\)(?:, done\.)?$/;
-
-function stripGitProgress(text: string): string {
-  return text
-    .split(/\r\n|\r|\n/)
-    .filter((line) => !GIT_PROGRESS_LINE.test(line.trim()))
-    .join("\n")
-    .trim();
-}
-
-export function describeGitFailure(result: GitCommandResult): string {
-  return stripGitProgress(result.stderr) || stripGitProgress(result.stdout) || "unknown Git error";
-}
-
 export class CompanionGitSync {
   constructor(private readonly runGit: GitRunner = companionGitSyncDeps.runGit) {}
 
-  async sync(companionPath: string, workingRepoPath?: string): Promise<CompanionGitSyncResult> {
+  async sync(
+    companionPath: string,
+    workingRepoPath?: string,
+    interactiveGit = false,
+  ): Promise<CompanionGitSyncResult> {
     if (!(await this.assertSafeCompanionRoot(companionPath, workingRepoPath))) {
       return { skipped: true, changed: false, companionPath };
     }
@@ -157,13 +172,30 @@ export class CompanionGitSync {
     }
     const dirty = outputLines(before.stdout).length > 0;
 
-    const fetch = await this.command(companionPath, ["fetch", target.remote, target.branch]);
+    const fetch = await this.command(
+      companionPath,
+      ["fetch", target.remote, target.branch],
+      interactiveGit ? "interactive" : undefined,
+    );
     if (fetch.status !== 0) {
+      const authenticationFailure = isAuthenticationFailure(fetch);
+      const recovery = interactiveGit
+        ? authenticationFailure
+          ? "Retry the launch and complete Git authentication, or use the `--no-git` bypass."
+          : "Check the Git or SSH diagnostics above, then retry the launch."
+        : authenticationFailure
+          ? "Provide credentials through a non-interactive Git credential helper or SSH agent, retry from a terminal, or use the `--no-git` bypass."
+          : "Check the remote and network, or resolve the issue before retrying.";
+      const detail = this.detail(fetch);
+      const failureDetail =
+        interactiveGit && detail === "unknown Git error"
+          ? "Git fetch failed; review the Git or SSH diagnostics above."
+          : detail;
       throw this.failure(
         companionPath,
-        `Unable to fetch ${target.ref}: ${this.detail(fetch)}`,
+        `Unable to fetch ${target.ref}: ${failureDetail}`,
         [],
-        "Check the remote and network, or resolve the issue before retrying.",
+        recovery,
       );
     }
 
@@ -207,6 +239,8 @@ export class CompanionGitSync {
     }
 
     const headAfter = await this.command(companionPath, ["rev-parse", "HEAD"]);
+    /** Best-effort bookkeeping: a launch that synchronized must not fail on it. */
+    recordCompanionSync(companionPath);
     return {
       skipped: false,
       changed: headBefore.stdout.trim() !== headAfter.stdout.trim(),
@@ -319,35 +353,13 @@ export class CompanionGitSync {
     }
   }
 
+  /**
+   * Delegates to `runtime/`: the blind half resolves the same ref, and the two
+   * must never disagree about which upstream they mean.
+   */
   private async resolveSyncTarget(companionPath: string): Promise<SyncTarget> {
-    const upstream = await this.command(companionPath, [
-      "rev-parse",
-      "--abbrev-ref",
-      "--symbolic-full-name",
-      "@{u}",
-    ]);
-    const configured = this.parseRemoteRef(upstream.stdout);
-    if (upstream.status === 0 && configured) return configured;
-
-    const remoteHead = await this.command(companionPath, [
-      "symbolic-ref",
-      "--short",
-      "refs/remotes/origin/HEAD",
-    ]);
-    const fromRemoteHead = this.parseRemoteRef(remoteHead.stdout);
-    if (remoteHead.status === 0 && fromRemoteHead) return fromRemoteHead;
-
-    for (const branch of ["main", "master"]) {
-      const exists = await this.command(companionPath, [
-        "show-ref",
-        "--verify",
-        "--quiet",
-        `refs/remotes/origin/${branch}`,
-      ]);
-      if (exists.status === 0) {
-        return { remote: "origin", branch, ref: `origin/${branch}` };
-      }
-    }
+    const target = await resolveUpstreamTargetWith((args) => this.command(companionPath, args));
+    if (target) return target;
 
     throw this.failure(
       companionPath,
@@ -357,17 +369,6 @@ export class CompanionGitSync {
     );
   }
 
-  private parseRemoteRef(stdout: string): SyncTarget | undefined {
-    const ref = stdout.trim();
-    const separator = ref.indexOf("/");
-    if (separator <= 0 || separator === ref.length - 1) return undefined;
-    return {
-      remote: ref.slice(0, separator),
-      branch: ref.slice(separator + 1),
-      ref,
-    };
-  }
-
   private async assertNoUnfinishedOperation(companionPath: string): Promise<void> {
     const unfinished = [
       "MERGE_HEAD",
@@ -464,8 +465,12 @@ export class CompanionGitSync {
     }
   }
 
-  private async command(companionPath: string, args: readonly string[]): Promise<GitCommandResult> {
-    return this.runGit(args, companionPath);
+  private async command(
+    companionPath: string,
+    args: readonly string[],
+    mode?: GitExecutionMode,
+  ): Promise<GitCommandResult> {
+    return mode ? this.runGit(args, companionPath, mode) : this.runGit(args, companionPath);
   }
 
   private detail(result: GitCommandResult): string {
@@ -485,6 +490,11 @@ export class CompanionGitSync {
 export async function syncCompanionGit(
   companionPath: string,
   workingRepoPath?: string,
+  interactiveGit = false,
 ): Promise<CompanionGitSyncResult> {
-  return new CompanionGitSync(companionGitSyncDeps.runGit).sync(companionPath, workingRepoPath);
+  return new CompanionGitSync(companionGitSyncDeps.runGit).sync(
+    companionPath,
+    workingRepoPath,
+    interactiveGit,
+  );
 }

package/src/lib/orchestrator/config-store.ts

@@ -5,8 +5,6 @@ import { getDefaultSetupSelections } from "./setup-compatibilities";
 import { YamlFileStore } from "./yaml-file-store";
 import { ConfigError, type FrameworkConfig } from "./types";
 
-export const RTK_CAPABILITY_SPLIT_MIGRATION = "rtk-capability-split-v1";
-
 const HUB_MEMBER_SOURCE_KINDS = ["git", "local"] as const;
 
 function defaultConfigPath(): string {
@@ -57,20 +55,6 @@ export function mergeWithDefaults(existing: FrameworkConfig): FrameworkConfig {
   };
 }
 
-export function migrateRtkCapabilitySplit(config: FrameworkConfig): FrameworkConfig {
-  const migrations = config.migrations ?? [];
-  if (migrations.includes(RTK_CAPABILITY_SPLIT_MIGRATION)) return config;
-
-  const capabilities = config.capabilities ?? [];
-  const hasHeadroom = capabilities.some((capability) => capability.name === "headroom");
-  const hasRtk = capabilities.some((capability) => capability.name === "rtk");
-  return {
-    ...config,
-    capabilities: hasHeadroom && !hasRtk ? [...capabilities, { name: "rtk" }] : capabilities,
-    migrations: [...migrations, RTK_CAPABILITY_SPLIT_MIGRATION],
-  };
-}
-
 /** Validates the shape of a hub manifest before it is used. */
 export function validateHubConfig(config: FrameworkConfig): void {
   if (config.type !== "hub") {
@@ -166,14 +150,11 @@ export class ConfigStore extends YamlFileStore<FrameworkConfig> {
     const merged = mergeWithDefaults(migrateProfilesToAllowedAgents(await super.load()));
     validateHubConfig(merged);
     validatePluginDeclarations(merged);
-    const needsMigration = !(merged.migrations ?? []).includes(RTK_CAPABILITY_SPLIT_MIGRATION);
-    const config = migrateRtkCapabilitySplit(merged);
-    if (needsMigration) await this.save(config);
-    return config;
+    return merged;
   }
 
   protected async onMissing(): Promise<FrameworkConfig> {
-    const config = migrateRtkCapabilitySplit(defaultConfig());
+    const config = defaultConfig();
     await this.save(config);
     return config;
   }

package/src/lib/orchestrator/editor.ts

@@ -1,8 +1,10 @@
 import { execFileSync, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import fs from "node:fs/promises";
 import path from "node:path";
 
+import { workspaceDocumentPath } from "./projection-entries";
+import { project } from "./working-repo-projection";
+
 type SpawnLike = typeof spawn;
 
 const CURSOR_FALLBACK_PATHS = [
@@ -75,9 +77,8 @@ export function writeMissingEditorCliGuidance(
   write(`mate: run "Install '${cli}' command in PATH" from the Command Palette to enable this.\n`);
 }
 
-export function editorWorkspacePath(repoPath: string): string {
-  return path.join(path.resolve(repoPath), ".mate", "workspace.code-workspace");
-}
+/** The Projection Root owns the path; this is the editor's name for it. */
+export const editorWorkspacePath = workspaceDocumentPath;
 
 export interface WorkspaceDocument {
   workspacePath: string;
@@ -87,29 +88,18 @@ export interface WorkspaceDocument {
 /**
  * Writes the generated `.mate/workspace.code-workspace` file (working
  * repository first, companion second) and returns its path and folder
- * order. Shared by editor-launching `injectEditorFolder` and the
- * non-launching `workspace materialize` command — both must produce the
- * same document for the same pairing.
+ * order. Called by editor-launching `injectEditorFolder`, which backs
+ * `mate companion open`.
  */
 export async function writeWorkspaceDocument(
   companionPath: string,
   repoPath: string,
 ): Promise<WorkspaceDocument> {
-  const folders: [string, string] = [path.resolve(repoPath), path.resolve(companionPath)];
-  const workspacePath = editorWorkspacePath(repoPath);
-  await fs.mkdir(path.dirname(workspacePath), { recursive: true });
-  await fs.writeFile(
-    workspacePath,
-    `${JSON.stringify(
-      {
-        folders: folders.map((candidate) => ({ path: candidate })),
-      },
-      null,
-      2,
-    )}\n`,
-    "utf8",
-  );
-  return { workspacePath, folders };
+  await project("workspace", { repoPath, companionPath });
+  return {
+    workspacePath: workspaceDocumentPath(repoPath),
+    folders: [path.resolve(repoPath), path.resolve(companionPath)],
+  };
 }
 
 export async function injectEditorFolder(

package/src/lib/orchestrator/framework-context.ts

@@ -10,6 +10,7 @@ import { readCompanionRegistry } from "./companion-registry-reader";
 import { ConfigStore } from "./config-store";
 import { GlobalConfigStore } from "./global-config-store";
 import { findRepoLocalLinkedRepository } from "./repo-local-registry";
+import { projectWorkingRepositoryBestEffort } from "./working-repo-projection";
 import {
   AmbiguousCompanionError,
   ConfigError,
@@ -216,6 +217,7 @@ export async function resolveForLaunch(
     const repository = (await findRepoLocalLinkedRepository(cwd)) ?? undefined;
     if (repository) {
       await backfillCompanionRegistration(resolution.match.companionPath, repository);
+      await projectWorkingRepositoryBestEffort(resolution.match.companionPath, repository);
     }
     const context = await withResolvedHub(
       makeContext(resolution.match.companionPath, "working-repo", repository),
@@ -280,14 +282,23 @@ export async function resolveForCapability(
     return { ...ctx, repositoryId: "" };
   }
 
-  const match = await new CompanionResolver(globalConfigStore).resolve(cwd);
+  /**
+   * `resolveWithDiagnostics` only to learn whether the match is ambiguous;
+   * `resolve()` is this same call with `logFailures`, so the returned match is
+   * unchanged. Unlike `resolveForLaunch` this does not refuse on ambiguity —
+   * it only declines to make a guessed companion durable.
+   */
+  const resolution = await new CompanionResolver(globalConfigStore).resolveWithDiagnostics(cwd, {
+    logFailures: true,
+  });
+  const match = resolution.match;
   if (match) {
+    const repository = (await findRepoLocalLinkedRepository(cwd)) ?? undefined;
+    if (repository && resolution.ambiguousMatches.length <= 1) {
+      await projectWorkingRepositoryBestEffort(match.companionPath, repository);
+    }
     const context = await withResolvedHub(
-      makeContext(
-        match.companionPath,
-        "working-repo",
-        (await findRepoLocalLinkedRepository(cwd)) ?? undefined,
-      ),
+      makeContext(match.companionPath, "working-repo", repository),
     );
     return {
       ...context,

package/src/lib/orchestrator/global-config-store.ts

@@ -2,7 +2,7 @@ import os from "node:os";
 import path from "node:path";
 
 import { FRAMEWORK_NAME } from "../../framework";
-import { pathIsDirectory } from "./repo-local-registry";
+import { pathIsDirectory } from "../fs-utils";
 import { YamlFileStore } from "./yaml-file-store";
 
 interface CompanionEntry {

package/src/lib/orchestrator/launcher.ts

@@ -1,6 +1,7 @@
 // oxlint-disable no-underscore-dangle
-import { syncCompanionFiles, syncWorkingRepoClaudeSettings } from "../../tools/setup";
+import { syncCompanionFiles } from "../../tools/setup";
 import { getActiveDistribution } from "../../distribution";
+import { FRAMEWORK_NAME } from "../../framework";
 import type { CapabilityPlugin, LaunchPreflightContext } from "../../tools/setup/plugin";
 import type { LaunchAdapter, AdapterContext } from "./adapters/base";
 import { ClaudeAdapter } from "./adapters/claude";
@@ -8,6 +9,17 @@ import { OpenCodeAdapter } from "./adapters/opencode";
 import { CompanionStore } from "./companion-store";
 import { syncCompanionGit } from "./companion-git-sync";
 import { resolveForLaunch, type LaunchContext } from "./framework-context";
+import {
+  firstFailure,
+  type ProjectionEntryOutcome,
+  type ProjectionInput,
+  type ProjectionResult,
+} from "./projection-types";
+import {
+  isWorkingRepositoryWrapped,
+  project,
+  projectWorkingRepositoryBestEffort,
+} from "./working-repo-projection";
 import {
   RepositoryNotSelectedError,
   LaunchPreflightError,
@@ -38,10 +50,54 @@ interface ResolvedLaunchState {
 
 export const launcherDeps = {
   syncCompanionFiles,
-  syncWorkingRepoClaudeSettings,
+  /** The Managed Projection's launch scope; the working repo is written only here. */
+  projectWorkingRepo: (input: ProjectionInput) => project("launch", input),
+  /**
+   * The Projection Root a launch guarantees for itself. `resolveForLaunch` also
+   * writes it, but only on the branch that resolved a companion from the
+   * Working Repository; asking here makes the guarantee independent of which
+   * branch answered. Best-effort — a launch carries its own configuration.
+   */
+  refreshProjectionRoot: projectWorkingRepositoryBestEffort,
   syncCompanionGit,
+  isWrapped: isWorkingRepositoryWrapped,
 };
 
+/**
+ * A wrapped Working Repository delivers the companion to sessions the operator
+ * starts themselves, through documents the Agent Runtime discovers by its own
+ * upward walk. A Managed Session loads those *and* everything the launch
+ * injects through `--settings`, `--mcp-config` and `--plugin-dir`, which
+ * ADR-014 established can never be withdrawn. Two delivery channels that cannot
+ * be merged must therefore not both be live for one repository, so wrapping and
+ * launching are exclusive rather than reconciled (ADR-015, superseding
+ * ADR-014's judgement that the duplication is bounded enough to accept).
+ *
+ * Raised before every write the launch itself performs: the companion Git sync,
+ * the companion file sync, the launch scope's projection and the runtime
+ * invocation. Companion resolution has already refreshed the Projection Root by
+ * this point — `resolveForLaunch` writes it while resolving — but that write is
+ * idempotent and byte-identical to the one `mate wrap` performs, so it cannot
+ * change what the repository holds.
+ */
+function wrappedRepositoryRefusal(repository: LinkedRepository): string {
+  return [
+    `${FRAMEWORK_NAME}: ${repository.id} is wrapped — \`${FRAMEWORK_NAME} claude\` and \`${FRAMEWORK_NAME} opencode\` do not run in a wrapped working repository.`,
+    "Start the session yourself: `claude` or `opencode` — the wrap delivers the companion guidance.",
+    `Or restore managed launches: \`${FRAMEWORK_NAME} unwrap\`.`,
+  ].join("\n");
+}
+
+/**
+ * The shape `projectWorkingRepositoryBestEffort` reports a failed projection
+ * in, narrowed to the entry that failed: the launch scope writes several, so
+ * "the projection" alone would not tell the operator what to fix.
+ */
+function projectionFailure(outcome: ProjectionEntryOutcome, repository: LinkedRepository): string {
+  const error = outcome.error ?? new Error("projection failed");
+  return `failed to write ${outcome.path} for ${repository.id}: ${error.message}`;
+}
+
 export class FrameworkLauncher {
   private readonly adapters = new Map<string, LaunchAdapter>([
     ["claude", new ClaudeAdapter()],
@@ -62,15 +118,27 @@ export class FrameworkLauncher {
     const state = await this.resolveLaunchState(request);
     const adapterContext = this.makeAdapterContext(state);
 
+    if (await launcherDeps.isWrapped(state.repository.path)) {
+      throw new LaunchPreflightError(wrappedRepositoryRefusal(state.repository));
+    }
+
     if (!request.skipGit && state.config.git === "auto") {
-      await launcherDeps.syncCompanionGit(state.companionPath, state.repository.path);
+      await launcherDeps.syncCompanionGit(
+        state.companionPath,
+        state.repository.path,
+        request.interactiveGit ?? false,
+      );
     }
     await launcherDeps.syncCompanionFiles(state.companionPath, state.config, state.repository.path);
-    await launcherDeps.syncWorkingRepoClaudeSettings(
-      state.repository.path,
-      state.companionPath,
-      state.config,
+    this.answerForProjection(
+      await launcherDeps.projectWorkingRepo({
+        repoPath: state.repository.path,
+        companionPath: state.companionPath,
+        config: state.config,
+      }),
+      state.repository,
     );
+    await launcherDeps.refreshProjectionRoot(state.companionPath, state.repository);
     await this.runCapabilityPreflight(state, request.tool);
     await state.adapter.validateLaunch(adapterContext);
 
@@ -115,6 +183,28 @@ export class FrameworkLauncher {
     };
   }
 
+  /**
+   * `project` reports its failures rather than throwing, so the launch scope's
+   * caller is the one that has to answer for them. A non-degradable entry is a
+   * guardrail the session was promised — writing the companion into the
+   * runtime's allow-list, for one — so the launch fails instead of starting
+   * without it. A degradable entry warns in the voice
+   * {@link projectWorkingRepositoryBestEffort} uses, and the launch proceeds.
+   */
+  private answerForProjection(result: ProjectionResult, repository: LinkedRepository): void {
+    for (const outcome of result.outcomes) {
+      if (outcome.state !== "failed" || !outcome.degradable) continue;
+      console.error(`${FRAMEWORK_NAME}: warning: ${projectionFailure(outcome, repository)}`);
+    }
+
+    const failure = firstFailure(result.outcomes);
+    if (failure) {
+      throw new LaunchPreflightError(
+        `${FRAMEWORK_NAME}: ${projectionFailure(failure, repository)}`,
+      );
+    }
+  }
+
   private makeAdapterContext(state: ResolvedLaunchState): AdapterContext {
     return {
       repository: state.repository,

package/src/lib/orchestrator/opencode-guidance.ts

@@ -1,58 +1,6 @@
-import { GUIDANCE_FILE_VERSION, type MateGuidanceFile } from "../../runtime/guidance";
-
-import {
-  buildCodebaseExplorationGuidanceSection,
-  buildCompanionPolicyXml,
-  hasGraphifyCapability,
-  hasTokensaveCapability,
-} from "../../playbooks/companion-guidance";
-import type { CapabilityConfig } from "./types";
-
 /**
- * Build the companion guidance payload delivered to the OpenCode plugin
- * through the `MATE_GUIDANCE_JSON` launch environment variable. The guidance
- * text carries `$MATE_*` placeholders; the plugin materializes them from the
- * session environment, so the same payload shape serves every companion.
- *
- * Real capabilities are passed through (not just the graphify/tokensave
- * flags) so capability-gated companion-policy rules — e.g. openspec-finish —
- * render exactly as they do for the Claude provider.
+ * The OpenCode guidance payload. Built in `runtime/` so the plugin can build
+ * the same payload from the Projection Root when no launch injected one; this
+ * module stays as the orchestrator-side name the launch adapter imports.
  */
-export function buildOpenCodeGuidance(capabilities: CapabilityConfig[]): MateGuidanceFile {
-  const companionGuidance = buildCompanionPolicyXml(
-    {
-      companionPath: "$MATE_ARTIFACT_PATH",
-      repository: {
-        id: "$MATE_REPO_ID",
-        path: "$MATE_REPO_PATH",
-      },
-      allowedAgents: [],
-      capabilities,
-    },
-    { wrapperBinPath: "$MATE_WRAPPER_BIN_PATH" },
-  );
-  const graphifyEnabled = hasGraphifyCapability(capabilities);
-  const tokensaveEnabled = hasTokensaveCapability(capabilities);
-  const codebaseExplorationGuidance = buildCodebaseExplorationGuidanceSection({
-    useGraphify: graphifyEnabled,
-    useTokensave: tokensaveEnabled,
-  });
-  const errors: string[] = [];
-
-  if (!companionGuidance.includes("<companion-policy ")) {
-    errors.push("companion guidance was not injected");
-  }
-  if (
-    (graphifyEnabled || tokensaveEnabled) &&
-    !codebaseExplorationGuidance.includes("<codebase-exploration-rules ")
-  ) {
-    errors.push("codebase exploration guidance was not injected");
-  }
-
-  return {
-    version: GUIDANCE_FILE_VERSION,
-    companionGuidance,
-    codebaseExplorationGuidance,
-    errors,
-  };
-}
+export { buildOpenCodeGuidance } from "../../runtime/companion-guidance";