@uniqbit/mate-core 0.18.1-canary.0 → 0.18.1-canary.2

package/claude-plugin/hooks/session-banner.mjs

@@ -5,4 +5,4 @@
 import "./ts-loader.mjs";
 
 const { run } = await import("../../src/hooks/session-banner.ts");
-process.exitCode = run();
+process.exitCode = await run();

package/opencode-plugin/server.ts

@@ -0,0 +1,5 @@
+/**
+ * Root entry for a plugin bound by directory path: OpenCode resolves `<dir>/server`
+ * there and never reads `exports`, which serves only package-name references.
+ */
+export { default } from "./src/server";

package/opencode-plugin/src/add-dir.ts

@@ -0,0 +1,118 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import type { Context } from "@opencode/plugin/promise/plugin";
+
+type CompanionSkill = {
+  id: string;
+  name: string;
+  description?: string;
+  path: string;
+  content: string;
+};
+
+function companionSkillPaths(companionPath: string): string[] {
+  return [
+    path.join(companionPath, ".agents", "skills"),
+    path.join(companionPath, ".opencode", "skills"),
+  ];
+}
+
+function isWithin(root: string, candidate: string): boolean {
+  const relative = path.relative(root, path.resolve(candidate));
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function parseFrontmatter(content: string): { name?: string; description?: string } {
+  const match = content.match(/^---\s*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (!match) return {};
+
+  const scalar = (key: string) => {
+    const value = match[1].match(new RegExp(`^${key}:\\s*(.+)$`, "m"))?.[1]?.trim();
+    return value?.replace(
+      /^(?:"([\s\S]*)"|'([\s\S]*)')$/,
+      (_all, doubleQuoted, singleQuoted) => doubleQuoted ?? singleQuoted,
+    );
+  };
+
+  return { name: scalar("name"), description: scalar("description") };
+}
+
+async function findSkillFiles(directory: string): Promise<string[]> {
+  try {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files: string[] = [];
+    const subdirectories: Promise<string[]>[] = [];
+    for (const entry of entries) {
+      const entryPath = path.join(directory, entry.name);
+      if (entry.isFile() && entry.name === "SKILL.md") files.push(entryPath);
+      else if (entry.isDirectory()) subdirectories.push(findSkillFiles(entryPath));
+    }
+    const nested = await Promise.all(subdirectories);
+    return [...files, ...nested.flat()];
+  } catch {
+    return [];
+  }
+}
+
+function skillID(name: string): string {
+  return (
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9_-]+/g, "-")
+      .replace(/^-+|-+$/g, "") || "mate-skill"
+  );
+}
+
+async function loadCompanionSkills(companionPath: string): Promise<CompanionSkill[]> {
+  const files = (await Promise.all(companionSkillPaths(companionPath).map(findSkillFiles))).flat();
+  const skills = await Promise.all(
+    files.map(async (filePath): Promise<CompanionSkill | null> => {
+      try {
+        const content = await fs.readFile(filePath, "utf8");
+        const metadata = parseFrontmatter(content);
+        const name = metadata.name || path.basename(path.dirname(filePath));
+        return {
+          id: skillID(name),
+          name,
+          ...(metadata.description ? { description: metadata.description } : {}),
+          path: filePath,
+          content,
+        };
+      } catch {
+        /** An unreadable companion skill must not prevent the session from loading. */
+        return null;
+      }
+    }),
+  );
+  return skills.filter((skill) => skill !== null);
+}
+
+/**
+ * Grants the session access to the companion and registers its skills. The
+ * permission hook only widens access for companion resources; every other
+ * evaluation keeps OpenCode's own verdict.
+ */
+export async function registerCompanionAccess(api: Context, companionPath: string): Promise<void> {
+  const permissionRoot = path.resolve(companionPath);
+
+  await api.permission.hook("evaluate", (event) => {
+    if (event.resources.some((resource) => isWithin(permissionRoot, resource))) {
+      event.effect = "allow";
+      delete event.message;
+    }
+  });
+
+  const skills = await loadCompanionSkills(permissionRoot);
+  if (skills.length === 0) return;
+
+  await api.skill.transform((editor) => {
+    for (const skill of skills) {
+      if (editor.get(skill.id)) {
+        editor.update(skill.id, (current) => Object.assign(current, skill));
+      } else {
+        editor.add(skill as never);
+      }
+    }
+  });
+}

package/opencode-plugin/src/companion.ts

@@ -0,0 +1,180 @@
+import path from "node:path";
+
+import type { Context } from "@opencode/plugin/promise/plugin";
+import { MATE_ENV } from "../../src/runtime/env";
+import { COMPANION_POLICY_MARKER, type MateGuidanceFile } from "../../src/runtime/guidance";
+
+import type { CompanionContext } from "../../src/opencode/companion-policy";
+import { resolveOpenCodeGuidance } from "../../src/opencode/projected-guidance";
+
+function prependPathEntry(pathValue: string | undefined, entry: string): string {
+  const entries = (pathValue ?? "").split(path.delimiter).filter(Boolean);
+  return [entry, ...entries.filter((value) => value !== entry)].join(path.delimiter);
+}
+
+function resolveWrapperBinPath(): string {
+  return process.env.MATE_WRAPPER_BIN_PATH ?? "$MATE_WRAPPER_BIN_PATH";
+}
+
+function buildStartupError(details: string[]): Error {
+  return new Error(
+    [
+      "Mate OpenCode companion plugin is incomplete and cannot start.",
+      ...details.map((detail) => `- ${detail}`),
+      "Launch through `mate opencode`, or run `mate wrap` so the guidance resolves from the Projection Root.",
+    ].join("\n"),
+  );
+}
+
+/**
+ * Env first, projection second. A session Mate launched carries the payload;
+ * an Unmanaged Session in a wrapped repository builds the same payload from the
+ * companion the projection names, with the Capability names read live.
+ */
+function loadGuidance(directory: string): MateGuidanceFile | null {
+  const { guidance, errors } = resolveOpenCodeGuidance(process.env, directory);
+  if (errors.length > 0) throw buildStartupError(errors);
+  return guidance;
+}
+
+function materializeCompanionGuidance(guidance: string, context: CompanionContext): string {
+  const wrapperBinPath = resolveWrapperBinPath();
+  return guidance
+    .replaceAll("$MATE_REPO_PATH", context.repositoryPath)
+    .replaceAll("$MATE_ARTIFACT_PATH", context.companionPath)
+    .replaceAll("$MATE_WRAPPER_BIN_PATH", wrapperBinPath)
+    .replaceAll("$MATE_REPO_ID", context.repositoryId);
+}
+
+function buildSystemPrompt(context: CompanionContext, guidance: MateGuidanceFile): string[] {
+  const lines = [materializeCompanionGuidance(guidance.companionGuidance, context)];
+
+  if (guidance.codebaseExplorationGuidance.trim()) {
+    lines.push("", guidance.codebaseExplorationGuidance);
+  }
+
+  if (context.agentsMd.trim()) {
+    lines.push("", `<agents.md>${context.agentsMd.trim()}</agents.md>`);
+  }
+
+  return lines;
+}
+
+function readSystemText(part: unknown): string {
+  if (typeof part === "string") return part;
+  if (typeof part !== "object" || part === null || !("text" in part)) return "";
+  return typeof part.text === "string" ? part.text : "";
+}
+
+/** Session-scoped variables a spawned shell sees; mutates `env` in place. */
+function applyCompanionShellEnv(
+  context: CompanionContext,
+  env: Record<string, string | undefined>,
+): void {
+  const wrapperBinPath = resolveWrapperBinPath();
+  env.MATE_NAME = context.frameworkName;
+  env.MATE_VERSION = process.env.MATE_VERSION ?? "unknown";
+  env.MATE_ARTIFACT_PATH = context.companionPath;
+  env.MATE_WRAPPER_BIN_PATH = wrapperBinPath;
+  if (context.repositoryPath) {
+    env.MATE_REPO_PATH = context.repositoryPath;
+    env.MATE_REPO_ID = context.repositoryId;
+  } else {
+    delete env.MATE_REPO_PATH;
+    delete env.MATE_REPO_ID;
+  }
+  env.MATE_POLICY_JSON = context.policyJson;
+  env.MATE_GRAPHIFY_ENABLED = context.graphifyEnabled ? "1" : "0";
+  env.MATE_GIT_AUTO_MODE = context.gitAutoModeEnabled ? "1" : "0";
+  /**
+   * Session-scoped payload consumed at plugin startup: masked so the multi-KB
+   * guidance JSON never leaks into spawned shells (and a nested `mate` launch
+   * can never inherit a stale copy).
+   */
+  env[MATE_ENV.guidanceJson] = "";
+  env.PATH = prependPathEntry(process.env.PATH, wrapperBinPath);
+}
+
+function companionPathsResult(context: CompanionContext) {
+  const wrapperBinPath = resolveWrapperBinPath();
+  return {
+    content: JSON.stringify(
+      {
+        companionFrameworkPath: context.companionPath,
+        wrapperBinPath,
+        ...(context.repositoryPath
+          ? { repositoryPath: context.repositoryPath, repositoryId: context.repositoryId }
+          : {}),
+        policy: JSON.parse(context.policyJson || "{}"),
+      },
+      null,
+      2,
+    ),
+    metadata: {
+      companionPath: context.companionPath,
+      wrapperBinPath,
+      ...(context.repositoryPath ? { repositoryPath: context.repositoryPath } : {}),
+    },
+  };
+}
+
+/**
+ * A wrapped repository lists this plugin in its own project config, so a
+ * managed launch may load it twice; the marker keeps the second load inert.
+ */
+function hasCompanionPolicy(system: unknown[]): boolean {
+  return system.map(readSystemText).join("\n").includes(COMPANION_POLICY_MARKER);
+}
+
+/**
+ * Collapses the whole system prompt into a single entry. OpenCode sends each
+ * `system[]` element as its own system message, and some self-hosted chat
+ * templates (e.g. Qwen served via vLLM) reject any system message that is not
+ * the very first one.
+ */
+function mergeCompanionSystem(system: unknown[], companion: string): string[] {
+  if (hasCompanionPolicy(system)) return system.map(readSystemText);
+  const parts: string[] = [];
+  for (const text of [...system.map(readSystemText), companion]) {
+    const trimmed = text.trim();
+    if (trimmed.length > 0) parts.push(trimmed);
+  }
+  return parts.length > 0 ? [parts.join("\n\n")] : [];
+}
+
+/** Registers guidance, compaction context, shell env, and `companion_paths`. */
+export async function registerCompanion(api: Context, context: CompanionContext): Promise<void> {
+  const guidance = loadGuidance(api.location.directory);
+  if (!guidance) return;
+
+  const companion = buildSystemPrompt(context, guidance).join("\n");
+
+  await api.session.hook("context", (event) => {
+    const merged = mergeCompanionSystem(event.system, companion);
+    event.system.splice(
+      0,
+      event.system.length,
+      ...merged.map((text) => ({ type: "text" as const, text }) as never),
+    );
+  });
+
+  await api.session.hook("compaction", (event) => {
+    if (hasCompanionPolicy(event.system)) return;
+    event.system.push({ type: "text", text: companion } as never);
+  });
+
+  await api.shell.hook("create.before", (event) => {
+    applyCompanionShellEnv(context, event.env);
+  });
+
+  await api.tool.transform((editor) => {
+    editor.add({
+      name: "companion_paths",
+      description: `Return active ${context.frameworkName} companion framework and working repository paths.`,
+      input: { type: "object", properties: {}, additionalProperties: false },
+      async execute() {
+        return companionPathsResult(context);
+      },
+    });
+  });
+}

package/opencode-plugin/src/server.ts

@@ -0,0 +1,26 @@
+import { Plugin } from "@opencode/plugin";
+import { registerCompanionHooks } from "../../src/opencode/companion-hooks";
+import { readContext } from "../../src/opencode/companion-policy";
+
+import { registerCompanionAccess } from "./add-dir";
+import { registerCompanion } from "./companion";
+
+/**
+ * Mate OpenCode server plugin (OpenCode 2.x). Loaded through the package's
+ * `./server` export; stays inert when no companion resolves from the launch
+ * environment or a Projection Root above the session directory.
+ */
+export const MateOpenCodePlugin = Plugin.define({
+  id: "mate-opencode-plugin",
+  async setup(api) {
+    const context = readContext(process.env, api.location.directory);
+    if (!context.companionPath) return;
+
+    await registerCompanionAccess(api, context.companionPath);
+    const cleanup = await registerCompanionHooks(api, context);
+    await registerCompanion(api, context);
+    return cleanup;
+  },
+});
+
+export default MateOpenCodePlugin;

package/opencode-plugin/src/tui.tsx

@@ -0,0 +1 @@
+export { default } from "../../src/opencode/tui";

package/opencode-plugin/tui.tsx

@@ -0,0 +1,2 @@
+/** Root entry for a plugin bound by directory path; see `server.ts`. */
+export { default } from "./src/tui";

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@uniqbit/mate-core",
-  "version": "0.18.1-canary.0",
+  "version": "0.18.1-canary.2",
   "description": "Core framework and plugin APIs for Mate.",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uniqbit-ag/mate-cli.git",
+    "directory": "packages/mate-core"
+  },
   "files": [
     "src/",
     "wrappers/",
     "claude-plugin/",
+    "opencode-plugin/",
     "!src/**/*.test.ts",
-    "!src/**/*.test.tsx"
+    "!src/**/*.test.tsx",
+    "!opencode-plugin/**/*.test.ts"
   ],
   "type": "module",
   "exports": {
@@ -26,10 +33,10 @@
   "scripts": {
     "test": "CI=1 bun ../../test/run-isolated.ts",
     "typecheck": "bunx tsc --noEmit -p ../../tsconfig.json",
-    "lint": "oxlint src/",
-    "lint:fix": "oxlint src/ --fix",
-    "format": "oxfmt src/ \"!**/*.generated.*\" \"!**/report-assets/**\"",
-    "format:check": "oxfmt src/ \"!**/*.generated.*\" \"!**/report-assets/**\" --check"
+    "lint": "oxlint src/ opencode-plugin/",
+    "lint:fix": "oxlint src/ opencode-plugin/ --fix",
+    "format": "oxfmt src/ opencode-plugin/ \"!**/*.generated.*\" \"!**/report-assets/**\"",
+    "format:check": "oxfmt src/ opencode-plugin/ \"!**/*.generated.*\" \"!**/report-assets/**\" --check"
   },
   "dependencies": {
     "@opencode/plugin": "^2.0.23",

package/src/cli/commands/artifact/finish/engine.ts

@@ -181,7 +181,7 @@ export async function runFinishEngine(
         await git.fetch();
       } catch (err) {
         // Post-commit failure: retain the commit, do not roll back.
-        fail("sync-remote", `mate: fetch failed: ${String(err)}`);
+        fail("sync-remote", `mate: fetch failed (commit retained locally): ${String(err)}`);
         return result;
       }
       const rebase = await git.rebaseOntoUpstream();

package/src/cli/commands/artifact/finish/git.ts

@@ -1,7 +1,12 @@
 import fs from "node:fs";
-import { spawnSync } from "node:child_process";
 import path from "node:path";
 
+import {
+  companionGit,
+  isAuthenticationFailure,
+  type NetworkGitResult,
+} from "../../../../runtime/companion-git";
+
 export interface RebaseResult {
   ok: boolean;
   conflictedPaths: string[];
@@ -44,28 +49,23 @@ export interface GitOps {
   push(): Promise<PushResult>;
 }
 
-function gitRun(
-  companionPath: string,
-  args: string[],
-): { status: number; out: string; err: string } {
-  const {
-    GIT_DIR: _gitDir,
-    GIT_WORK_TREE: _gitWorkTree,
-    GIT_COMMON_DIR: _gitCommonDir,
-    GIT_INDEX_FILE: _gitIndexFile,
-    ...gitEnv
-  } = process.env;
-  const result = spawnSync("git", args, {
-    cwd: companionPath,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    env: gitEnv,
-  });
-  return {
-    status: result.status ?? 1,
-    out: (result.stdout ?? "").trimEnd(),
-    err: (result.stderr ?? "").trim(),
-  };
+export interface GitOpsOptions {
+  /** Environment Git runs with. */
+  env?: Record<string, string | undefined>;
+}
+
+/**
+ * Publication never prompts, so a credential failure must say how to supply
+ * credentials non-interactively; the retained commit and tag make a re-run safe.
+ */
+function remoteFailureDetail(result: NetworkGitResult): string {
+  const detail = result.stderr.trim() || result.stdout.trim() || "unknown Git error";
+  if (!isAuthenticationFailure(result)) return detail;
+  const remedy =
+    result.transport === "ssh"
+      ? "load the SSH key into an agent (`ssh-add`)"
+      : "configure a Git credential helper (`git config --global credential.helper <helper>`)";
+  return `${detail}\nPublication does not prompt for credentials: ${remedy}, then re-run \`mate artifact publish\`.`;
 }
 
 function resolvedPath(candidate: string): string {
@@ -107,14 +107,28 @@ function parsePorcelainKind(line: string): WorkingTreeChange {
   return status.includes("?") || status.includes("A") ? "new" : "modified";
 }
 
+/** Read-only index queries, so they may run concurrently; input order is kept. */
+async function filterPaths(
+  paths: string[],
+  keep: (filePath: string) => Promise<boolean>,
+): Promise<string[]> {
+  const kept = await Promise.all(paths.map(keep));
+  return paths.filter((_, index) => kept[index]);
+}
+
 export function defaultGitOps(
   companionPath: string,
   workingRepoPath = process.env.MATE_REPO_PATH,
+  options: GitOpsOptions = {},
 ): GitOps {
   assertSafeCompanionRoot(companionPath, workingRepoPath);
-  const exec = (args: string[]) => gitRun(companionPath, args);
-  const execOrThrow = (args: string[]) => {
-    const res = exec(args);
+  const git = companionGit(companionPath, { prompt: "never", env: options.env });
+  const exec = async (args: readonly string[]) => {
+    const res = await git.run(args);
+    return { status: res.status, out: res.stdout.trimEnd(), err: res.stderr.trim() };
+  };
+  const execOrThrow = async (args: string[]) => {
+    const res = await exec(args);
     if (res.status !== 0) {
       throw new Error(`git ${args.join(" ")} failed: ${res.err || res.out}`);
     }
@@ -122,74 +136,84 @@ export function defaultGitOps(
   };
   return {
     async currentBranch() {
-      const res = exec(["symbolic-ref", "--quiet", "--short", "HEAD"]);
+      const res = await exec(["symbolic-ref", "--quiet", "--short", "HEAD"]);
       return res.status === 0 && res.out.length > 0 ? res.out : null;
     },
     async defaultBranch() {
       // A configured remote HEAD is the only answer the remote itself asserts; the
       // rest are local conventions, narrowing to git's own default last.
-      const remoteHead = exec(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]);
+      const remoteHead = await exec([
+        "symbolic-ref",
+        "--quiet",
+        "--short",
+        "refs/remotes/origin/HEAD",
+      ]);
       if (remoteHead.status === 0 && remoteHead.out.length > 0) {
         return remoteHead.out.replace(/^origin\//, "");
       }
-      const configured = exec(["config", "--get", "init.defaultBranch"]);
+      const configured = await exec(["config", "--get", "init.defaultBranch"]);
       if (configured.status === 0 && configured.out.length > 0) return configured.out;
       return "main";
     },
     async changedPaths() {
-      const out = exec(["status", "--porcelain"]).out;
+      const out = (await exec(["status", "--porcelain"])).out;
       if (out.length === 0) return [];
       return out.split("\n").map(parsePorcelainPath);
     },
     async changedPathKinds() {
-      const out = exec(["status", "--porcelain"]).out;
+      const out = (await exec(["status", "--porcelain"])).out;
       if (out.length === 0) return {};
       return Object.fromEntries(
         out.split("\n").map((line) => [parsePorcelainPath(line), parsePorcelainKind(line)]),
       );
     },
     async stagedPaths() {
-      const out = exec(["diff", "--cached", "--name-only"]).out;
+      const out = (await exec(["diff", "--cached", "--name-only"])).out;
       return out.length === 0 ? [] : out.split("\n");
     },
     async add(paths) {
-      const applicable = paths.filter(
-        (filePath) =>
-          exec(["ls-files", "--cached", "--others", "--exclude-standard", "--", filePath]).out
-            .length > 0,
+      const applicable = await filterPaths(
+        paths,
+        async (filePath) =>
+          (await exec(["ls-files", "--cached", "--others", "--exclude-standard", "--", filePath]))
+            .out.length > 0,
       );
       if (applicable.length > 0) {
-        execOrThrow(["add", "--", ...applicable]);
+        await execOrThrow(["add", "--", ...applicable]);
       }
     },
     async hasStagedChanges(paths) {
       // `diff --cached --quiet` exits 1 when there ARE staged changes.
       const pathspec = paths && paths.length > 0 ? ["--", ...paths] : [];
-      return exec(["diff", "--cached", "--quiet", ...pathspec]).status !== 0;
+      return (await exec(["diff", "--cached", "--quiet", ...pathspec])).status !== 0;
     },
     async commit(message, paths) {
       // A produced path can be unknown to git entirely — e.g. an active change dir that
       // was never committed and has just been moved into the archive. `git commit` rejects
       // such pathspecs ("did not match any file(s) known to git"), so keep only paths that
       // exist in the index or in HEAD (staged deletions match HEAD, new files the index).
-      const known = (paths ?? []).filter(
-        (filePath) =>
-          exec(["ls-files", "--cached", "--", filePath]).out.length > 0 ||
-          exec(["ls-tree", "--name-only", "HEAD", "--", filePath]).out.length > 0,
+      const known = await filterPaths(
+        paths ?? [],
+        async (filePath) =>
+          (await exec(["ls-files", "--cached", "--", filePath])).out.length > 0 ||
+          (await exec(["ls-tree", "--name-only", "HEAD", "--", filePath])).out.length > 0,
       );
       const pathspec = known.length > 0 ? ["--", ...known] : [];
       if (paths && paths.length > 0 && known.length === 0) return;
-      execOrThrow(["commit", "-m", message, ...pathspec]);
+      await execOrThrow(["commit", "-m", message, ...pathspec]);
     },
     async hasUpstream() {
-      return exec(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"]).status === 0;
+      return (
+        (await exec(["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"])).status === 0
+      );
     },
     async fetch() {
-      execOrThrow(["fetch"]);
+      const res = await git.fetch();
+      if (res.status !== 0) throw new Error(`git fetch failed: ${remoteFailureDetail(res)}`);
     },
     async rebaseOntoUpstream() {
-      const res = exec(["rebase", "--autostash", "@{u}"]);
-      const conflicts = exec(["diff", "--name-only", "--diff-filter=U"]);
+      const res = await exec(["rebase", "--autostash", "@{u}"]);
+      const conflicts = await exec(["diff", "--name-only", "--diff-filter=U"]);
       if (res.status === 0 && conflicts.out.length === 0) {
         return { ok: true, conflictedPaths: [] };
       }
@@ -199,14 +223,14 @@ export function defaultGitOps(
       };
     },
     async tagExists(name) {
-      return exec(["tag", "--list", name]).out.length > 0;
+      return (await exec(["tag", "--list", name])).out.length > 0;
     },
     async tag(name, message) {
-      execOrThrow(["tag", "-a", name, "-m", message]);
+      await execOrThrow(["tag", "-a", name, "-m", message]);
     },
     async push() {
-      const res = exec(["push", "--follow-tags"]);
-      return { ok: res.status === 0, error: res.err || res.out };
+      const res = await git.push(["--follow-tags"]);
+      return { ok: res.status === 0, error: res.status === 0 ? "" : remoteFailureDetail(res) };
     },
   };
 }

package/src/cli/commands/companion/hub.ts

@@ -58,7 +58,7 @@ async function runHubInit(argv: string[]): Promise<void> {
 async function runHubAdd(argv: string[]): Promise<void> {
   const sourceArg =
     positionalArgs(argv)[0] ?? flagValue(argv, "url") ?? flagValue(argv, "companion");
-  const source = discoverHubSource(sourceArg ?? (await selectRegisteredCompanion()));
+  const source = await discoverHubSource(sourceArg ?? (await selectRegisteredCompanion()));
   const ref = flagValue(argv, "ref");
   if (ref && source.kind === "git") source.ref = ref;
   const member = await addHubMember(process.cwd(), source, {