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

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

package/wrappers/bin/openspec

@@ -1,6 +1,53 @@
 #!/usr/bin/env bash
-[ -n "$MATE_ARTIFACT_PATH" ] || { echo "openspec: must be run via mate claude or mate opencode" >&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"
+if [ -z "$_companion" ]; then
+  _projection="$(_mate_projection_file)"
+  if [ -n "$_projection" ]; then
+    _companion="$(_mate_projected "$_projection" MATE_ARTIFACT_PATH)"
+    _projected_wrapper_dir="$(_mate_projected "$_projection" MATE_WRAPPER_BIN_PATH)"
+    if [ -n "$_companion" ] && ! _mate_same_dir "$_projected_wrapper_dir" "$_this_dir"; then
+      {
+        echo "openspec: 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 "openspec: no mate context here — run \`mate wrap\` in this repository" >&2; exit 1; }
+
 _real=""
 IFS=:
 for _dir in $PATH; do
@@ -22,7 +69,7 @@ if [ "$command" = "templates" ]; then
   done
   if [ "$has_schema" -eq 0 ]; then
     _schema=""
-    for _cfg in "$MATE_ARTIFACT_PATH/openspec/config.yaml" "$MATE_ARTIFACT_PATH/openspec/config.yml"; do
+    for _cfg in "$_companion/openspec/config.yaml" "$_companion/openspec/config.yml"; do
       [ -f "$_cfg" ] || continue
       while IFS= read -r _line; do
         case "$_line" in
@@ -45,4 +92,4 @@ if [ "$command" = "templates" ]; then
     fi
   fi
 fi
-exec env -C "$MATE_ARTIFACT_PATH" "$_real" "$@"
+exec env -C "$_companion" "$_real" "$@"

package/claude-plugin/hooks/artifact-finish-nudge.mjs

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-// Thin shim: hook logic lives in src/hooks/artifact-finish-nudge.ts, loaded
-// through ts-loader.mjs because the installed plugin sits inside node_modules
-// where node's native type stripping is disabled.
-import "./ts-loader.mjs";
-
-const { run } = await import("../../src/hooks/artifact-finish-nudge.ts");
-process.exitCode = await run();

package/src/cli/commands/cap/headroom.ts

@@ -1,52 +0,0 @@
-import { spawnSync } from "node:child_process";
-
-import { resolveForCapability } from "../../../lib/orchestrator/framework-context";
-import type { CapabilityConfig } from "../../../lib/orchestrator/types";
-import { ensureUnambiguousCompanion } from "../shared/companion-selection";
-
-export interface HeadroomCapDeps {
-  ensureUnambiguousCompanion?: (cwd: string) => Promise<boolean>;
-}
-
-/**
- * @command mate cap headroom [...args]
- * @description Forwards `[...args]` to the `headroom` CLI, run from the
- * companion directory. Requires the `headroom` capability to be enabled in
- * `.mate/config/framework.yaml`.
- * @remarks The child process's exit code is propagated via `process.exitCode`.
- */
-export async function runHeadroomCapCommand(
-  args: string[],
-  deps: HeadroomCapDeps = {},
-): Promise<void> {
-  const ensureCompanion = deps.ensureUnambiguousCompanion ?? ensureUnambiguousCompanion;
-  if (!(await ensureCompanion(process.cwd()))) {
-    process.exitCode = 1;
-    return;
-  }
-
-  const { companionPath, configStore } = await resolveForCapability(process.cwd());
-  const config = await configStore.load();
-
-  const capability = (config.capabilities ?? []).find(
-    (entry: CapabilityConfig) => entry.name === "headroom",
-  );
-
-  if (!capability) {
-    process.stderr.write("headroom capability is not enabled in .mate/config/framework.yaml\n");
-    process.exitCode = 1;
-    return;
-  }
-
-  const result = spawnSync("headroom", args, { cwd: companionPath, stdio: "inherit" });
-
-  if (result.error) {
-    process.stderr.write(`Failed to run headroom: ${result.error.message}\n`);
-    process.exitCode = 1;
-    return;
-  }
-
-  if (result.status !== null) {
-    process.exitCode = result.status;
-  }
-}

package/src/cli/commands/workspace/list.ts

@@ -1,25 +0,0 @@
-import { collectWorkspaceInventory } from "../../../lib/orchestrator/workspace-inventory";
-import { writeJsonStdout } from "../../write-json-stdout";
-
-export const workspaceListCommandDeps = {
-  collectWorkspaceInventory: () => collectWorkspaceInventory(),
-};
-
-/**
- * @command mate workspace list
- * @description Prints the aggregate inventory of registered companions and
- * their linked working-repository pairings as one JSON document. Runs
- * without a linked working repository or any active companion context.
- * @flags
- * - `--json` — required; this command only supports JSON output.
- */
-export async function runWorkspaceListCommand(argv: string[] = []): Promise<void> {
-  if (!argv.includes("--json")) {
-    process.stderr.write("mate: `workspace list` requires --json.\n");
-    process.exitCode = 1;
-    return;
-  }
-
-  const inventory = await workspaceListCommandDeps.collectWorkspaceInventory();
-  await writeJsonStdout(inventory);
-}