@lanes-sh/link 0.1.0

package/src/cli/commands/mcp/assets.ts

@@ -0,0 +1,189 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { installRoot } from '#profile';
+import { print, style } from '../../output.ts';
+import type { Harness } from './harnesses.ts';
+
+/**
+ * The documents this repository ships *to* a client, and how they get there.
+ *
+ * They live under `instructions/` — one root, because they are one thing said
+ * three ways. The MCP server says the short version of it to every client that
+ * connects (`server/mcp/instructions.ts`); these two are the long version, for
+ * the harnesses that can hold a file.
+ *
+ * Deliberately not read by the server. `.dockerignore` keeps `instructions/`
+ * out of the image, so a deployed revision has no copy of either — which is
+ * exactly why the endpoint describes itself from code instead.
+ */
+
+export type AssetKind = 'skill' | 'agent';
+
+export interface BundledAsset {
+  readonly kind: AssetKind;
+  /** Under `instructions/` here. */
+  readonly source: string;
+  /** Under the harness's directory for that kind, once installed. */
+  readonly target: string;
+  readonly label: string;
+}
+
+export const ASSETS: readonly BundledAsset[] = [
+  {
+    kind: 'skill',
+    source: 'skills/lanes-link/SKILL.md',
+    // A directory rather than a flat `lanes-link.md`, so a skill that later
+    // grows a reference or a script has somewhere to put it without moving.
+    target: 'lanes-link/SKILL.md',
+    label: 'skill',
+  },
+  {
+    kind: 'agent',
+    source: 'agents/lanes-link-scout.md',
+    target: 'lanes-link-scout.md',
+    label: 'scout agent',
+  },
+];
+
+/** Where an asset lives in this checkout. */
+export function sourcePath(asset: BundledAsset): string {
+  return join(installRoot(import.meta.dir), 'instructions', asset.source);
+}
+
+export async function readAsset(asset: BundledAsset): Promise<string> {
+  const path = sourcePath(asset);
+
+  if (!existsSync(path)) {
+    throw new Error(
+      `The bundled ${asset.label} is missing from ${path}. ` +
+        `It ships in the repository under instructions/${asset.source}.`,
+    );
+  }
+
+  return readFile(path, 'utf8');
+}
+
+export interface AssetPlan {
+  readonly asset: BundledAsset;
+  readonly path: string;
+}
+
+/**
+ * What this harness would receive, at this scope.
+ *
+ * A harness with no directory for a kind simply contributes nothing for it —
+ * Codex takes the skill and has nowhere to put a subagent, and that is a fact
+ * about Codex rather than a failure to report.
+ */
+export function plannedAssets(harness: Harness, scope: string): AssetPlan[] {
+  const plans: AssetPlan[] = [];
+
+  for (const asset of ASSETS) {
+    const directory = asset.kind === 'skill' ? harness.skills?.(scope) : harness.agents?.(scope);
+    if (directory) plans.push({ asset, path: join(directory, asset.target) });
+  }
+
+  return plans;
+}
+
+export type AssetState = 'installed' | 'updated' | 'unchanged';
+
+/**
+ * Write one asset, reporting what that actually changed.
+ *
+ * Compared before writing rather than written unconditionally, for two reasons
+ * that are both about the second run. It makes re-running honest — "unchanged"
+ * is different information from "updated", and someone re-running after a token
+ * rotation wants to know the document did not move under them. And it keeps the
+ * file's mtime still, which matters because a harness that watches its skills
+ * directory would otherwise reload on every `mcp add`.
+ */
+export async function installAsset(plan: AssetPlan, body: string): Promise<AssetState> {
+  const existing = existsSync(plan.path) ? await readFile(plan.path, 'utf8') : null;
+  if (existing === body) return 'unchanged';
+
+  await mkdir(dirname(plan.path), { recursive: true });
+  await writeFile(plan.path, body);
+
+  return existing === null ? 'installed' : 'updated';
+}
+
+/** Whether what is on disk is what we ship, without writing anything. */
+export async function assetState(
+  plan: AssetPlan,
+  body: string,
+): Promise<'current' | 'stale' | 'missing'> {
+  if (!existsSync(plan.path)) return 'missing';
+  return (await readFile(plan.path, 'utf8')) === body ? 'current' : 'stale';
+}
+
+/**
+ * Install every asset this harness takes, and say what happened to each.
+ *
+ * Errors are reported rather than thrown: a read-only home directory should not
+ * abandon a registration that already succeeded, and the operator can still
+ * install by hand from `lanes link mcp skill`.
+ */
+export async function installFor(
+  harness: Harness,
+  scope: string,
+  options: { dryRun?: boolean | undefined },
+): Promise<void> {
+  for (const plan of plannedAssets(harness, scope)) {
+    if (options.dryRun) {
+      print(style.dim(`      would write ${plan.asset.label} to ${plan.path}`));
+      continue;
+    }
+
+    try {
+      const state = await installAsset(plan, await readAsset(plan.asset));
+      print(
+        style.dim(
+          state === 'unchanged'
+            ? `      ${plan.asset.label} already current at ${plan.path}`
+            : `      ${state} ${plan.asset.label} at ${plan.path}`,
+        ),
+      );
+    } catch (error) {
+      print(style.dim(`      could not install the ${plan.asset.label}: ${message(error)}`));
+    }
+  }
+}
+
+function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * `lanes link mcp skill` — the bundled skill, as a path or as the document.
+ *
+ * Still here after `mcp add` learned to install it, because it is the answer for
+ * every client that has no skills directory to install into: Claude Desktop,
+ * Cowork, and anything else that reads a URL and nothing else. `--print` sends
+ * the document to stdout so it can be piped somewhere this CLI has never heard
+ * of.
+ */
+export async function skillDocument(options: { print?: boolean | undefined }): Promise<void> {
+  const asset = ASSETS.find((candidate) => candidate.kind === 'skill')!;
+  const body = await readAsset(asset);
+
+  if (options.print) {
+    print(body.trimEnd());
+    return;
+  }
+
+  const directory = dirname(sourcePath(asset));
+  print(directory);
+  print('');
+  print(style.dim('Installed for you by "lanes link mcp add". By hand, for Claude Code:'));
+  print(`  cp -r ${directory} ~/.claude/skills/`);
+  print('');
+  print(
+    style.dim(
+      'For a client with nowhere to put a file, "lanes link mcp skill --print" writes the\n' +
+        'document to stdout — though such a client is already told the short version of it\n' +
+        'by the endpoint itself, when it connects.',
+    ),
+  );
+}

package/src/cli/commands/mcp/harnesses.ts

@@ -0,0 +1,143 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * The agent harnesses this CLI knows how to set up, and the two different
+ * things "setting up" means.
+ *
+ * **Registration is delegated.** `add`, `get`, and `remove` are argument lists
+ * for the harness's *own* command, because where Claude Code and Codex keep
+ * their servers, and what belongs in those files, is not ours to define. If
+ * either CLI changes shape, this breaks loudly rather than writing a stale
+ * format.
+ *
+ * **Assets are written.** `skills` and `agents` name directories we put a
+ * document in, because there is no `claude skill add` to delegate to. The line
+ * between the two is the whole of ADR-016: delegate where the harness owns a
+ * command, write the file where it does not. A skill is content in a documented
+ * location, not a config format we would be guessing at, and the directory
+ * written is named after this project.
+ */
+
+export interface AddInput {
+  readonly name: string;
+  readonly url: string;
+  readonly token: string;
+  readonly tokenEnv: string;
+  readonly scope: string;
+}
+
+export interface Harness {
+  readonly id: string;
+  readonly binary: string;
+  readonly label: string;
+  /** Whether `--scope` means anything here. Codex config is global. */
+  readonly scoped: boolean;
+  /**
+   * Whether the token is handed to the harness at all.
+   *
+   * Codex stores the *name* of an environment variable and reads it when it
+   * launches, so the secret never reaches its config file and a rotation is
+   * picked up without re-registering. Claude Code stores the header value.
+   */
+  readonly storesToken: boolean;
+  /**
+   * This harness's configuration directory, honouring its own override.
+   *
+   * Read at call time rather than captured, because a test sets the variable
+   * around the call and a value resolved at import would be the real home.
+   */
+  home(): string;
+  add(input: AddInput): string[];
+  get(name: string): string[];
+  remove(name: string): string[];
+  /** Where user- or project-scope skills go, if this harness reads any. */
+  skills?(scope: string): string;
+  /** Where subagent definitions go. Codex has no equivalent. */
+  agents?(scope: string): string;
+  /** Anything the operator still has to do themselves. */
+  afterAdd?(input: AddInput): string[];
+}
+
+/**
+ * A scoped directory under a harness's home.
+ *
+ * `user` is the home itself; anything else is the project-local `.<harness>`
+ * directory beside the code, which is where both Claude Code scopes that are
+ * not `user` look. Resolved against the current directory deliberately — a
+ * project-scope install belongs to the checkout someone is standing in.
+ */
+function scoped(home: string, dotDirectory: string, scope: string, kind: string): string {
+  return scope === 'user' ? join(home, kind) : join(process.cwd(), dotDirectory, kind);
+}
+
+const CLAUDE_HOME = (): string => process.env['CLAUDE_CONFIG_DIR'] ?? join(homedir(), '.claude');
+const CODEX_HOME = (): string => process.env['CODEX_HOME'] ?? join(homedir(), '.codex');
+
+export const HARNESSES: readonly Harness[] = [
+  {
+    id: 'claude',
+    binary: 'claude',
+    label: 'Claude Code',
+    scoped: true,
+    storesToken: true,
+    home: CLAUDE_HOME,
+    add: ({ name, url, token, scope }) => [
+      'mcp',
+      'add',
+      '--transport',
+      'http',
+      name,
+      url,
+      '--header',
+      `Authorization: Bearer ${token}`,
+      '--scope',
+      scope,
+    ],
+    // No scope on get: it looks across all of them, which is what we want —
+    // a name registered at user scope still collides with a local-scope add.
+    get: (name) => ['mcp', 'get', name],
+    // No scope on remove either: "removes from whichever scope it exists in",
+    // so a user-scope registration cannot survive a local-scope --force.
+    remove: (name) => ['mcp', 'remove', name],
+    skills: (scope) => scoped(CLAUDE_HOME(), '.claude', scope, 'skills'),
+    agents: (scope) => scoped(CLAUDE_HOME(), '.claude', scope, 'agents'),
+  },
+  {
+    id: 'codex',
+    binary: 'codex',
+    label: 'Codex',
+    scoped: false,
+    storesToken: false,
+    home: CODEX_HOME,
+    add: ({ name, url, tokenEnv }) => [
+      'mcp',
+      'add',
+      name,
+      '--url',
+      url,
+      '--bearer-token-env-var',
+      tokenEnv,
+    ],
+    get: (name) => ['mcp', 'get', name],
+    remove: (name) => ['mcp', 'remove', name],
+    // Same layout and the same frontmatter Claude Code reads, so one document
+    // installs to both unchanged. Codex has no subagent directory, so it gets
+    // the skill and not the scout — and `mcp add` says which it did.
+    skills: () => join(CODEX_HOME(), 'skills'),
+    afterAdd: ({ tokenEnv }) => [
+      `Codex reads the token from $${tokenEnv} when it starts, so set it where Codex will see it:`,
+      '',
+      `    export ${tokenEnv}="$(lanes link token show --raw)"`,
+      '',
+      'Add that to your shell profile. This is the better half of the bargain: the token never',
+      'reaches ~/.codex/config.toml, and a "lanes link token rotate" is picked up on next launch',
+      'with no re-registration.',
+    ],
+  },
+];
+
+/** The command shapes, exposed so a test can pin them against each CLI's help. */
+export function harnessCommands(id: string): Harness | undefined {
+  return HARNESSES.find((harness) => harness.id === id);
+}

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

@@ -0,0 +1,70 @@
+import { heading, print, style } from '../../output.ts';
+import { assetState, plannedAssets, readAsset } from './assets.ts';
+import { HARNESSES, type Harness } from './harnesses.ts';
+import { exists } from './register.ts';
+
+/**
+ * `lanes link mcp list` — where this endpoint is registered, and whether what
+ * each harness has been told about it is still what we ship.
+ *
+ * Two columns because there are two ways to be half set up, and they have
+ * different fixes. A registration without the skill is a working endpoint
+ * nobody reaches for; a skill against no registration is a document describing
+ * tools that are not there.
+ */
+export async function mcpList(options: { name?: string | undefined; scope?: string | undefined }): Promise<void> {
+  const name = options.name ?? 'lanes-link';
+  const scope = options.scope ?? 'user';
+
+  heading(`Registered as ${style.bold(name)}`);
+
+  for (const harness of HARNESSES) {
+    const binary = Bun.which(harness.binary);
+
+    if (!binary) {
+      print(`  ${harness.label.padEnd(14)} ${style.dim('not installed')}`);
+      continue;
+    }
+
+    print(
+      `  ${harness.label.padEnd(14)} ${
+        exists(binary, harness, name)
+          ? style.green('registered')
+          : style.dim(`not registered — lanes link mcp add ${harness.id}`)
+      }`,
+    );
+
+    for (const line of await documentLines(harness, scope)) print(`  ${' '.repeat(14)} ${line}`);
+  }
+}
+
+/** One line per document this harness can hold, saying whether it is current. */
+async function documentLines(harness: Harness, scope: string): Promise<string[]> {
+  const lines: string[] = [];
+
+  for (const plan of plannedAssets(harness, scope)) {
+    try {
+      const state = await assetState(plan, await readAsset(plan.asset));
+
+      lines.push(
+        state === 'current'
+          ? style.dim(`${plan.asset.label}: `) + style.green('up to date')
+          : style.dim(
+              state === 'stale'
+                ? `${plan.asset.label}: out of date — lanes link mcp add ${harness.id}`
+                : `${plan.asset.label}: not installed — lanes link mcp add ${harness.id}`,
+            ),
+      );
+    } catch (error) {
+      // A checkout without `instructions/` — a container image, say. Worth one
+      // line rather than a thrown error that hides the registration column.
+      lines.push(style.dim(`${plan.asset.label}: ${message(error)}`));
+    }
+  }
+
+  return lines;
+}
+
+function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/src/cli/commands/mcp/register.ts

@@ -0,0 +1,199 @@
+import { endpointUrl } from '../../endpoint-url.ts';
+import { fail, ok, print, style, warn } from '../../output.ts';
+import { ensureProfileToken, openRuntime, type GlobalFlags } from '../../runtime.ts';
+import { installFor } from './assets.ts';
+import { HARNESSES, type AddInput, type Harness } from './harnesses.ts';
+
+/**
+ * `lanes link mcp add [harness]` — register this endpoint with an agent, and
+ * give that agent the document that says what it is for.
+ *
+ * The registration half does **not** write to any agent's config file. It runs
+ * the harness's own supported command, which keeps the registration format the
+ * harness's business. If either CLI changes, this breaks loudly rather than
+ * writing a stale format.
+ *
+ * The install half does write a file, because no harness has a command for it
+ * (ADR-016). Those are different risks: a registration we spelled wrong is a
+ * config file we corrupted, and a skill we spelled wrong is a Markdown document
+ * in a directory named after us.
+ *
+ * The manual command from `lanes link outputs` remains the canonical path. This
+ * exists because typing it correctly turns out to be error-prone: an em-dash
+ * from a paste, or a `lanes` not on PATH substituting to an empty token,
+ * both produce a 401 that reads as a bad credential.
+ */
+
+export interface McpAddOptions extends GlobalFlags {
+  readonly name?: string | undefined;
+  readonly scope?: string | undefined;
+  readonly tokenEnv?: string | undefined;
+  readonly dryRun?: boolean | undefined;
+  readonly force?: boolean | undefined;
+  /** Register only; leave the skill and the agent alone. */
+  readonly noSkill?: boolean | undefined;
+}
+
+export async function mcpAdd(target: string | undefined, options: McpAddOptions): Promise<void> {
+  // No harness named: every one that is actually installed. Registering with
+  // whatever is present is what someone means by "add my mcp", and naming one
+  // stays available for the case where it is not.
+  const chosen = target
+    ? HARNESSES.filter((harness) => harness.id === target)
+    : HARNESSES.filter((harness) => Bun.which(harness.binary));
+
+  if (target && chosen.length === 0) {
+    throw new Error(
+      `Unknown harness "${target}". Known: ${HARNESSES.map((h) => h.id).join(', ')}.\n` +
+        '  For anything else, "lanes link outputs" prints the URL and token to register by hand.',
+    );
+  }
+
+  if (chosen.length === 0) {
+    throw new Error(
+      `None of ${HARNESSES.map((h) => h.binary).join(', ')} is on your PATH, so there is nothing to run.\n` +
+        '  Run "lanes link outputs" and register by hand instead.',
+    );
+  }
+
+  const name = options.name ?? 'lanes-link';
+  // User scope, not project scope.
+  //
+  // This registers a gateway to someone's *accounts* — their mail, calendar,
+  // files. Claude Code's `local` scope binds a server to one directory, so a
+  // project-scoped registration means your inbox is reachable from
+  // ~/dev/thing and not from ~/dev/other, which nobody expects and nothing
+  // about the endpoint suggests. `local` is right for a repository's own
+  // tooling; it is wrong for this.
+  const scope = options.scope ?? 'user';
+  const tokenEnv = options.tokenEnv ?? 'LANES_LINK_TOKEN';
+
+  const runtime = await openRuntime(options);
+
+  try {
+    const { token } = await ensureProfileToken(runtime.credentials, runtime.config.auth.token_ref);
+
+    // The target's own address, not the local one. This built
+    // `http://<host>:<port>/mcp` unconditionally, so `mcp add --target cloud`
+    // registered loopback with the agent: a registration that reports success,
+    // names the right server, and points at a port with nothing behind it.
+    const url = await endpointUrl(runtime.config, runtime.target);
+    const input: AddInput = { name, url, token, tokenEnv, scope };
+
+    // Registering an endpoint that is down is legitimate — the harness stores
+    // the address and connects on demand — but it is usually a mistake worth
+    // mentioning, since the first symptom is a failed tool call much later.
+    if (!(await reachable(url))) {
+      const start = url.startsWith('http://127.') || url.startsWith('http://localhost')
+        ? 'run "lanes link start" before using it'
+        : 'the deployed service is not answering — check "lanes link outputs"';
+      print(warn(`nothing is answering on ${url} — ${start}`));
+    }
+
+    for (const harness of chosen) await register(harness, input, options);
+  } finally {
+    await runtime.close();
+  }
+}
+
+async function register(
+  harness: Harness,
+  input: AddInput,
+  options: McpAddOptions,
+): Promise<void> {
+  const binary = Bun.which(harness.binary);
+  if (!binary) {
+    print(fail(`${harness.label} ("${harness.binary}") is not on your PATH`));
+    return;
+  }
+
+  const args = harness.add(input);
+
+  if (options.dryRun) {
+    // The token is redacted here and only here: a dry run exists precisely so
+    // someone can read the command before it carries a live credential.
+    print(`  ${harness.binary} ${redactToken(args).map(quote).join(' ')}`);
+    if (!options.noSkill) await installFor(harness, input.scope, { dryRun: true });
+    return;
+  }
+
+  if (exists(binary, harness, input.name)) {
+    if (!options.force) {
+      print(warn(`${harness.label}: "${input.name}" is already registered`));
+      print(style.dim('    --force replaces it, e.g. after "lanes link token rotate"'));
+      // The documents are still refreshed. Someone re-running this after an
+      // upgrade wants the current skill, and refusing to update it because the
+      // registration was already right is the opposite of what they asked for.
+      if (!options.noSkill) await installFor(harness, input.scope, {});
+      return;
+    }
+    // Remove then add: both CLIs refuse a duplicate name rather than updating,
+    // and a stale token is the usual reason anyone is here.
+    Bun.spawnSync([binary, ...harness.remove(input.name)], { stdout: 'ignore', stderr: 'ignore' });
+  }
+
+  const result = Bun.spawnSync([binary, ...args], { stdout: 'pipe', stderr: 'pipe' });
+
+  if (!result.success) {
+    print(fail(`${harness.label}: ${harness.binary} exited ${result.exitCode}`));
+    const stderr = new TextDecoder().decode(result.stderr).trim();
+    if (stderr) print(style.dim(`    ${stderr}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  print(
+    ok(
+      `registered ${style.bold(input.name)} with ${harness.label}` +
+        (harness.scoped ? ` (${input.scope} scope)` : ''),
+    ),
+  );
+  print(`      ${input.url}`);
+
+  if (!options.noSkill) await installFor(harness, input.scope, {});
+
+  if (harness.storesToken) {
+    print(
+      style.dim(
+        '      The token was stored as a value, not a command, so "lanes link token rotate"\n' +
+          '      means running this again with --force.',
+      ),
+    );
+  }
+
+  const after = harness.afterAdd?.(input);
+  if (after) {
+    print('');
+    for (const line of after) print(line ? `      ${line}` : '');
+  }
+}
+
+/** Whether the harness already knows this name, so we replace rather than fail. */
+export function exists(binary: string, harness: Harness, name: string): boolean {
+  return Bun.spawnSync([binary, ...harness.get(name)], {
+    stdout: 'ignore',
+    stderr: 'ignore',
+  }).success;
+}
+
+async function reachable(url: string): Promise<boolean> {
+  try {
+    const health = new URL(url);
+    health.pathname = '/health';
+    return (await fetch(health, { signal: AbortSignal.timeout(700) })).ok;
+  } catch {
+    return false;
+  }
+}
+
+/** Quote an argument a shell would otherwise split, so a dry run is pasteable. */
+function quote(argument: string): string {
+  return /[\s"'$`\\]/.test(argument) ? `"${argument.replace(/(["$`\\])/g, '\\$1')}"` : argument;
+}
+
+/** Replace the bearer value, so a dry run can be pasted into a bug report. */
+function redactToken(args: readonly string[]): string[] {
+  return args.map((argument) =>
+    argument.startsWith('Authorization: Bearer ') ? 'Authorization: Bearer <token>' : argument,
+  );
+}

package/src/cli/commands/mcp/stdio.ts

@@ -0,0 +1,57 @@
+import { printErr } from '../../output.ts';
+import type { GlobalFlags } from '../../runtime.ts';
+import { startStdioEndpoint } from '#server/endpoint.ts';
+
+/**
+ * `lanes link mcp stdio` — serve this workspace on stdin and stdout.
+ *
+ * Not a command anyone types. It is what a client's config file names, so the
+ * client spawns it: Claude Desktop validates each `mcpServers` entry against
+ * `{ command, args?, env?, extensionId? }` and has no `url` field, so an HTTP
+ * endpoint is not something it can be pointed at.
+ *
+ * Such a client also has nowhere to install a skill, which is the case the
+ * server's own `instructions` exist for — it arrives over this pipe like any
+ * other, in the `initialize` response.
+ *
+ * Nothing may be written to stdout here — it is the wire. Reconcile output and
+ * errors go to stderr, where a client's log captures them.
+ */
+export async function mcpStdio(
+  flags: GlobalFlags & { only?: boolean | undefined },
+): Promise<void> {
+  const endpoint = await startStdioEndpoint({
+    flags,
+    ...(flags.only ? { only: true } : {}),
+    reporter: {
+      reconciled: ({ profile, plan, ofMany }) =>
+        printErr(`${ofMany ? `${profile}\n` : ''}${plan}`),
+      // Unreachable: this path never mints a token, because it never needs one.
+      tokenMinted: () => {},
+    },
+    log: {
+      debug() {},
+      info() {},
+      warn: (message, fields) => printErr(`warn  ${message} ${JSON.stringify(fields ?? {})}`),
+      error: (message, fields) => printErr(`error ${message} ${JSON.stringify(fields ?? {})}`),
+    },
+  });
+
+  const stop = async (code: number): Promise<never> => {
+    await endpoint.stop();
+    process.exit(code);
+  };
+
+  process.on('SIGINT', () => void stop(0));
+  process.on('SIGTERM', () => void stop(0));
+
+  // The client owns the lifetime: it spawned this process, and closing the pipe
+  // is how it says it is done. Without this the process outlives the client that
+  // started it, holding a database handle open for nobody.
+  await new Promise<void>((resolve) => {
+    process.stdin.once('end', resolve);
+    process.stdin.once('close', resolve);
+  });
+
+  await endpoint.stop();
+}

package/src/cli/commands/mcp.ts

@@ -0,0 +1,22 @@
+/**
+ * Setting an agent up to use this endpoint.
+ *
+ * A barrel beside the directory, matching `operate.ts` and `owner.ts` and for
+ * the same reason: `main.ts` binds `./mcp.ts`, and Bun does not resolve that to
+ * `mcp/index.ts`.
+ *
+ * Five files, because "set up an agent" turned out to be two jobs with
+ * different rules (ADR-016):
+ *
+ *   harnesses  which agents we know, and what each will accept
+ *   register   running the harness's own registration command
+ *   assets     writing the documents no harness has a command for
+ *   list       what is set up, and what has drifted
+ *   stdio      serving the client that spawns us instead of connecting
+ */
+
+export { skillDocument } from './mcp/assets.ts';
+export { harnessCommands } from './mcp/harnesses.ts';
+export { mcpList } from './mcp/list.ts';
+export { mcpAdd, type McpAddOptions } from './mcp/register.ts';
+export { mcpStdio } from './mcp/stdio.ts';