@toon-protocol/rig 1.0.0 → 2.0.1

package/dist/cli/rig.js

@@ -10,15 +10,16 @@ import {
   serializePushPlan,
   serializePushResult
 } from "../chunk-LFGDLD6J.js";
+import {
+  MissingIdentityError,
+  resolveIdentity
+} from "../chunk-CW4HJNMU.js";
 import {
   buildComment,
   buildIssue,
   buildPatch,
   buildStatus
 } from "../chunk-HPSOQP7Q.js";
-import {
-  DEFAULT_DAEMON_PORT
-} from "../chunk-D3HGS44Y.js";
 import {
   MAX_OBJECT_SIZE
 } from "../chunk-X2CZPPDM.js";
@@ -26,9 +27,12 @@ import {
 // src/cli/rig.ts
 import { createInterface } from "readline/promises";
 
+// src/cli/dispatch.ts
+import { createRequire } from "module";
+
 // src/cli/events.ts
 import { readFile } from "fs/promises";
-import { parseArgs as parseArgs2 } from "util";
+import { parseArgs as parseArgs3 } from "util";
 import {
   REPOSITORY_ANNOUNCEMENT_KIND,
   STATUS_APPLIED_KIND,
@@ -37,179 +41,66 @@ import {
   STATUS_OPEN_KIND
 } from "@toon-protocol/core/nip34";
 
-// src/cli/daemon.ts
-var DaemonRouteError = class extends Error {
-  constructor(status, envelope) {
-    super(envelope.detail ?? envelope.error);
-    this.status = status;
-    this.envelope = envelope;
-    this.name = "DaemonRouteError";
+// src/cli/errors.ts
+var UnconfiguredRepoAddressError = class extends Error {
+  constructor(missing) {
+    super(
+      `no ${missing} configured \u2014 this command addresses the repo as 30617:<ownerPubkey>:<repoId>. Run \`rig init\` once inside the repo (it writes toon.repoid/toon.owner to the local git config), or pass ${missing === "repository id" ? "--repo-id <id>" : "--owner <pubkey>"} explicitly (use --owner for repos you don't own).`
+    );
+    this.missing = missing;
+    this.name = "UnconfiguredRepoAddressError";
   }
-  status;
-  envelope;
+  missing;
 };
-var DaemonUnreachableError = class extends Error {
-  constructor(baseUrl, cause) {
+var InvalidRelayUrlError = class extends Error {
+  constructor(url, context) {
     super(
-      `toon-clientd control API is not reachable at ${baseUrl} \u2014 start the daemon (\`toon-clientd\`, shipped by @toon-protocol/client-mcp) and re-run, or use --standalone with TOON_CLIENT_MNEMONIC set` + (cause instanceof Error ? ` (${cause.message})` : "")
+      `${context}: ${JSON.stringify(url)} is not a relay URL \u2014 relays are ws://, wss://, http://, or https://`
     );
-    this.baseUrl = baseUrl;
-    this.name = "DaemonUnreachableError";
+    this.url = url;
+    this.name = "InvalidRelayUrlError";
   }
-  baseUrl;
+  url;
 };
-var DaemonGitClient = class {
-  constructor(baseUrl, fetchImpl) {
-    this.baseUrl = baseUrl;
-    this.fetchImpl = fetchImpl;
-  }
-  baseUrl;
-  fetchImpl;
-  gitEstimate(req) {
-    return this.post("/git/estimate", req);
-  }
-  gitPush(req) {
-    return this.post("/git/push", req);
-  }
-  gitIssue(req) {
-    return this.post("/git/issue", req);
-  }
-  gitComment(req) {
-    return this.post("/git/comment", req);
-  }
-  gitPatch(req) {
-    return this.post("/git/patch", req);
-  }
-  gitStatus(req) {
-    return this.post("/git/status", req);
-  }
-  async post(path, body) {
-    let res;
-    try {
-      res = await this.fetchImpl(`${this.baseUrl}${path}`, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(body)
-      });
-    } catch (err) {
-      throw new DaemonUnreachableError(this.baseUrl, err);
-    }
-    const text = await res.text();
-    let parsed;
-    try {
-      parsed = text === "" ? {} : JSON.parse(text);
-    } catch {
-      throw new DaemonRouteError(res.status, {
-        error: "invalid_response",
-        detail: `daemon returned non-JSON (HTTP ${res.status}): ${text.slice(0, 200)}`
-      });
-    }
-    if (!res.ok) {
-      const envelope = parsed && typeof parsed === "object" && "error" in parsed ? parsed : { error: "http_error", detail: `HTTP ${res.status}` };
-      throw new DaemonRouteError(res.status, envelope);
-    }
-    return parsed;
+var UnknownRemoteError = class extends Error {
+  constructor(remote) {
+    super(
+      `no remote named ${JSON.stringify(remote)} is configured \u2014 \`rig remote list\` shows configured remotes; add it with \`rig remote add ${remote} <relay-url>\``
+    );
+    this.remote = remote;
+    this.name = "UnknownRemoteError";
   }
+  remote;
 };
-
-// src/cli/mode.ts
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function daemonBaseUrl(env) {
-  const raw = env["TOON_CLIENT_HTTP_PORT"];
-  const parsed = raw ? Number(raw) : NaN;
-  const port = Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_DAEMON_PORT;
-  return `http://127.0.0.1:${port}`;
-}
-async function probeDaemon(env, fetchImpl, timeoutMs = 1500) {
-  const baseUrl = daemonBaseUrl(env);
-  try {
-    const res = await fetchImpl(`${baseUrl}/status`, {
-      signal: AbortSignal.timeout(timeoutMs)
-    });
-    if (!res.ok) return { baseUrl, reachable: false };
-    const body = await res.json();
-    const probe = { baseUrl, reachable: true };
-    const pubkey = body?.identity?.nostrPubkey;
-    if (typeof pubkey === "string" && pubkey !== "") probe.identity = pubkey;
-    if (typeof body?.ready === "boolean") probe.ready = body.ready;
-    if (typeof body?.relay?.url === "string" && body.relay.url !== "") {
-      probe.relayUrl = body.relay.url;
-    }
-    if (typeof body?.feePerEvent === "string" && body.feePerEvent !== "") {
-      probe.feePerEvent = body.feePerEvent;
-    }
-    return probe;
-  } catch {
-    return { baseUrl, reachable: false };
-  }
-}
-function clientConfigPath(env) {
-  const dir = env["TOON_CLIENT_HOME"] ?? join(homedir(), ".toon-client");
-  return join(dir, "config.json");
-}
-function standaloneAvailability(env) {
-  const configPath = clientConfigPath(env);
-  if (env["TOON_CLIENT_MNEMONIC"]) {
-    return { available: true, source: "env", configPath };
-  }
-  if (existsSync(configPath)) {
-    try {
-      const file = JSON.parse(readFileSync(configPath, "utf8"));
-      if (typeof file.mnemonic === "string" && file.mnemonic !== "" || typeof file.keystorePath === "string" && file.keystorePath !== "") {
-        return { available: true, source: "config", configPath };
-      }
-    } catch {
-    }
-  }
-  return { available: false, configPath };
-}
-var NoPublisherError = class extends Error {
-  constructor(probe, standalone) {
+var MultiUrlRemoteError = class extends Error {
+  constructor(remote, urls) {
     super(
-      `no way to pay for this push \u2014 neither publisher mode is available:
-  \u2022 daemon: no toon-clientd control API at ${probe.baseUrl}/status \u2014 start it (\`toon-clientd\`, shipped by @toon-protocol/client-mcp) and re-run, or pass --daemon once it is up
-  \u2022 standalone: no identity found \u2014 set TOON_CLIENT_MNEMONIC (BIP-39 seed phrase) or configure ${standalone.configPath} (mnemonic / keystorePath), then re-run (or pass --standalone)`
+      `remote ${JSON.stringify(remote)} has ${urls.length} URLs (${urls.join(", ")}) \u2014 rig supports one relay URL per remote. Fix it with \`git remote set-url ${remote} <relay-url>\`. Nothing was uploaded, published, or paid.`
     );
-    this.name = "NoPublisherError";
+    this.remote = remote;
+    this.urls = urls;
+    this.name = "MultiUrlRemoteError";
   }
+  remote;
+  urls;
 };
-async function selectMode(options) {
-  const { env, fetchImpl } = options;
-  if (options.daemon && options.standalone) {
-    throw new Error("--daemon and --standalone are mutually exclusive");
-  }
-  if (options.standalone) {
-    return {
-      mode: "standalone",
-      probe: { baseUrl: daemonBaseUrl(env), reachable: false }
-    };
+var NoOriginConfiguredError = class extends Error {
+  constructor(nonRelayOriginUrl) {
+    super(
+      "no origin configured \u2014 run `rig remote add origin <relay-url>` (or pass --relay <url> for a one-off publish)." + (nonRelayOriginUrl !== void 0 ? `
+The existing "origin" remote (${nonRelayOriginUrl}) is not a relay URL, so rig ignores it \u2014 add the relay under another name (\`rig remote add toon <relay-url>\`) and target it explicitly (\`rig push toon\` / \`--remote toon\`).` : "")
+    );
+    this.name = "NoOriginConfiguredError";
   }
-  const probe = await probeDaemon(env, fetchImpl);
-  if (options.daemon) return { mode: "daemon", probe };
-  if (probe.reachable && probe.identity) return { mode: "daemon", probe };
-  const standalone = standaloneAvailability(env);
-  if (standalone.available) return { mode: "standalone", probe };
-  throw new NoPublisherError(probe, standalone);
-}
-
-// src/cli/errors.ts
-var FUNDING_REMEDIATION = (command) => [
-  "Remediation:",
-  "  \u2022 fund the settlement wallet: run the toon_fund_wallet MCP tool (devnet faucet), or send gas/tokens to the wallet yourself",
-  "  \u2022 open (or top up) a payment channel: toon_open_channel / toon_channel_deposit",
-  `  \u2022 then re-run rig ${command}`
-];
-var UnconfiguredRepoAddressError = class extends Error {
-  constructor(missing) {
+};
+var NotAGitRepositoryError = class extends Error {
+  constructor(cwd) {
     super(
-      `no ${missing} configured \u2014 this command addresses the repo as 30617:<ownerPubkey>:<repoId>. Run \`rig push\` once inside the repo (it persists toon.repoid/toon.owner/toon.relay to git config), or pass ${missing === "repository id" ? "--repo-id <id>" : "--owner <pubkey>"} explicitly (use --owner for repos you don't own).`
+      `not a git repository: ${cwd}
+rig works inside an existing repo \u2014 create one first with \`git init\` (rig never runs it for you), then re-run.`
     );
-    this.missing = missing;
-    this.name = "UnconfiguredRepoAddressError";
+    this.name = "NotAGitRepositoryError";
   }
-  missing;
 };
 function nonFastForwardLines(refs) {
   return [
@@ -231,49 +122,7 @@ function oversizeLines(objects) {
     "Large-object support is tracked in toon-client#235."
   ];
 }
-function fromDaemonEnvelope(err, command) {
-  const { envelope, status } = err;
-  const json = { ...envelope, status };
-  switch (envelope.error) {
-    case "non_fast_forward": {
-      const refs = Array.isArray(envelope["refs"]) ? envelope["refs"] : [];
-      return { code: "non_fast_forward", lines: nonFastForwardLines(refs), json };
-    }
-    case "oversize_objects": {
-      const objects = Array.isArray(envelope["objects"]) ? envelope["objects"] : [];
-      return { code: "oversize_objects", lines: oversizeLines(objects), json };
-    }
-    case "bootstrapping":
-      return {
-        code: "bootstrapping",
-        lines: [
-          `toon-clientd is still bootstrapping: ${envelope.detail ?? "transport/channel coming up"}`,
-          "Retry in a few seconds. If it never becomes ready, check the toon-clientd logs."
-        ],
-        json
-      };
-    case "insufficient_gas":
-      return {
-        code: "insufficient_gas",
-        lines: [
-          `Payment failed: ${envelope.detail ?? "the settlement wallet cannot fund the channel"}`,
-          ...FUNDING_REMEDIATION(command)
-        ],
-        json
-      };
-    default:
-      return {
-        code: envelope.error,
-        lines: [
-          `rig ${command} failed (${envelope.error}, HTTP ${status})` + (envelope.detail ? `: ${envelope.detail}` : ""),
-          ...envelope.retryable ? ["This error is retryable \u2014 try again shortly."] : []
-        ],
-        json
-      };
-  }
-}
 function describeError(err, command = "push") {
-  if (err instanceof DaemonRouteError) return fromDaemonEnvelope(err, command);
   if (err instanceof UnconfiguredRepoAddressError) {
     return {
       code: "unconfigured_repo_address",
@@ -281,18 +130,51 @@ function describeError(err, command = "push") {
       json: { error: "unconfigured_repo_address", detail: err.message }
     };
   }
-  if (err instanceof DaemonUnreachableError) {
+  if (err instanceof NotAGitRepositoryError) {
+    return {
+      code: "not_a_git_repository",
+      lines: err.message.split("\n"),
+      json: { error: "not_a_git_repository", detail: err.message }
+    };
+  }
+  if (err instanceof InvalidRelayUrlError) {
     return {
-      code: "daemon_unreachable",
-      lines: [err.message],
-      json: { error: "daemon_unreachable", detail: err.message }
+      code: "invalid_relay_url",
+      lines: err.message.split("\n"),
+      json: { error: "invalid_relay_url", detail: err.message, url: err.url }
+    };
+  }
+  if (err instanceof UnknownRemoteError) {
+    return {
+      code: "unknown_remote",
+      lines: err.message.split("\n"),
+      json: { error: "unknown_remote", detail: err.message, remote: err.remote }
+    };
+  }
+  if (err instanceof MultiUrlRemoteError) {
+    return {
+      code: "multi_url_remote",
+      lines: err.message.split("\n"),
+      json: {
+        error: "multi_url_remote",
+        detail: err.message,
+        remote: err.remote,
+        urls: err.urls
+      }
     };
   }
-  if (err instanceof NoPublisherError) {
+  if (err instanceof NoOriginConfiguredError) {
     return {
-      code: "no_publisher",
+      code: "no_origin_configured",
       lines: err.message.split("\n"),
-      json: { error: "no_publisher", detail: err.message }
+      json: { error: "no_origin_configured", detail: err.message }
+    };
+  }
+  if (err instanceof MissingIdentityError) {
+    return {
+      code: "missing_identity",
+      lines: err.message.split("\n"),
+      json: { error: "missing_identity", detail: err.message }
     };
   }
   if (err instanceof NonFastForwardError) {
@@ -325,15 +207,18 @@ function describeError(err, command = "push") {
   if (name === "DaemonIdentityConflictError") {
     return {
       code: "daemon_identity_conflict",
-      lines: [message, "Re-run without --standalone (or with --daemon) to push through the running daemon."],
+      lines: [
+        message,
+        "Stop the toon-clientd daemon (or publish through its toon_git_* MCP tools) and re-run."
+      ],
       json: { error: "daemon_identity_conflict", detail: message }
     };
   }
-  if (name === "MissingMnemonicError" || name === "MissingUplinkError") {
+  if (name === "MissingUplinkError") {
     return {
-      code: name === "MissingMnemonicError" ? "missing_mnemonic" : "missing_uplink",
+      code: "missing_uplink",
       lines: [message],
-      json: { error: "standalone_unavailable", detail: message }
+      json: { error: "missing_uplink", detail: message }
     };
   }
   return {
@@ -397,6 +282,29 @@ async function readToonConfig(repoPath) {
   if (owner.exitCode === 0 && own) config.owner = own;
   return config;
 }
+async function getGitRemoteUrls(repoPath, name) {
+  const { stdout } = await git(
+    repoPath,
+    ["config", "--get-all", `remote.${name}.url`],
+    [1]
+  );
+  return stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+async function listGitRemotes(repoPath) {
+  const { stdout } = await git(repoPath, ["remote"]);
+  const names = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+  const remotes = [];
+  for (const name of names) {
+    remotes.push({ name, urls: await getGitRemoteUrls(repoPath, name) });
+  }
+  return remotes;
+}
+async function addGitRemote(repoPath, name, url) {
+  await git(repoPath, ["remote", "add", name, url]);
+}
+async function removeGitRemote(repoPath, name) {
+  await git(repoPath, ["remote", "remove", name]);
+}
 async function writeToonConfig(repoPath, config) {
   if (config.repoId !== void 0) {
     await git(repoPath, ["config", "toon.repoid", config.repoId]);
@@ -413,8 +321,7 @@ async function writeToonConfig(repoPath, config) {
 }
 
 // src/cli/push.ts
-import { basename } from "path";
-import { parseArgs } from "util";
+import { parseArgs as parseArgs2 } from "util";
 
 // src/cli/render.ts
 function formatNumber(value) {
@@ -427,10 +334,13 @@ function refLine(update) {
   const arrow = `${shortSha(update.remoteSha)} \u2192 ${shortSha(update.localSha)}`;
   return `  ${update.refname}  ${arrow}  (${update.kind})`;
 }
-function renderPlan(plan, mode) {
+function renderIdentityLine(identity) {
+  return `Identity: ${identity.pubkey} (from ${identity.sourceLabel})`;
+}
+function renderPlan(plan) {
   const lines = [];
   lines.push(
-    `Push plan for repo "${plan.repoId}" (${mode} mode)` + (plan.announceNeeded ? " \u2014 first push, will announce (kind:30617)" : "")
+    `Push plan for repo "${plan.repoId}"` + (plan.announceNeeded ? " \u2014 first push, will announce (kind:30617)" : "")
   );
   lines.push("Refs:");
   for (const update of plan.refUpdates) lines.push(refLine(update));
@@ -453,8 +363,9 @@ function feeLabel(fee) {
 }
 function renderEventPlan(opts) {
   return [
-    `Publish ${opts.action} (${opts.mode} mode)`,
+    `Publish ${opts.action}`,
     `Repo: 30617:${opts.addr.ownerPubkey}:${opts.addr.repoId}`,
+    renderIdentityLine(opts.identity),
     `Fee: ${feeLabel(opts.fee)}. Writes are permanent and non-refundable.`
   ];
 }
@@ -496,18 +407,248 @@ function renderResult(result) {
   return lines;
 }
 
+// src/cli/remote.ts
+import { parseArgs } from "util";
+var RELAY_PROTOCOLS = /* @__PURE__ */ new Set(["ws:", "wss:", "http:", "https:"]);
+function isRelayUrl(url) {
+  try {
+    return RELAY_PROTOCOLS.has(new URL(url).protocol);
+  } catch {
+    return false;
+  }
+}
+function assertRelayUrl(url, context) {
+  if (!isRelayUrl(url)) throw new InvalidRelayUrlError(url, context);
+}
+async function resolveRelays(opts) {
+  if (opts.relayFlags.length > 0) {
+    return { relays: opts.relayFlags, source: "relay-flag" };
+  }
+  if (opts.remoteName !== void 0) {
+    const urls = opts.repoRoot !== void 0 ? await getGitRemoteUrls(opts.repoRoot, opts.remoteName) : [];
+    if (urls.length === 0) throw new UnknownRemoteError(opts.remoteName);
+    if (urls.length > 1) throw new MultiUrlRemoteError(opts.remoteName, urls);
+    const url = urls[0];
+    assertRelayUrl(url, `remote ${JSON.stringify(opts.remoteName)}`);
+    return { relays: urls, source: "remote", remoteName: opts.remoteName };
+  }
+  let nonRelayOriginUrl;
+  if (opts.repoRoot !== void 0) {
+    const urls = await getGitRemoteUrls(opts.repoRoot, "origin");
+    if (urls.length === 1 && isRelayUrl(urls[0])) {
+      return { relays: urls, source: "remote", remoteName: "origin" };
+    }
+    if (urls.length > 1 && urls.some(isRelayUrl)) {
+      throw new MultiUrlRemoteError("origin", urls);
+    }
+    if (urls.length > 0) nonRelayOriginUrl = urls[0];
+  }
+  if (opts.toonRelays.length > 0) {
+    return {
+      relays: opts.toonRelays,
+      source: "toon.relay",
+      nudge: `note: git config toon.relay is deprecated (removed in v0.3) \u2014 migrate: rig remote add origin ${opts.toonRelays[0]}`
+    };
+  }
+  throw new NoOriginConfiguredError(nonRelayOriginUrl);
+}
+function singleRelayRefusal(resolved, nothingHappened) {
+  const fix = resolved.source === "relay-flag" ? "pass exactly one --relay <url>" : "trim git config toon.relay to one URL (better: migrate \u2014 `rig remote add origin <relay-url>`)";
+  return `rig publishes to a single relay, but ${resolved.relays.length} are configured (${resolved.relays.join(", ")}) \u2014 ${fix}. ${nothingHappened}`;
+}
+var REMOTE_USAGE = `Usage: rig remote <add|remove|list> [args] [options]
+
+Manage the relays this repo publishes to. Remotes are stored as REAL git
+remotes (\`git remote -v\` shows them; plain git tooling round-trips). Paid
+commands publish via the "origin" remote by default; \`rig push <remote>\`
+and \`--remote <name>\` target another one. Free \u2014 nothing is published or
+paid.
+
+Commands:
+  add <name> <relay-url>   add a remote pointing at a relay (the URL must be
+                           ws://, wss://, http://, or https://)
+  remove <name>            remove a remote
+  list                     list remote names + URLs (the default subcommand)
+
+Options:
+  --json                   machine-readable output (list)
+  -h, --help               show this help`;
+async function runRemote(args, deps) {
+  const { io } = deps;
+  let sub;
+  let rest;
+  let json;
+  try {
+    const { values, positionals } = parseArgs({
+      args,
+      options: {
+        json: { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false }
+      },
+      allowPositionals: true
+    });
+    if (values.help) {
+      io.out(REMOTE_USAGE);
+      return 0;
+    }
+    json = values.json ?? false;
+    [sub, ...rest] = positionals;
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(REMOTE_USAGE);
+    return 2;
+  }
+  switch (sub) {
+    case void 0:
+    case "list":
+      if (rest.length > 0) {
+        io.err(`rig remote list takes no arguments (got ${rest.join(" ")})`);
+        io.err(REMOTE_USAGE);
+        return 2;
+      }
+      break;
+    case "add": {
+      if (rest.length !== 2) {
+        io.err("usage: rig remote add <name> <relay-url>");
+        io.err(REMOTE_USAGE);
+        return 2;
+      }
+      const url = rest[1];
+      if (!isRelayUrl(url)) {
+        io.err(
+          `cannot add remote: ${JSON.stringify(url)} is not a relay URL \u2014 relays are ws://, wss://, http://, or https://`
+        );
+        return 2;
+      }
+      break;
+    }
+    case "remove":
+      if (rest.length !== 1) {
+        io.err("usage: rig remote remove <name>");
+        io.err(REMOTE_USAGE);
+        return 2;
+      }
+      break;
+    default:
+      io.err(`unknown rig remote subcommand: ${sub}`);
+      io.err(REMOTE_USAGE);
+      return 2;
+  }
+  try {
+    let repoRoot;
+    try {
+      repoRoot = await resolveRepoRoot(deps.cwd);
+    } catch {
+      throw new NotAGitRepositoryError(deps.cwd);
+    }
+    switch (sub) {
+      case void 0:
+      case "list": {
+        const remotes = await listGitRemotes(repoRoot);
+        if (json) {
+          io.out(JSON.stringify({ command: "remote", remotes }, null, 2));
+          return 0;
+        }
+        if (remotes.length === 0) {
+          io.out(
+            "no remotes configured \u2014 add one: rig remote add origin <relay-url>"
+          );
+          return 0;
+        }
+        for (const remote of remotes) {
+          for (const url of remote.urls) {
+            io.out(
+              `${remote.name}	${url}` + (isRelayUrl(url) ? "" : "	(not a relay URL \u2014 ignored by rig)")
+            );
+          }
+          if (remote.urls.length > 1) {
+            io.err(
+              `warning: remote "${remote.name}" has ${remote.urls.length} URLs \u2014 rig supports one relay URL per remote (fix with \`git remote set-url ${remote.name} <relay-url>\`)`
+            );
+          }
+        }
+        return 0;
+      }
+      case "add": {
+        const [name, url] = rest;
+        const existing = await getGitRemoteUrls(repoRoot, name);
+        if (existing.length > 0) {
+          io.err(
+            `remote ${JSON.stringify(name)} already exists (${existing.join(", ")}) \u2014 nothing changed. Point it somewhere else with \`git remote set-url ${name} <relay-url>\`, or \`rig remote remove ${name}\` first.`
+          );
+          return 1;
+        }
+        await addGitRemote(repoRoot, name, url);
+        io.out(`Added remote ${name} \u2192 ${url}`);
+        if (name === "origin") {
+          io.out(
+            "`rig push` and the event commands now publish here by default."
+          );
+          const toonConfig = await readToonConfig(repoRoot);
+          if (toonConfig.relays.length > 0) {
+            io.err(
+              `note: git config toon.relay (${toonConfig.relays.join(", ")}) is deprecated and now shadowed by the origin remote \u2014 drop it with \`git config --unset-all toon.relay\` (the key is removed in v0.3).`
+            );
+          }
+        }
+        return 0;
+      }
+      case "remove": {
+        const name = rest[0];
+        const existing = await getGitRemoteUrls(repoRoot, name);
+        if (existing.length === 0) {
+          io.err(
+            `no remote named ${JSON.stringify(name)} \u2014 \`rig remote list\` shows configured remotes.`
+          );
+          return 1;
+        }
+        await removeGitRemote(repoRoot, name);
+        io.out(`Removed remote ${name}`);
+        return 0;
+      }
+      /* v8 ignore next 2 -- unreachable: validated above */
+      default:
+        return 2;
+    }
+  } catch (err) {
+    const described = describeError(err, "remote");
+    if (json) {
+      io.out(JSON.stringify({ command: "remote", ...described.json }, null, 2));
+    } else {
+      for (const line of described.lines) io.err(line);
+    }
+    return 1;
+  }
+}
+
 // src/cli/push.ts
-var defaultLoadStandalone = async (env) => {
-  const mod = await import("../standalone-mode-IK2RXILS.js");
-  return mod.createStandaloneContext(env);
+var defaultLoadStandalone = async (options) => {
+  const mod = await import("../standalone-mode-Q3FFZUXE.js");
+  return mod.createStandaloneContext(options);
 };
-var PUSH_USAGE = `Usage: rig push [refspecs...] [options]
+function identityReport(ctx) {
+  return {
+    pubkey: ctx.ownerPubkey,
+    source: ctx.identitySource,
+    sourceLabel: ctx.identitySourceLabel
+  };
+}
+var PUSH_USAGE = `Usage: rig push [remote] [refspecs...] [options]
 
 Push local git refs to TOON: uploads the object delta to Arweave (paid) and
 publishes the NIP-34 refs event (kind:30618; kind:30617 announce on first
 push). Writes are permanent and non-refundable.
 
-Refspecs are branch/tag names or full refnames; default is the current branch.
+The repo must be set up once with \`rig init\` (writes toon.repoid/toon.owner
+to the local git config); the identity comes from RIG_MNEMONIC (env or a
+project .env), or the ~/.toon-client keystore/config.
+
+The relay is a git remote: \`rig push\` publishes via "origin" (set up with
+\`rig remote add origin <relay-url>\`); \`rig push <remote> [refspecs...]\`
+publishes via a named remote. When the first positional matches a configured
+remote name it is the remote; otherwise it is a refspec and the remote
+defaults to origin. Refspecs are branch/tag names or full refnames; default
+is the current branch.
 
 Options:
   --force            allow non-fast-forward ref updates (overwrites remote history)
@@ -516,13 +657,12 @@ Options:
   --yes              skip the fee confirmation (required when not a TTY)
   --json             machine-readable plan/receipts; without --yes it is a pure
                      estimate (nothing executed)
-  --relay <url>      relay URL (repeatable in daemon mode; standalone mode
-                     supports exactly one; default: git config toon.relay,
-                     then the mode's default relay)
+  --relay <url>      ad-hoc relay override (exactly one) \u2014 bypasses the
+                     configured remotes; every positional is then a refspec.
+                     The deprecated v0.1 \`git config toon.relay\` still works
+                     as a fallback, with a migration nudge
   --repo-id <id>     repository id / NIP-34 d-tag (default: git config
-                     toon.repoid, then the repo directory name)
-  --daemon           force daemon mode (toon-clientd control API)
-  --standalone       force standalone mode (embedded client from TOON_CLIENT_MNEMONIC)
+                     toon.repoid \u2014 run \`rig init\` to set it)
   -h, --help         show this help`;
 async function selectRefspecs(reader, positionals, all, tags) {
   const { head, refs } = await reader.listRefs();
@@ -565,7 +705,7 @@ async function selectRefspecs(reader, positionals, all, tags) {
   return selected;
 }
 function parsePushArgs(args) {
-  const { values, positionals } = parseArgs({
+  const { values, positionals } = parseArgs2({
     args,
     options: {
       force: { type: "boolean", default: false },
@@ -573,8 +713,6 @@ function parsePushArgs(args) {
       tags: { type: "boolean", default: false },
       yes: { type: "boolean", default: false },
       json: { type: "boolean", default: false },
-      daemon: { type: "boolean", default: false },
-      standalone: { type: "boolean", default: false },
       relay: { type: "string", multiple: true },
       "repo-id": { type: "string" },
       help: { type: "boolean", short: "h", default: false }
@@ -587,8 +725,6 @@ function parsePushArgs(args) {
     tags: values.tags ?? false,
     yes: values.yes ?? false,
     json: values.json ?? false,
-    daemon: values.daemon ?? false,
-    standalone: values.standalone ?? false,
     relay: values.relay ?? [],
     help: values.help ?? false,
     positionals
@@ -598,7 +734,7 @@ function parsePushArgs(args) {
   return flags;
 }
 async function runPush(args, deps) {
-  const { io, env, fetchImpl } = deps;
+  const { io, env } = deps;
   let flags;
   try {
     flags = parsePushArgs(args);
@@ -612,91 +748,98 @@ async function runPush(args, deps) {
     return 0;
   }
   let standaloneCtx;
-  let standalonePlan;
   try {
     const repoRoot = await resolveRepoRoot(deps.cwd);
     const toonConfig = await readToonConfig(repoRoot);
-    const repoId = flags.repoId ?? toonConfig.repoId ?? basename(repoRoot);
+    const repoId = flags.repoId ?? toonConfig.repoId;
+    if (!repoId) throw new UnconfiguredRepoAddressError("repository id");
     const reader = new GitRepoReader(repoRoot);
+    let remoteName;
+    let refspecArgs = flags.positionals;
+    if (flags.relay.length === 0 && refspecArgs.length > 0) {
+      const first = refspecArgs[0];
+      const remoteNames = new Set(
+        (await listGitRemotes(repoRoot)).map((r) => r.name)
+      );
+      if (remoteNames.has(first)) {
+        remoteName = first;
+        refspecArgs = refspecArgs.slice(1);
+      } else {
+        const { refs } = await reader.listRefs();
+        const known = new Set(refs.map((r) => r.refname));
+        if (!known.has(first) && !known.has(`refs/heads/${first}`) && !known.has(`refs/tags/${first}`)) {
+          throw new Error(
+            `${JSON.stringify(first)} is neither a configured remote nor a local branch/tag \u2014 add the relay remote (\`rig remote add ${first} <relay-url>\`; \`rig remote list\` shows configured remotes) or fix the refspec`
+          );
+        }
+      }
+    }
     const refspecs = await selectRefspecs(
       reader,
-      flags.positionals,
+      refspecArgs,
       flags.all,
       flags.tags
     );
-    const explicitRelays = flags.relay.length > 0 ? flags.relay : toonConfig.relays.length > 0 ? toonConfig.relays : void 0;
-    const { mode, probe } = await selectMode({
-      daemon: flags.daemon,
-      standalone: flags.standalone,
-      env,
-      fetchImpl
+    const resolved = await resolveRelays({
+      relayFlags: flags.relay,
+      remoteName,
+      repoRoot,
+      toonRelays: toonConfig.relays
     });
-    let plan;
-    let identity;
-    let relaysUsed = explicitRelays;
-    const daemonClient = new DaemonGitClient(probe.baseUrl, fetchImpl);
-    const daemonRequest = {
-      repoPath: repoRoot,
-      repoId,
-      refspecs,
-      force: flags.force,
-      ...explicitRelays ? { relayUrls: explicitRelays } : {}
-    };
-    if (mode === "daemon") {
-      identity = probe.identity;
-      relaysUsed ??= probe.relayUrl ? [probe.relayUrl] : void 0;
-      plan = await daemonClient.gitEstimate(daemonRequest);
-    } else {
-      standaloneCtx = await (deps.loadStandalone ?? defaultLoadStandalone)(env);
-      identity = standaloneCtx.ownerPubkey;
-      relaysUsed ??= standaloneCtx.defaultRelayUrls;
-      if (relaysUsed && relaysUsed.length > 1) {
-        io.err(
-          `standalone mode publishes to a single relay, but ${relaysUsed.length} are configured (${relaysUsed.join(", ")}) \u2014 re-run with exactly one --relay <url> (or trim git config toon.relay). Nothing was uploaded or paid.`
-        );
-        return 1;
-      }
-      const remoteState = await standaloneCtx.fetchRemote({
-        ownerPubkey: standaloneCtx.ownerPubkey,
-        repoId,
-        relayUrls: relaysUsed
-      });
-      const feeRates = await standaloneCtx.publisher.getFeeRates();
-      const pushPlan = await planPush({
-        repoReader: reader,
-        remoteState,
-        feeRates,
-        repoId,
-        refs: refspecs,
-        force: flags.force
-      });
-      plan = serializePushPlan(pushPlan);
-      standalonePlan = { pushPlan, remoteState, reader, relaysUsed };
+    if (resolved.nudge !== void 0) io.err(resolved.nudge);
+    const relaysUsed = resolved.relays;
+    if (relaysUsed.length > 1) {
+      io.err(singleRelayRefusal(resolved, "Nothing was uploaded or paid."));
+      return 1;
     }
-    if (toonConfig.owner && identity && toonConfig.owner !== identity) {
+    standaloneCtx = await (deps.loadStandalone ?? defaultLoadStandalone)({
+      env,
+      cwd: deps.cwd,
+      warn: (line) => io.err(line)
+    });
+    const identity = identityReport(standaloneCtx);
+    if (toonConfig.owner && toonConfig.owner !== identity.pubkey) {
       io.err(
-        `warning: git config toon.owner (${toonConfig.owner.slice(0, 8)}\u2026) differs from the active ${mode} identity (${identity.slice(0, 8)}\u2026) \u2014 this push publishes under the ACTIVE identity's repo namespace, not the configured owner's`
+        `warning: git config toon.owner (${toonConfig.owner.slice(0, 8)}\u2026) differs from the active identity (${identity.pubkey.slice(0, 8)}\u2026) \u2014 this push publishes under the ACTIVE identity's repo namespace, not the configured owner's. Re-run \`rig init\` to adopt the active identity.`
       );
     }
+    const remoteState = await standaloneCtx.fetchRemote({
+      ownerPubkey: standaloneCtx.ownerPubkey,
+      repoId,
+      relayUrls: relaysUsed
+    });
+    const feeRates = await standaloneCtx.publisher.getFeeRates();
+    const pushPlan = await planPush({
+      repoReader: reader,
+      remoteState,
+      feeRates,
+      repoId,
+      refs: refspecs,
+      force: flags.force
+    });
+    const plan = serializePushPlan(pushPlan);
     const upToDate = plan.refUpdates.every((u) => u.kind === "up-to-date");
     if (upToDate) {
       if (flags.json) {
-        io.out(jsonOut({ command: "push", mode, repoId, executed: false, upToDate: true, plan }));
+        io.out(
+          jsonOut({ command: "push", repoId, identity, executed: false, upToDate: true, plan })
+        );
       } else {
         io.out("Everything up-to-date \u2014 nothing to push (and nothing paid).");
       }
       return 0;
     }
     if (!flags.json) {
-      for (const line of renderPlan(plan, mode)) io.out(line);
+      for (const line of renderPlan(plan)) io.out(line);
+      io.out(renderIdentityLine(identity));
     }
     if (!flags.yes) {
       if (flags.json) {
         io.out(
           jsonOut({
             command: "push",
-            mode,
             repoId,
+            identity,
             executed: false,
             upToDate: false,
             plan,
@@ -719,41 +862,21 @@ async function runPush(args, deps) {
         return 1;
       }
     }
-    let result;
-    if (mode === "daemon") {
-      result = await daemonClient.gitPush({ ...daemonRequest, confirm: true });
-    } else {
-      const cached = standalonePlan;
-      if (!cached || !standaloneCtx) {
-        throw new Error("internal: standalone plan cache missing");
-      }
-      const pushResult = await executePush({
-        plan: cached.pushPlan,
-        publisher: standaloneCtx.publisher,
-        remoteState: cached.remoteState,
-        repoReader: cached.reader,
-        relayUrls: cached.relaysUsed
-      });
-      result = serializePushResult(cached.pushPlan, pushResult);
-    }
+    const pushResult = await executePush({
+      plan: pushPlan,
+      publisher: standaloneCtx.publisher,
+      remoteState,
+      repoReader: reader,
+      relayUrls: relaysUsed
+    });
+    const result = serializePushResult(pushPlan, pushResult);
     if (flags.json) {
       io.out(
-        jsonOut({ command: "push", mode, repoId, executed: true, upToDate: false, plan, result })
+        jsonOut({ command: "push", repoId, identity, executed: true, upToDate: false, plan, result })
       );
     } else {
       for (const line of renderResult(result)) io.out(line);
     }
-    try {
-      await writeToonConfig(repoRoot, {
-        repoId,
-        ...identity ? { owner: identity } : {},
-        ...relaysUsed ? { relays: relaysUsed } : {}
-      });
-    } catch (err) {
-      io.err(
-        `warning: push succeeded but persisting git config failed: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
     return 0;
   } catch (err) {
     const described = describeError(err);
@@ -783,23 +906,24 @@ var defaultReadStdin = async () => {
   for await (const chunk of process.stdin) chunks.push(chunk);
   return Buffer.concat(chunks).toString("utf-8");
 };
-var COMMON_FLAGS_USAGE = `  --repo-id <id>       repository id / NIP-34 d-tag (default: git config toon.repoid)
+var COMMON_FLAGS_USAGE = `  --repo-id <id>       repository id / NIP-34 d-tag (default: git config
+                       toon.repoid \u2014 run \`rig init\` to set it)
   --owner <pubkey>     repository owner pubkey, 64-char hex (default: git config
-                       toon.owner, then the active publisher identity)
-  --relay <url>        relay to publish to in standalone mode (default: git config
-                       toon.relay, then the mode's default; standalone supports
-                       exactly one relay \u2014 daemon mode publishes via its apex)
+                       toon.owner, then the active identity)
+  --remote <name>      publish via this configured git remote (default: the
+                       "origin" remote \u2014 \`rig remote add origin <relay-url>\`)
+  --relay <url>        ad-hoc relay override (exactly one) \u2014 bypasses the
+                       configured remotes. The deprecated v0.1 \`git config
+                       toon.relay\` still works as a fallback, with a nudge
   --yes                skip the fee confirmation (required when not a TTY)
   --json               machine-readable receipt; without --yes it is a pure
                        estimate (nothing published, exit 0)
-  --daemon             force daemon mode (toon-clientd control API)
-  --standalone         force standalone mode (embedded client from TOON_CLIENT_MNEMONIC)
   -h, --help           show this help`;
 var ISSUE_USAGE = `Usage: rig issue create --title <title> [options]
 
 File an issue (kind:1621) against a TOON repo \u2014 a paid publish; writes are
 permanent and non-refundable. The repo address (30617:<owner>:<repoId>) comes
-from the toon.* git config keys \`rig push\` persists.
+from the toon.* git config keys \`rig init\` writes.
 
 Body source (exactly one): --body, --body-file, or piped stdin.
 
@@ -822,7 +946,7 @@ Options:
   --marker <root|reply>    e-tag marker (default: root \u2014 commenting directly
                            on the issue/patch)
 ${COMMON_FLAGS_USAGE}`;
-var PR_USAGE = `Usage: rig pr create --title <title> (--range <range> | --patch-file <path>) [options]
+var PR_CREATE_USAGE = `Usage: rig pr create --title <title> (--range <range> | --patch-file <path>) [options]
 
 Publish a patch (kind:1617) whose content is REAL \`git format-patch\` output \u2014
 a paid publish; writes are permanent and non-refundable. --range runs
@@ -839,16 +963,20 @@ Options:
   --patch-file <path>  literal patch text to publish
   --branch <name>      branch name (t tag)
 ${COMMON_FLAGS_USAGE}`;
-var STATUS_USAGE = `Usage: rig status <target-event-id> <open|applied|closed|draft> [options]
+var PR_STATUS_USAGE = `Usage: rig pr status <target-event-id> <open|applied|closed|draft> [options]
 
 Set the status of an issue or patch \u2014 a paid publish; writes are permanent
 and non-refundable. Publishes kind:1630 (open), 1631 (applied), 1632
 (closed), or 1633 (draft) against the 64-char hex id of the target event,
 with the repo a-tag attached so readers can scope a status stream to the
-repository.
+repository. (This command was \`rig status\` before v2 \u2014 bare \`rig status\`
+now passes through to \`git status\`.)
 
 Options:
 ${COMMON_FLAGS_USAGE}`;
+var PR_USAGE = `${PR_CREATE_USAGE}
+
+${PR_STATUS_USAGE}`;
 var HEX64_RE = /^[0-9a-f]{64}$/;
 function assertHex64(value, what) {
   if (!HEX64_RE.test(value)) {
@@ -860,9 +988,8 @@ function assertHex64(value, what) {
 var COMMON_OPTIONS = {
   yes: { type: "boolean", default: false },
   json: { type: "boolean", default: false },
-  daemon: { type: "boolean", default: false },
-  standalone: { type: "boolean", default: false },
   relay: { type: "string", multiple: true },
+  remote: { type: "string" },
   "repo-id": { type: "string" },
   owner: { type: "string" },
   help: { type: "boolean", short: "h", default: false }
@@ -871,11 +998,11 @@ function pickCommon(values) {
   const flags = {
     yes: values["yes"] === true,
     json: values["json"] === true,
-    daemon: values["daemon"] === true,
-    standalone: values["standalone"] === true,
     relay: Array.isArray(values["relay"]) ? values["relay"] : [],
     help: values["help"] === true
   };
+  const remote = values["remote"];
+  if (typeof remote === "string") flags.remote = remote;
   const repoId = values["repo-id"];
   if (typeof repoId === "string") flags.repoId = repoId;
   const owner = values["owner"];
@@ -887,54 +1014,43 @@ function pickCommon(values) {
 }
 async function runEvent(opts) {
   const { command, flags, deps, actionLabel } = opts;
-  const { io, env, fetchImpl } = deps;
+  const { io, env } = deps;
   let standaloneCtx;
   try {
+    let repoRoot;
     let toonConfig = { relays: [] };
     try {
-      toonConfig = await readToonConfig(await resolveRepoRoot(deps.cwd));
+      repoRoot = await resolveRepoRoot(deps.cwd);
+      toonConfig = await readToonConfig(repoRoot);
     } catch {
     }
     const repoId = flags.repoId ?? toonConfig.repoId;
     if (!repoId) throw new UnconfiguredRepoAddressError("repository id");
-    const explicitRelays = flags.relay.length > 0 ? flags.relay : toonConfig.relays.length > 0 ? toonConfig.relays : void 0;
-    const { mode, probe } = await selectMode({
-      daemon: flags.daemon,
-      standalone: flags.standalone,
-      env,
-      fetchImpl
+    const resolved = await resolveRelays({
+      relayFlags: flags.relay,
+      remoteName: flags.remote,
+      repoRoot,
+      toonRelays: toonConfig.relays
     });
-    const daemonClient = new DaemonGitClient(probe.baseUrl, fetchImpl);
-    let identity;
-    let fee;
-    let relaysUsed = explicitRelays;
-    if (mode === "daemon") {
-      identity = probe.identity;
-      fee = probe.feePerEvent;
-    } else {
-      standaloneCtx = await (deps.loadStandalone ?? defaultLoadStandalone)(env);
-      identity = standaloneCtx.ownerPubkey;
-      relaysUsed ??= standaloneCtx.defaultRelayUrls;
-      if (relaysUsed.length > 1) {
-        io.err(
-          `standalone mode publishes to a single relay, but ${relaysUsed.length} are configured (${relaysUsed.join(", ")}) \u2014 re-run with exactly one --relay <url> (or trim git config toon.relay). Nothing was published or paid.`
-        );
-        return 1;
-      }
-      fee = (await standaloneCtx.publisher.getFeeRates()).eventFee.toString();
+    if (resolved.nudge !== void 0) io.err(resolved.nudge);
+    const relaysUsed = resolved.relays;
+    if (relaysUsed.length > 1) {
+      io.err(singleRelayRefusal(resolved, "Nothing was published or paid."));
+      return 1;
     }
-    const owner = flags.owner ?? toonConfig.owner ?? identity;
-    if (!owner) throw new UnconfiguredRepoAddressError("repository owner");
+    standaloneCtx = await (deps.loadStandalone ?? defaultLoadStandalone)({
+      env,
+      cwd: deps.cwd,
+      warn: (line) => io.err(line)
+    });
+    const identity = identityReport(standaloneCtx);
+    const fee = (await standaloneCtx.publisher.getFeeRates()).eventFee.toString();
+    const owner = flags.owner ?? toonConfig.owner ?? identity.pubkey;
     const addr = { ownerPubkey: owner, repoId };
     const event = await opts.buildEvent(addr);
     const action = `kind:${event.kind} ${actionLabel}`;
     if (!flags.json) {
-      for (const line of renderEventPlan({
-        action,
-        addr,
-        mode,
-        ...fee !== void 0 ? { fee } : {}
-      })) {
+      for (const line of renderEventPlan({ action, addr, identity, fee })) {
         io.out(line);
       }
     }
@@ -943,11 +1059,11 @@ async function runEvent(opts) {
         io.out(
           jsonOut2({
             command,
-            mode,
             repoAddr: addr,
+            identity,
             kind: event.kind,
             executed: false,
-            feeEstimate: fee ?? null,
+            feeEstimate: fee,
             hint: "estimate only \u2014 re-run with --yes to publish (permanent, non-refundable)"
           })
         );
@@ -967,26 +1083,17 @@ async function runEvent(opts) {
         return 1;
       }
     }
-    let result;
-    if (mode === "daemon") {
-      result = await opts.sendDaemon(daemonClient, addr);
-    } else {
-      if (!standaloneCtx) throw new Error("internal: standalone context missing");
-      const receipt = await standaloneCtx.publisher.publishEvent(
-        event,
-        relaysUsed ?? []
-      );
-      result = serializeEventReceipt(event.kind, receipt);
-    }
+    const receipt = await standaloneCtx.publisher.publishEvent(event, relaysUsed);
+    const result = serializeEventReceipt(event.kind, receipt);
     if (flags.json) {
       io.out(
         jsonOut2({
           command,
-          mode,
           repoAddr: addr,
+          identity,
           kind: result.kind,
           executed: true,
-          feeEstimate: fee ?? null,
+          feeEstimate: fee,
           result
         })
       );
@@ -1034,7 +1141,7 @@ async function runIssue(args, deps) {
   let bodyFile;
   let labels;
   try {
-    const { values } = parseArgs2({
+    const { values } = parseArgs3({
       args: rest,
       options: {
         ...COMMON_OPTIONS,
@@ -1093,13 +1200,7 @@ async function runIssue(args, deps) {
     flags,
     deps,
     actionLabel: `issue ${JSON.stringify(title)}`,
-    buildEvent: async (addr) => buildIssue(addr.ownerPubkey, addr.repoId, title, body, labels),
-    sendDaemon: (client, addr) => client.gitIssue({
-      repoAddr: addr,
-      title,
-      body,
-      ...labels.length > 0 ? { labels } : {}
-    })
+    buildEvent: async (addr) => buildIssue(addr.ownerPubkey, addr.repoId, title, body, labels)
   });
 }
 async function runComment(args, deps) {
@@ -1110,7 +1211,7 @@ async function runComment(args, deps) {
   let parentAuthor;
   let marker;
   try {
-    const { values, positionals } = parseArgs2({
+    const { values, positionals } = parseArgs3({
       args,
       options: {
         ...COMMON_OPTIONS,
@@ -1160,14 +1261,7 @@ async function runComment(args, deps) {
       parentAuthor ?? addr.ownerPubkey,
       body,
       marker
-    ),
-    sendDaemon: (client, addr) => client.gitComment({
-      repoAddr: addr,
-      rootEventId,
-      body,
-      marker,
-      ...parentAuthor !== void 0 ? { parentAuthorPubkey: parentAuthor } : {}
-    })
+    )
   });
 }
 var PATCH_FROM_RE = /^From ([0-9a-f]{40}) /gm;
@@ -1177,24 +1271,33 @@ function extractPatchShas(patchText) {
 async function runPr(args, deps) {
   const { io } = deps;
   const [sub, ...rest] = args;
-  if (sub === "--help" || sub === "-h" || sub === "help") {
-    io.out(PR_USAGE);
-    return 0;
-  }
-  if (sub !== "create") {
-    io.err(
-      sub === void 0 ? "missing subcommand: rig pr create" : `unknown rig pr subcommand: ${sub}`
-    );
-    io.err(PR_USAGE);
-    return 2;
+  switch (sub) {
+    case "create":
+      return runPrCreate(rest, deps);
+    case "status":
+      return runPrStatus(rest, deps);
+    case "--help":
+    case "-h":
+    case "help":
+      io.out(PR_USAGE);
+      return 0;
+    default:
+      io.err(
+        sub === void 0 ? "missing subcommand: rig pr <create|status>" : `unknown rig pr subcommand: ${sub}`
+      );
+      io.err(PR_USAGE);
+      return 2;
   }
+}
+async function runPrCreate(rest, deps) {
+  const { io } = deps;
   let flags;
   let title;
   let range;
   let patchFile;
   let branch;
   try {
-    const { values } = parseArgs2({
+    const { values } = parseArgs3({
       args: rest,
       options: {
         ...COMMON_OPTIONS,
@@ -1207,7 +1310,7 @@ async function runPr(args, deps) {
     });
     flags = pickCommon(values);
     if (flags.help) {
-      io.out(PR_USAGE);
+      io.out(PR_CREATE_USAGE);
       return 0;
     }
     if (values.title === void 0 || values.title === "") {
@@ -1222,43 +1325,38 @@ async function runPr(args, deps) {
     branch = values.branch;
   } catch (err) {
     io.err(err instanceof Error ? err.message : String(err));
-    io.err(PR_USAGE);
+    io.err(PR_CREATE_USAGE);
     return 2;
   }
-  let prepared;
-  const prepare = async () => {
-    if (prepared) return prepared;
-    if (range !== void 0) {
-      const reader = new GitRepoReader(await resolveRepoRoot(deps.cwd));
-      const patchText = await reader.formatPatch(range);
-      if (patchText === "") {
-        throw new Error(
-          `range ${JSON.stringify(range)} selects no commits \u2014 nothing to publish`
-        );
-      }
-      const shas = extractPatchShas(patchText);
-      const parents = await reader.commitParents(shas);
-      const commits = shas.flatMap((sha) => {
-        const parentSha = parents.get(sha)?.[0];
-        return parentSha ? [{ sha, parentSha }] : [];
-      });
-      prepared = { patchText, commits };
-    } else {
-      const patchText = await readFile(patchFile, "utf-8");
-      if (patchText.trim() === "") {
-        throw new Error(`--patch-file ${patchFile} is empty \u2014 nothing to publish`);
-      }
-      prepared = { patchText, commits: [] };
-    }
-    return prepared;
-  };
   return runEvent({
     command: "pr",
     flags,
     deps,
     actionLabel: `patch ${JSON.stringify(title)}`,
     buildEvent: async (addr) => {
-      const { patchText, commits } = await prepare();
+      let patchText;
+      let commits;
+      if (range !== void 0) {
+        const reader = new GitRepoReader(await resolveRepoRoot(deps.cwd));
+        patchText = await reader.formatPatch(range);
+        if (patchText === "") {
+          throw new Error(
+            `range ${JSON.stringify(range)} selects no commits \u2014 nothing to publish`
+          );
+        }
+        const shas = extractPatchShas(patchText);
+        const parents = await reader.commitParents(shas);
+        commits = shas.flatMap((sha) => {
+          const parentSha = parents.get(sha)?.[0];
+          return parentSha ? [{ sha, parentSha }] : [];
+        });
+      } else {
+        patchText = await readFile(patchFile, "utf-8");
+        if (patchText.trim() === "") {
+          throw new Error(`--patch-file ${patchFile} is empty \u2014 nothing to publish`);
+        }
+        commits = [];
+      }
       return buildPatch(
         addr.ownerPubkey,
         addr.repoId,
@@ -1267,16 +1365,6 @@ async function runPr(args, deps) {
         branch,
         patchText
       );
-    },
-    sendDaemon: async (client, addr) => {
-      const { patchText, commits } = await prepare();
-      return client.gitPatch({
-        repoAddr: addr,
-        title,
-        patchText,
-        ...commits.length > 0 ? { commits } : {},
-        ...branch !== void 0 ? { branch } : {}
-      });
     }
   });
 }
@@ -1289,20 +1377,20 @@ var STATUS_KIND_BY_VALUE = {
 function isStatusValue(value) {
   return Object.hasOwn(STATUS_KIND_BY_VALUE, value);
 }
-async function runStatus(args, deps) {
+async function runPrStatus(args, deps) {
   const { io } = deps;
   let flags;
   let targetEventId;
   let status;
   try {
-    const { values, positionals } = parseArgs2({
+    const { values, positionals } = parseArgs3({
       args,
       options: COMMON_OPTIONS,
       allowPositionals: true
     });
     flags = pickCommon(values);
     if (flags.help) {
-      io.out(STATUS_USAGE);
+      io.out(PR_STATUS_USAGE);
       return 0;
     }
     if (positionals.length !== 2) {
@@ -1321,11 +1409,11 @@ async function runStatus(args, deps) {
     status = rawStatus;
   } catch (err) {
     io.err(err instanceof Error ? err.message : String(err));
-    io.err(STATUS_USAGE);
+    io.err(PR_STATUS_USAGE);
     return 2;
   }
   return runEvent({
-    command: "status",
+    command: "pr status",
     flags,
     deps,
     actionLabel: `status ${status} on ${targetEventId.slice(0, 8)}\u2026`,
@@ -1336,59 +1424,261 @@ async function runStatus(args, deps) {
         `${REPOSITORY_ANNOUNCEMENT_KIND}:${addr.ownerPubkey}:${addr.repoId}`
       ]);
       return event;
+    }
+  });
+}
+
+// src/cli/git-passthrough.ts
+import { spawn } from "child_process";
+import { constants as osConstants } from "os";
+var GIT_NOT_FOUND_EXIT = 127;
+var RELAYED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+function signalExitCode(signal) {
+  const num = osConstants.signals[signal];
+  return num === void 0 ? 1 : 128 + num;
+}
+var runGitPassthrough = (argv, options = {}) => {
+  const err = options.err ?? ((line) => process.stderr.write(`${line}
+`));
+  return new Promise((resolve) => {
+    const child = spawn("git", argv, {
+      stdio: "inherit",
+      ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+      env: options.env ?? process.env
+    });
+    const relay = /* @__PURE__ */ new Map();
+    for (const signal of RELAYED_SIGNALS) {
+      const handler = () => {
+        child.kill(signal);
+      };
+      relay.set(signal, handler);
+      process.on(signal, handler);
+    }
+    const restoreSignals = () => {
+      for (const [signal, handler] of relay) process.removeListener(signal, handler);
+    };
+    child.on("error", (spawnErr) => {
+      restoreSignals();
+      if (spawnErr.code === "ENOENT") {
+        err(
+          `rig: git not found \u2014 \`rig ${argv[0] ?? ""}\` is not a rig command, so it is passed through to the system \`git\`, which is not on your PATH. Install git (https://git-scm.com) or fix your PATH.`
+        );
+        resolve(GIT_NOT_FOUND_EXIT);
+        return;
+      }
+      err(`rig: failed to run git: ${spawnErr.message}`);
+      resolve(1);
+    });
+    child.on("close", (code, signal) => {
+      restoreSignals();
+      resolve(signal !== null ? signalExitCode(signal) : code ?? 1);
+    });
+  });
+};
+
+// src/cli/init.ts
+import { basename } from "path";
+import { parseArgs as parseArgs4 } from "util";
+var INIT_USAGE = `Usage: rig init [options]
+
+Set up the current git repository for rig (one-shot, idempotent, free):
+resolves your identity (RIG_MNEMONIC env \u2192 project .env \u2192 ~/.toon-client
+keystore/config), then writes toon.repoid and toon.owner to the repo's
+LOCAL git config. Re-running updates and reports; it never errors on an
+already-initialized repo. The seed phrase is never written anywhere.
+
+The follow-up step is adding a relay: \`rig remote add origin <relay-url>\`
+(a real git remote \u2014 \`git remote -v\` shows it). A deprecated v0.1
+\`git config toon.relay\` is migrated to the origin remote automatically
+when no origin exists (the old key stays readable and is removed in v0.3).
+
+Options:
+  --repo-id <id>     repository id / NIP-34 d-tag (default: the existing
+                     toon.repoid, then the repo directory basename)
+  --json             machine-readable report
+  -h, --help         show this help`;
+function parseInitArgs(args) {
+  const { values, positionals } = parseArgs4({
+    args,
+    options: {
+      "repo-id": { type: "string" },
+      json: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
     },
-    sendDaemon: (client, addr) => client.gitStatus({ repoAddr: addr, targetEventId, status })
+    allowPositionals: false
   });
+  if (positionals.length > 0) {
+    throw new Error(`rig init takes no positional arguments`);
+  }
+  const flags = {
+    json: values.json ?? false,
+    help: values.help ?? false
+  };
+  const repoId = values["repo-id"];
+  if (repoId !== void 0) {
+    if (repoId.trim() === "") throw new Error("--repo-id must not be empty");
+    flags.repoId = repoId;
+  }
+  return flags;
+}
+async function runInit(args, deps) {
+  const { io, env } = deps;
+  let flags;
+  try {
+    flags = parseInitArgs(args);
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(INIT_USAGE);
+    return 2;
+  }
+  if (flags.help) {
+    io.out(INIT_USAGE);
+    return 0;
+  }
+  try {
+    let repoRoot;
+    try {
+      repoRoot = await resolveRepoRoot(deps.cwd);
+    } catch {
+      throw new NotAGitRepositoryError(deps.cwd);
+    }
+    const identity = await (deps.resolveIdentityImpl ?? resolveIdentity)({
+      env,
+      cwd: deps.cwd,
+      warn: (line) => io.err(line)
+    });
+    const existing = await readToonConfig(repoRoot);
+    const repoId = flags.repoId ?? existing.repoId ?? basename(repoRoot);
+    const changed = {
+      repoId: existing.repoId !== repoId,
+      owner: existing.owner !== identity.pubkey
+    };
+    await writeToonConfig(repoRoot, { repoId, owner: identity.pubkey });
+    let remotes = await listGitRemotes(repoRoot);
+    let migratedToonRelay = false;
+    const legacyRelay = existing.relays[0];
+    if (!remotes.some((r) => r.name === "origin") && existing.relays.length === 1 && legacyRelay !== void 0 && isRelayUrl(legacyRelay)) {
+      await addGitRemote(repoRoot, "origin", legacyRelay);
+      migratedToonRelay = true;
+      remotes = await listGitRemotes(repoRoot);
+    }
+    const origin = remotes.find((r) => r.name === "origin");
+    const originRelay = origin !== void 0 && origin.urls.length === 1 && isRelayUrl(origin.urls[0]) ? origin.urls[0] : void 0;
+    if (flags.json) {
+      const output = {
+        command: "init",
+        repoRoot,
+        repoId,
+        owner: identity.pubkey,
+        identity: {
+          source: identity.source,
+          sourceLabel: identity.sourceLabel,
+          pubkey: identity.pubkey
+        },
+        relays: existing.relays,
+        relayConfigured: originRelay !== void 0 || existing.relays.length > 0,
+        remotes,
+        origin: originRelay ?? null,
+        migratedToonRelay,
+        changed
+      };
+      io.out(JSON.stringify(output, null, 2));
+      return 0;
+    }
+    io.out(`Initialized rig for ${repoRoot}`);
+    io.out(renderIdentityLine(identity));
+    io.out(
+      `  toon.repoid = ${repoId}` + (changed.repoId ? "" : " (unchanged)") + (existing.repoId && changed.repoId ? ` (was ${existing.repoId})` : "")
+    );
+    io.out(
+      `  toon.owner  = ${identity.pubkey}` + (changed.owner ? "" : " (unchanged)") + (existing.owner && changed.owner ? ` (was ${existing.owner})` : "")
+    );
+    if (originRelay !== void 0) {
+      io.out(
+        `  origin      = ${originRelay}` + (migratedToonRelay ? " (migrated from git config toon.relay)" : "")
+      );
+      if (migratedToonRelay) {
+        io.out(
+          "note: toon.relay is deprecated \u2014 it stays readable as a fallback and is removed in v0.3; drop it now with `git config --unset-all toon.relay`."
+        );
+      }
+      io.out('Ready: `rig push` publishes this repo via remote "origin".');
+    } else if (existing.relays.length > 0) {
+      io.out(`  toon.relay  = ${existing.relays.join(", ")} (deprecated)`);
+      io.out(
+        origin !== void 0 ? `The "origin" remote (${origin.urls.join(", ")}) is not a single relay URL, so toon.relay stays the fallback \u2014 add the relay under another name (\`rig remote add toon <relay-url>\`) and push with \`rig push toon\`.` : existing.relays.length > 1 ? `toon.relay has ${existing.relays.length} values and rig publishes to one relay \u2014 migrate the right one: \`rig remote add origin <relay-url>\`.` : "This value is not a relay URL (ws://, wss://, http://, or https://) \u2014 set a real one: `rig remote add origin <relay-url>`."
+      );
+    } else if (origin !== void 0) {
+      io.out(
+        `No relay configured yet \u2014 "origin" (${origin.urls.join(", ")}) is not a relay URL, so add the relay under another name: \`rig remote add toon <relay-url>\`, then \`rig push toon\`.`
+      );
+    } else {
+      io.out(
+        "No relay configured yet \u2014 add one as the follow-up step: `rig remote add origin <relay-url>` (a real git remote; `git remote -v` shows it). One-off pushes can pass --relay <url>."
+      );
+    }
+    return 0;
+  } catch (err) {
+    const described = describeError(err, "init");
+    if (flags.json) {
+      io.out(JSON.stringify({ command: "init", ...described.json }, null, 2));
+    } else {
+      for (const line of described.lines) io.err(line);
+    }
+    return 1;
+  }
 }
 
-// src/cli/rig.ts
-var USAGE = `rig \u2014 push git repos to TOON (pay-to-write Nostr + Arweave)
+// src/cli/dispatch.ts
+var USAGE = `rig \u2014 git with a TOON remote (pay-to-write Nostr + Arweave)
 
 Usage: rig <command> [options]
 
-Commands:
-  push [refspecs...]         plan, price, confirm, and execute a paid push
+Commands rig owns:
+  init                       set up this repo: resolve your identity
+                             (RIG_MNEMONIC) and write the toon.* git config
+  remote add <name> <url>    add a relay as a REAL git remote ("origin" is
+  remote remove <name>       the default publish target); remove/list manage
+  remote list                them \u2014 \`git remote -v\` shows the same data
+  push [remote] [refspecs...]  plan, price, confirm, and execute a paid push
+                             to TOON (defaults to the "origin" remote). rig
+                             push is the TOON transport and shadows git push;
+                             plain-git pushes remain available by running
+                             \`git push\` directly
   issue create               file an issue (kind:1621) against a repo
   comment <root-event-id>    comment (kind:1622) on an issue or patch
   pr create                  publish a patch (kind:1617) with real
                              \`git format-patch\` content
-  status <event-id> <state>  set an issue/patch status (kind:1630-1633):
+  pr status <event-id> <state>  set an issue/patch status (kind:1630-1633):
                              open | applied | closed | draft
 
-Run \`rig <command> --help\` for the command's flags. All writes are paid,
-permanent, and non-refundable; each command quotes its fee and asks for
-confirmation before spending (--yes skips, --json emits machine output).`;
-function makeIo() {
-  return {
-    out: (line) => process.stdout.write(`${line}
-`),
-    err: (line) => process.stderr.write(`${line}
-`),
-    isInteractive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
-    confirm: async (question) => {
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stderr
-      });
-      try {
-        const answer = (await rl.question(question)).trim().toLowerCase();
-        return answer === "y" || answer === "yes";
-      } finally {
-        rl.close();
-      }
+Any other command is passed through to git verbatim: \`rig status\` runs
+\`git status\`, and \`rig add -p\`, \`rig commit\`, \`rig log --oneline\`,
+\`rig rebase -i\`, \u2026 behave exactly like git (same output, same exit code).
+
+Run \`rig <command> --help\` for a rig command's flags. \`rig init\` and
+\`rig remote\` are free; the other rig commands are paid writes \u2014 permanent
+and non-refundable; each quotes its fee and asks for confirmation before
+spending (--yes skips, --json emits machine output).`;
+function rigVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const rel of ["../package.json", "../../package.json", "../../../package.json"]) {
+    try {
+      const pkg = require2(rel);
+      if (pkg.name === "@toon-protocol/rig" && pkg.version) return pkg.version;
+    } catch {
     }
-  };
+  }
+  return "unknown";
 }
-async function main() {
-  const [command, ...rest] = process.argv.slice(2);
-  const io = makeIo();
-  const deps = {
-    io,
-    env: process.env,
-    cwd: process.cwd(),
-    fetchImpl: fetch
-  };
+async function dispatch(argv, deps) {
+  const [command, ...rest] = argv;
+  const { io } = deps;
   switch (command) {
+    case "init":
+      return runInit(rest, deps);
+    case "remote":
+      return runRemote(rest, deps);
     case "push":
       return runPush(rest, deps);
     case "issue":
@@ -1397,8 +1687,6 @@ async function main() {
       return runComment(rest, deps);
     case "pr":
       return runPr(rest, deps);
-    case "status":
-      return runStatus(rest, deps);
     case "help":
     case "--help":
     case "-h":
@@ -1406,16 +1694,48 @@ async function main() {
       io.out("");
       io.out(PUSH_USAGE);
       return 0;
+    case "--version":
+      io.out(`rig ${rigVersion()}`);
+      return 0;
     case void 0:
       io.err(USAGE);
       return 2;
     default:
-      io.err(`unknown command: ${command}`);
-      io.err(USAGE);
-      return 2;
+      return (deps.runGit ?? runGitPassthrough)(argv, {
+        cwd: deps.cwd,
+        env: deps.env,
+        err: (line) => io.err(line)
+      });
   }
 }
-main().then(
+
+// src/cli/rig.ts
+function makeIo() {
+  return {
+    out: (line) => process.stdout.write(`${line}
+`),
+    err: (line) => process.stderr.write(`${line}
+`),
+    isInteractive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    confirm: async (question) => {
+      const rl = createInterface({
+        input: process.stdin,
+        output: process.stderr
+      });
+      try {
+        const answer = (await rl.question(question)).trim().toLowerCase();
+        return answer === "y" || answer === "yes";
+      } finally {
+        rl.close();
+      }
+    }
+  };
+}
+dispatch(process.argv.slice(2), {
+  io: makeIo(),
+  env: process.env,
+  cwd: process.cwd()
+}).then(
   (code) => {
     process.exitCode = code;
   },