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

package/src/tools/setup/providers/opencode.ts

@@ -18,6 +18,7 @@ import {
   upsertManagedBlock,
 } from "../context-services";
 import type { CapabilityContributionInput, ProviderPlugin, SetupContext } from "../plugin";
+import { surfaceRoot } from "../surface-target";
 import { mergeDir, pruneEmptyAncestors } from "../utils";
 import {
   getOpenCodePluginReferences,
@@ -424,22 +425,23 @@ export async function reconcileOpenCodeContributions(
   ctx: SetupContext,
   inputs: CapabilityContributionInput[],
 ): Promise<void> {
-  const { companionPath } = ctx;
+  /** Resolved once per pass; every write site below is relative to it. */
+  const root = surfaceRoot(ctx);
 
   if (ctx.scope === "hub") {
-    await reconcileOpenCodeMcpContributions(ctx, inputs);
-    await reconcileOpenCodeAgentDefinitionContributions(ctx, inputs);
+    await reconcileOpenCodeMcpContributions(root, inputs);
+    await reconcileOpenCodeAgentDefinitionContributions(root, inputs);
     return;
   }
 
-  await reconcileOpenCodeMcpContributions(ctx, inputs);
-  await reconcileOpenCodeAgentDefinitionContributions(ctx, inputs);
+  await reconcileOpenCodeMcpContributions(root, inputs);
+  await reconcileOpenCodeAgentDefinitionContributions(root, inputs);
 
   for (const input of inputs) {
     for (const pluginReference of input.contributions.pluginReferences ?? []) {
       const configFiles = pluginReference.configFiles ?? OPENCODE_CONTRIBUTION_CONFIG_FILES;
       for (const name of configFiles) {
-        const configPath = path.join(companionPath, ".opencode", name);
+        const configPath = path.join(root, ".opencode", name);
         const { present, config } = await readOpenCodeConfig(configPath);
         if (!input.enabled && !present) continue;
         const preserved = getOpenCodePluginReferences(config).filter(
@@ -456,7 +458,7 @@ export async function reconcileOpenCodeContributions(
     // Guidance sections are managed blocks in AGENTS.md. Capability disable
     // strips them here; runtime teardown of the shared AGENTS.md is guarded in
     // the provider teardown paths (kept while another active runtime uses it).
-    const guidancePath = path.join(companionPath, "AGENTS.md");
+    const guidancePath = path.join(root, "AGENTS.md");
     const sections = input.enabled ? (input.contributions.guidanceSections ?? []) : [];
     const keepKeys = new Set<string>();
     for (const section of sections) {
@@ -469,12 +471,12 @@ export async function reconcileOpenCodeContributions(
     }
 
     for (const skillTree of input.contributions.skillTrees ?? []) {
-      const skillDir = path.join(companionPath, ".opencode", "skills", skillTree.name);
+      const skillDir = path.join(root, ".opencode", "skills", skillTree.name);
       if (input.enabled) {
         await mergeDir(skillTree.sourceDir, skillDir);
       } else {
         await fs.rm(skillDir, { recursive: true, force: true });
-        await pruneEmptyAncestors(path.join(companionPath, ".opencode", "skills"), companionPath);
+        await pruneEmptyAncestors(path.join(root, ".opencode", "skills"), root);
       }
     }
   }
@@ -482,13 +484,13 @@ export async function reconcileOpenCodeContributions(
 
 /** Reconcile only MCP entries without touching OpenCode plugins or guidance. */
 async function reconcileOpenCodeMcpContributions(
-  ctx: SetupContext,
+  root: string,
   inputs: CapabilityContributionInput[],
 ): Promise<void> {
   for (const input of inputs) {
     for (const descriptor of input.contributions.mcpServers ?? []) {
       await updateOpenCodeMcpServer(
-        getCompanionOpenCodeConfigPath(ctx.companionPath),
+        getCompanionOpenCodeConfigPath(root),
         descriptor.name,
         input.enabled ? toOpenCodeMcpEntry(descriptor) : null,
       );
@@ -496,6 +498,31 @@ async function reconcileOpenCodeMcpContributions(
   }
 }
 
+/** The Mate-managed `mcp` map of one pass, as a value. */
+export function renderManagedOpenCodeMcpServers(
+  contributions: CapabilityContributionInput[] = [],
+): Record<string, unknown> {
+  const servers: Record<string, unknown> = {};
+  for (const input of contributions) {
+    if (!input.enabled) continue;
+    for (const descriptor of input.contributions.mcpServers ?? []) {
+      servers[descriptor.name] = toOpenCodeMcpEntry(descriptor);
+    }
+  }
+  return servers;
+}
+
+/**
+ * The Mate-managed `permission.external_directory` map, as a value. Rendered
+ * once for both destinations a session can reach it through — the projected
+ * document and the launch environment — so the two cannot drift.
+ */
+export function renderCompanionExternalDirectoryPermissions(
+  companionPath: string,
+): Record<string, string> {
+  return { [companionPath]: "allow", [`${companionPath}/**`]: "allow" };
+}
+
 /**
  * Reconcile declared agent definition files under `.opencode/agents/`. Runs
  * in both companion and hub scope — an agent definition is fully
@@ -503,10 +530,10 @@ async function reconcileOpenCodeMcpContributions(
  * surface.
  */
 async function reconcileOpenCodeAgentDefinitionContributions(
-  ctx: SetupContext,
+  root: string,
   inputs: CapabilityContributionInput[],
 ): Promise<void> {
-  const agentsDir = path.join(ctx.companionPath, ".opencode", "agents");
+  const agentsDir = path.join(root, ".opencode", "agents");
   for (const input of inputs) {
     for (const agent of input.contributions.agentDefinitions ?? []) {
       const agentPath = path.join(agentsDir, `${agent.name}.md`);
@@ -515,7 +542,7 @@ async function reconcileOpenCodeAgentDefinitionContributions(
         await fs.writeFile(agentPath, agent.content, "utf8");
       } else {
         await fs.rm(agentPath, { force: true });
-        await pruneEmptyAncestors(agentsDir, ctx.companionPath);
+        await pruneEmptyAncestors(agentsDir, root);
       }
     }
   }

package/src/tools/setup/runtime-documents.ts

@@ -0,0 +1,174 @@
+import {
+  CLAUDE_LOCAL_CONFIG_DOCUMENT,
+  CLAUDE_MCP_DOCUMENT,
+  CLAUDE_SETTINGS_DOCUMENT,
+  OPENCODE_CONFIG_DOCUMENT,
+} from "../../lib/orchestrator/projection-runtime-documents";
+import type {
+  ManagedRegion,
+  RenderedRuntimeDocument,
+} from "../../lib/orchestrator/projection-types";
+import { getOpenCodePluginPackageReference } from "../../lib/opencode-plugin-package";
+import type { CapabilityContributionInput, SetupContext } from "./plugin";
+import {
+  mateBannerHookGroups,
+  mateGuardHookGroups,
+  mateGuidanceHookGroups,
+} from "./providers/claude-plugin-hooks";
+import {
+  renderManagedClaudeMcpServers,
+  renderManagedClaudePermissionEntries,
+} from "./providers/claude";
+import {
+  renderCompanionExternalDirectoryPermissions,
+  renderManagedOpenCodeMcpServers,
+} from "./providers/opencode";
+import { projectionRepoRoot } from "./surface-target";
+
+/**
+ * The working target's documents, rendered as values. Each is a document the
+ * runtime finds by walking up from the current directory, and every path inside
+ * one still names the Companion Repository — only where the document is placed
+ * differs from the companion target.
+ */
+
+export {
+  CLAUDE_LOCAL_CONFIG_DOCUMENT,
+  CLAUDE_MCP_DOCUMENT,
+  CLAUDE_SETTINGS_DOCUMENT,
+  OPENCODE_CONFIG_DOCUMENT,
+};
+
+function nonEmpty(region: ManagedRegion): boolean {
+  if (region.kind === "list") return region.values.length > 0;
+  if (region.kind === "map") return Object.keys(region.entries).length > 0;
+  return true;
+}
+
+function document(documentPath: string, regions: ManagedRegion[]): RenderedRuntimeDocument[] {
+  const kept = regions.filter(nonEmpty);
+  return kept.length > 0 ? [{ path: documentPath, regions: kept }] : [];
+}
+
+/**
+ * The Mate plugin reference is what makes an Unmanaged OpenCode session load
+ * the companion guidance at all: OpenCode has no config channel for a generated
+ * system prompt, so the plugin is the only injection point, and a bare session
+ * loads no companion config to find it in.
+ *
+ * A managed launch does load the plugin twice — its `OPENCODE_CONFIG_DIR` names
+ * the companion, whose config carries the same reference. That is inert rather
+ * than doubled: the plugin skips its own emission when the companion-policy
+ * marker is already in the prompt.
+ */
+
+/**
+ * Capability hook groups stay companion-only. A managed session loads this
+ * document as its `local` source *alongside* the companion's, so anything here
+ * that the launch also delivers runs twice; the guard, the guidance hook and
+ * the banner are the contributions whose absence is a correctness hole and
+ * whose double run is inert — the guard because its verdict depends only on the
+ * tool input, the guidance hook because it yields nothing under a launch
+ * environment, and the banner because the copy carried here is flagged
+ * `--projected` and defers to the one the launch's own plugin prints.
+ *
+ * `CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD` is what a managed launch sets
+ * beside `--add-dir`. Without it the companion directories this document
+ * already permits are reachable but their `CLAUDE.md` is not loaded, so the
+ * permission alone delivers no guidance.
+ */
+function claudeSettingsRegions(
+  ctx: SetupContext,
+  inputs: CapabilityContributionInput[],
+): ManagedRegion[] {
+  return [
+    { at: ["hooks", "PreToolUse"], kind: "list", values: mateGuardHookGroups() },
+    {
+      at: ["hooks", "SessionStart"],
+      kind: "list",
+      values: [...mateBannerHookGroups(), ...mateGuidanceHookGroups()],
+    },
+    /**
+     * `stripPrefix` heals a repository an older Mate wrapped. That version wrote
+     * the whole launch environment here, and Claude Code applies `env` to the
+     * session, so every hook in a bare session inherited `MATE_*` and read the
+     * repository as a Managed Session — silently, since looking managed is
+     * exactly what makes the guidance hook emit nothing. Guidance must be the
+     * projection's to give in an Unmanaged Session, so no `MATE_*` key may
+     * survive here.
+     */
+    {
+      at: ["env"],
+      kind: "map",
+      entries: { CLAUDE_CODE_ADDITIONAL_DIRECTORIES_CLAUDE_MD: "1" },
+      stripPrefix: "MATE_",
+    },
+    {
+      at: ["permissions", "allow"],
+      kind: "list",
+      values: renderManagedClaudePermissionEntries(ctx.companionPath, inputs),
+    },
+  ];
+}
+
+export function renderDocumentsForTarget(
+  ctx: SetupContext,
+  inputsByRuntime: Map<string, CapabilityContributionInput[]>,
+): RenderedRuntimeDocument[] {
+  const repoRoot = projectionRepoRoot(ctx);
+
+  const documents: RenderedRuntimeDocument[] = [];
+  if (ctx.activeProviders.includes("claude")) {
+    const inputs = inputsByRuntime.get("claude") ?? [];
+    documents.push(...document(CLAUDE_SETTINGS_DOCUMENT, claudeSettingsRegions(ctx, inputs)));
+    /**
+     * Local scope, not `.mcp.json`: a project-scoped server is inert until a
+     * human approves it in a session, which an Unmanaged Session is exactly the
+     * case that cannot rely on. The repo path is the key Claude Code files a
+     * project under, resolved so a symlinked working directory still matches.
+     *
+     * Confirmed against a real `~/.claude.json`: the keys there are the
+     * directories sessions started in, not repository roots — sibling
+     * directories of one checkout each hold their own entry, as do temporary
+     * directories. So this reaches exactly one session: the one started at the
+     * repository root. A session started in a subdirectory of a wrapped
+     * repository has its own key, finds no `mcpServers` under it, and sees none
+     * of these servers — the Unmanaged Session case this document exists for,
+     * missed. That limit is deliberate. The directories a session might start
+     * in are unbounded, and every one of them would be a fresh entry in the
+     * user's global configuration that nothing later reclaims; keying the
+     * repository root only keeps the projection's footprint there to a single
+     * key. A subdirectory session still gets the rest of the projection — the
+     * documents inside the repository are found by the runtime's own upward
+     * walk — it loses only the MCP servers.
+     */
+    documents.push(
+      ...document(CLAUDE_LOCAL_CONFIG_DOCUMENT, [
+        {
+          at: ["projects", repoRoot, "mcpServers"],
+          kind: "map",
+          entries: renderManagedClaudeMcpServers(inputs),
+        },
+      ]),
+    );
+  }
+  if (ctx.activeProviders.includes("opencode")) {
+    const inputs = inputsByRuntime.get("opencode") ?? [];
+    documents.push(
+      ...document(OPENCODE_CONFIG_DOCUMENT, [
+        {
+          at: ["plugin"],
+          kind: "list",
+          values: [getOpenCodePluginPackageReference()],
+        },
+        { at: ["mcp"], kind: "map", entries: renderManagedOpenCodeMcpServers(inputs) },
+        {
+          at: ["permission", "external_directory"],
+          kind: "map",
+          entries: renderCompanionExternalDirectoryPermissions(ctx.companionPath),
+        },
+      ]),
+    );
+  }
+  return documents;
+}

package/src/tools/setup/surface-target.ts

@@ -0,0 +1,50 @@
+import path from "node:path";
+
+import type { ProjectionTarget, SetupContext } from "./plugin";
+
+/**
+ * The projection target of a reconcile pass, resolved once. A `working` pass
+ * without a Working Repository in scope refuses rather than falling back to the
+ * companion: writing the other root is the one outcome the caller cannot detect.
+ */
+export function projectionTarget(ctx: SetupContext): ProjectionTarget {
+  const target = ctx.target ?? "companion";
+  if (target === "working" && !ctx.repoPath) {
+    throw new Error(
+      "a working-target reconcile needs a Working Repository in scope; none was supplied",
+    );
+  }
+  return target;
+}
+
+/**
+ * The Working Repository a rendered document is addressed by, resolved so a
+ * symlinked working directory still matches what the runtime reports. Every
+ * document a reconcile pass renders is for a Working Repository, so a pass with
+ * none in scope refuses here rather than resolving an absent path: `path.resolve`
+ * answers the current working directory for an empty one, and a document keyed
+ * by wherever the process happened to start would file a Runtime Surface's MCP
+ * servers under a stranger's project in the user's global Claude config — a
+ * write no caller asked for and none would notice.
+ */
+export function projectionRepoRoot(ctx: SetupContext): string {
+  const target = projectionTarget(ctx);
+  if (!ctx.repoPath) {
+    throw new Error(
+      `a ${target}-target render needs a Working Repository in scope to address its documents by; none was supplied`,
+    );
+  }
+  return path.resolve(ctx.repoPath);
+}
+
+/**
+ * The root a Runtime Surface writes into. Defined for the companion target
+ * only: a working-target pass renders its documents for the Projection Root to
+ * place, so no Runtime Surface ever computes a path inside a Working Repository.
+ */
+export function surfaceRoot(ctx: SetupContext): string {
+  if (projectionTarget(ctx) === "working") {
+    throw new Error("a working-target reconcile renders its documents; it writes no surface root");
+  }
+  return ctx.companionPath;
+}

package/src/tools/setup/working-repo-cleanup.ts

@@ -1,40 +1,47 @@
-import fs from "node:fs/promises";
-
-import { repoLocalDirPath } from "../../lib/orchestrator/repo-local-registry";
-import { cleanupWorkingRepoClaudeSettings } from "./providers/claude";
-import { removeWorkingRepoLocalExcludes } from "./working-repo-local-state";
+import { unproject } from "../../lib/orchestrator/working-repo-projection";
+import type { ProjectionEntryId } from "../../lib/orchestrator/projection-types";
 
 export interface WorkingRepoCleanupResult {
   changed: boolean;
   removed: string[];
   updated: string[];
+  /** Entries `unproject` deliberately left in place, named rather than omitted. */
+  retained: string[];
 }
 
-async function pathExists(candidatePath: string): Promise<boolean> {
-  try {
-    await fs.access(candidatePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
+/**
+ * How an entry is reported. Presentation only — cleanup holds no list of paths,
+ * so a newly declared entry is removed without touching this map.
+ */
+const REPORTED_AS: Partial<
+  Record<ProjectionEntryId, { as: "removed" | "updated"; label: string }>
+> = {
+  "projection-root": { as: "removed", label: ".mate" },
+  "git-excludes": { as: "removed", label: "git-excludes" },
+  "claude-working-settings": { as: "updated", label: "claude-settings" },
+  "legacy-tokensave-claude-md": { as: "updated", label: "claude-settings" },
+};
 
 export async function cleanupWorkingRepository(
   repoPath: string,
-  registeredCompanionPaths: string[],
+  registeredCompanionPaths: string[] = [],
 ): Promise<WorkingRepoCleanupResult> {
-  const updated: string[] = [];
+  const { outcomes } = await unproject({ repoPath, registeredCompanionPaths });
   const removed: string[] = [];
-  if (await cleanupWorkingRepoClaudeSettings(repoPath, registeredCompanionPaths)) {
-    updated.push("claude-settings");
-  }
-  if (await removeWorkingRepoLocalExcludes(repoPath)) {
-    removed.push("git-excludes");
-  }
-  const localDir = repoLocalDirPath(repoPath);
-  if (await pathExists(localDir)) {
-    await fs.rm(localDir, { recursive: true, force: true });
-    removed.unshift(".mate");
+  const updated: string[] = [];
+  const retained: string[] = [];
+
+  for (const entry of outcomes) {
+    if (entry.state === "retained") {
+      retained.push(entry.id);
+      continue;
+    }
+    if (entry.state !== "removed") continue;
+    const reported = REPORTED_AS[entry.id];
+    if (!reported) continue;
+    const bucket = reported.as === "removed" ? removed : updated;
+    if (!bucket.includes(reported.label)) bucket.push(reported.label);
   }
-  return { changed: removed.length > 0 || updated.length > 0, removed, updated };
+
+  return { changed: removed.length > 0 || updated.length > 0, removed, updated, retained };
 }

package/src/tools/setup/working-repo-local-state.ts

@@ -5,7 +5,8 @@ import { resolveGitInfoExcludePath } from "./git-utils";
 
 const MANAGED_BLOCK_START = "# mate managed: start";
 const MANAGED_BLOCK_END = "# mate managed: end";
-const CORE_EXCLUDE_ENTRIES = ["/.mate/", "/.claude/", "/.opencode/", "/.agents/"];
+/** `.mcp.json` is the one working-target document no directory entry covers. */
+const CORE_EXCLUDE_ENTRIES = ["/.mate/", "/.claude/", "/.opencode/", "/.agents/", "/.mcp.json"];
 const LEGACY_CORE_EXCLUDE_ENTRIES = new Set([".mate/", ".claude/settings.local.json"]);
 
 async function readExclude(excludePath: string): Promise<string> {
@@ -90,6 +91,25 @@ export async function reconcileWorkingRepoCapabilityExcludes(
   return writeExclude(excludePath, existing, lines);
 }
 
+/** Whether the managed block is on disk; the block, not the exclude file. */
+export async function managedWorkingRepoExcludesPresent(repoPath: string): Promise<boolean> {
+  const excludePath = await resolveGitInfoExcludePath(repoPath);
+  if (!excludePath) return false;
+  const lines = contentLines(await readExclude(excludePath));
+  return lines.some((line) => line.trim() === MANAGED_BLOCK_START);
+}
+
+/** Whether any Capability-owned exclusion is present outside the managed block. */
+export async function workingRepoCapabilityExcludesPresent(
+  repoPath: string,
+  candidateEntries: string[],
+): Promise<boolean> {
+  const excludePath = await resolveGitInfoExcludePath(repoPath);
+  if (!excludePath) return false;
+  const lines = withoutManagedBlocks(contentLines(await readExclude(excludePath)));
+  return candidateEntries.some((entry) => lines.some((line) => line.trim() === entry));
+}
+
 export async function removeWorkingRepoLocalExcludes(repoPath: string): Promise<boolean> {
   const excludePath = await resolveGitInfoExcludePath(repoPath);
   if (!excludePath) return false;

package/src/tools/setup.ts

@@ -19,7 +19,6 @@ import {
   type CapabilityConfig,
   type FrameworkConfig,
 } from "../lib/orchestrator/types";
-import { syncWorkingRepoClaudeSettings } from "./setup/providers/claude";
 import {
   collectManagedGitignoreEntries,
   writeManagedGitignoreBlock,
@@ -35,10 +34,10 @@ import { installDeclaredPlugins } from "./setup/dynamic-plugins/install";
 import {
   buildSetupInstallationPlan,
   executeSetupInstallationPlan,
+  renderRuntimeDocuments,
   type SetupInstallationOutcome,
 } from "./setup/engine";
-
-export { syncWorkingRepoClaudeSettings };
+import type { RenderedRuntimeDocument } from "../lib/orchestrator/projection-types";
 
 export interface SetupInput {
   allowedAgents?: string[];
@@ -67,6 +66,29 @@ export async function applySetupCompatibilities(
   return executeSetupInstallationPlan(ctx, plugins, plan);
 }
 
+/**
+ * The active Agent Runtimes' documents for a Working Repository, rendered
+ * without a write. Runs no plugin phase: the working target reconciles
+ * declarations only, so nothing is written to the companion on its behalf.
+ */
+export async function renderWorkingRuntimeDocuments(
+  companionPath: string,
+  config: FrameworkConfig,
+  repoPath: string,
+  plugins: PluginRegistration[] = getActiveDistribution().registry.getAll(),
+): Promise<RenderedRuntimeDocument[]> {
+  const plan = buildSetupInstallationPlan(config, plugins);
+  const ctx: SetupContext = {
+    companionPath,
+    config,
+    mode: "sync",
+    activeProviders: plan.activeProviders,
+    repoPath,
+    target: "working",
+  };
+  return renderRuntimeDocuments(ctx, plugins, plan);
+}
+
 export async function updateProjectGitignore(
   companionPath: string,
   config: FrameworkConfig,

package/wrappers/bin/graphify

@@ -1,8 +1,59 @@
 #!/usr/bin/env bash
-[ -n "$MATE_ARTIFACT_PATH" ] || { echo "graphify: must be run via mate claude or mate opencode (MATE_ARTIFACT_PATH not set)" >&2; exit 1; }
-[ -n "$MATE_REPO_PATH" ] || { echo "graphify: must be run via mate claude or mate opencode (MATE_REPO_PATH not set)" >&2; exit 1; }
-
 _this_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+# Mate context: the launch environment first, the Working Repository's
+# Projection Root second. Projected values stay in private shell variables and
+# no MATE_-prefixed variable is exported: the projection carries paths and
+# never predicates, so a partial MATE_* environment would read to any child as
+# authoritative with every predicate disabled.
+_mate_projection_file() {
+  local dir="$PWD"
+  while :; do
+    if [ -f "$dir/.mate/config/registry.yaml" ]; then
+      [ -f "$dir/.mate/projection.env" ] && printf '%s' "$dir/.mate/projection.env"
+      return
+    fi
+    [ "$dir" = "/" ] && return
+    dir="$(dirname "$dir")"
+  done
+}
+
+_mate_projected() {
+  sed -n "s/^$2='\\(.*\\)'\$/\\1/p" "$1" | head -n 1 | sed "s/'\\\\''/'/g"
+}
+
+_mate_same_dir() {
+  local left="$1" right="$2"
+  [ -d "$left" ] && left="$(cd "$left" && pwd)"
+  [ -d "$right" ] && right="$(cd "$right" && pwd)"
+  [ "$left" = "$right" ]
+}
+
+_companion="$MATE_ARTIFACT_PATH"
+_repo_path="$MATE_REPO_PATH"
+_graphify_out="$GRAPHIFY_OUT"
+if [ -z "$_companion" ]; then
+  _projection="$(_mate_projection_file)"
+  if [ -n "$_projection" ]; then
+    _companion="$(_mate_projected "$_projection" MATE_ARTIFACT_PATH)"
+    _repo_path="$(_mate_projected "$_projection" MATE_REPO_PATH)"
+    _graphify_out="$(_mate_projected "$_projection" GRAPHIFY_OUT)"
+    _projected_wrapper_dir="$(_mate_projected "$_projection" MATE_WRAPPER_BIN_PATH)"
+    if [ -n "$_companion" ] && ! _mate_same_dir "$_projected_wrapper_dir" "$_this_dir"; then
+      {
+        echo "graphify: this repository was wrapped by a different mate install."
+        echo "  projected wrappers: $_projected_wrapper_dir"
+        echo "  running wrapper:    $_this_dir"
+        echo "  re-run \`mate wrap\` with this install."
+      } >&2
+      exit 1
+    fi
+  fi
+fi
+[ -n "$_companion" ] || { echo "graphify: no mate context here — run \`mate wrap\` in this repository" >&2; exit 1; }
+[ -n "$_repo_path" ] || { echo "graphify: no working repository in the mate context — run \`mate wrap\` in this repository" >&2; exit 1; }
+[ -n "$_graphify_out" ] || { echo "graphify: no graphify output path in the mate context — run \`mate wrap\` in this repository" >&2; exit 1; }
+
 _real=""
 IFS=:
 for _dir in $PATH; do
@@ -14,8 +65,6 @@ done
 unset IFS
 [ -n "$_real" ] || { echo "graphify wrapper: real graphify binary not found in PATH" >&2; exit 1; }
 
-_repo_id="${MATE_REPO_ID:-unknown}"
-_graphify_out="$MATE_ARTIFACT_PATH/.graphify/$_repo_id/graphify-out"
 _graphify_root="$(dirname "$_graphify_out")"
 _graph_json="$_graphify_out/graph.json"
 export GRAPHIFY_OUT="$_graphify_out"
@@ -32,18 +81,18 @@ case "$_cmd" in
         *) _rest+=("$_a") ;;
       esac
     done
-    exec "$_real" extract "$MATE_REPO_PATH" --out "$_graphify_root" "${_rest[@]}"
+    exec "$_real" extract "$_repo_path" --out "$_graphify_root" "${_rest[@]}"
     ;;
   update)
     if [ "$#" -eq 1 ] || [[ "$2" == -* ]]; then
-      exec "$_real" "$MATE_REPO_PATH" --update "${@:2}"
+      exec "$_real" "$_repo_path" --update "${@:2}"
     else
       exec "$_real" "$2" --update "${@:3}"
     fi
     ;;
   extract|watch|cluster-only|label|check-update)
     if [ "$#" -eq 1 ] || [[ "$2" == -* ]]; then
-      exec "$_real" "$_cmd" "$MATE_REPO_PATH" "${@:2}"
+      exec "$_real" "$_cmd" "$_repo_path" "${@:2}"
     else
       exec "$_real" "$@"
     fi