@toon-protocol/rig 4.5.0 → 4.7.0

package/dist/{chunk-UZZ2JKEC.js → chunk-J6Y3U645.js}

@@ -10,11 +10,15 @@ import {
   UnconfiguredRepoAddressError,
   UnknownRemoteError,
   addGitRemote,
+  amendRepoAnnouncement,
   buildCiManualTrigger,
   buildCiSecretUpdate,
   buildCiServiceRequest,
   buildCiServiceStop,
   collectRepoObjects,
+  conformanceEdits,
+  diffAnnouncementTags,
+  earliestUniqueCommit,
   emitCliError,
   encryptSecretUpdate,
   executePush,
@@ -48,22 +52,29 @@ import {
   updateRef,
   writeGitObjects,
   writeToonConfig
-} from "./chunk-S2BMLXAD.js";
+} from "./chunk-3IVO2MSZ.js";
+import {
+  PREFERRED_GATEWAY,
+  mirrorGatewaysFor,
+  readGateways,
+  shaResolverFor
+} from "./chunk-XQ2AWNHQ.js";
 import {
-  ARWEAVE_GATEWAYS,
   COMMENT_KIND,
   DEFAULT_KEYSTORE_PASSWORD,
+  LEGACY_COMMENT_KIND,
   MissingIdentityError,
   authorizedStatusAuthors,
   buildComment,
   buildIssue,
   buildPatch,
-  buildRepoAnnouncement,
   buildStatus,
   clientConfigPath,
   clientKeystorePath,
+  commentBelongsToThread,
   defaultWebSocketFactory,
   fetchRemoteState,
+  firstTagValue,
   isValidEvmPayoutAddress,
   linkKeystoreInClientConfig,
   parseMaintainers,
@@ -71,7 +82,7 @@ import {
   readClientConfigFile,
   resolveAccountIndex,
   resolveIdentity
-} from "./chunk-HMED76GU.js";
+} from "./chunk-S3KKQ4IC.js";
 import {
   ChannelMapStore,
   channelStatus,
@@ -84,22 +95,13 @@ import {
   uploadChargeFor
 } from "./chunk-U5A7MHBP.js";
 
-// src/gateway-preference.ts
-var TESTNET_GATEWAY = /(^|\.)ar-io\.dev$/i;
-function isMainnetGateway(url) {
-  try {
-    return !TESTNET_GATEWAY.test(new URL(url).hostname);
-  } catch {
-    return false;
-  }
-}
-var PREFERRED_GATEWAY = ARWEAVE_GATEWAYS.find(isMainnetGateway) ?? "https://arweave.net";
-function mirrorGatewaysFor(primary) {
-  const p = primary.replace(/\/+$/, "");
-  return ARWEAVE_GATEWAYS.filter((g) => g.replace(/\/+$/, "") !== p);
-}
-
 // src/cli/render.ts
+function describeAnnouncementDiff(diff) {
+  return [
+    ...diff.removed.map((tag) => `  - ${tag.join(" ")}`),
+    ...diff.added.map((tag) => `  + ${tag.join(" ")}`)
+  ];
+}
 function formatNumber(value) {
   return String(value).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 }
@@ -214,6 +216,14 @@ function repoHashRoute(options) {
 function rigWebRoute(options) {
   return `${options.rigWebUrl.replace(/\/+$/, "")}/${repoHashRoute(options)}`;
 }
+function repoWebUrl(options) {
+  return rigWebRoute({
+    rigWebUrl: options.env[RIG_WEB_URL_ENV] ?? DEFAULT_RIG_WEB_URL,
+    relay: options.relay,
+    ownerNpub: hexToNpub(options.ownerPubkey),
+    repoId: options.repoId
+  });
+}
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
@@ -300,7 +310,7 @@ function loadPaidSession(deps, relayUrl) {
   });
 }
 var defaultLoadStandalone = async (options) => {
-  const mod = await import("./standalone-mode-W3ZEKC6M.js");
+  const mod = await import("./standalone-mode-FY3XVQQK.js");
   return mod.createStandaloneContext(options);
 };
 function identityReport(ctx) {
@@ -559,6 +569,14 @@ async function runPush(args, deps) {
         `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 announcement = relaysUsed[0] === void 0 ? void 0 : {
+      web: repoWebUrl({
+        env: deps.env,
+        relay: relaysUsed[0],
+        ownerPubkey: identity.pubkey,
+        repoId
+      })
+    };
     let plan;
     let execute;
     let pointerPlan;
@@ -577,7 +595,8 @@ async function runPush(args, deps) {
         feeRates,
         repoId,
         refs: refspecs,
-        force: flags.force
+        force: flags.force,
+        ...announcement ? { announcement } : {}
       });
       plan = serializePushPlan(pushPlan);
       execute = async () => serializePushResult(
@@ -612,7 +631,8 @@ async function runPush(args, deps) {
         repoId,
         refspecs,
         force: flags.force,
-        relayUrls: relaysUsed
+        relayUrls: relaysUsed,
+        ...announcement ? { announcement } : {}
       });
       execute = () => client.gitPush({
         repoPath: repoRoot,
@@ -620,7 +640,8 @@ async function runPush(args, deps) {
         refspecs,
         force: flags.force,
         relayUrls: relaysUsed,
-        confirm: true
+        confirm: true,
+        ...announcement ? { announcement } : {}
       });
       rigPageSkipDetail = "skipped on the daemon path (refreshes on the next standalone push)";
     }
@@ -879,6 +900,82 @@ async function resolveRepoContext(flags, deps) {
     ...repoRoot !== void 0 ? { repoRoot } : {}
   };
 }
+async function conformanceFactsFor(options) {
+  const { ctx, relayUrl, deps } = options;
+  const repoRoot = ctx.repoRoot;
+  const rootCommits = deps.rootCommits ?? (repoRoot === void 0 ? void 0 : (rev) => new GitRepoReader(repoRoot).rootCommits(rev));
+  let euc = null;
+  if (rootCommits !== void 0) {
+    try {
+      euc = await earliestUniqueCommit({ rootCommits });
+    } catch {
+      euc = null;
+    }
+  }
+  let web = null;
+  try {
+    web = repoWebUrl({
+      env: deps.env,
+      relay: relayUrl,
+      ownerPubkey: ctx.owner,
+      repoId: ctx.repoId
+    });
+  } catch {
+    web = null;
+  }
+  return { relays: [relayUrl], web, earliestUniqueCommit: euc };
+}
+async function openAnnouncementRepublish(options) {
+  const { deps, flags, what, before } = options;
+  const { io } = deps;
+  const ctx = await resolveRepoContext(flags, deps);
+  if (ctx.relays.length > 1) {
+    io.err(singleRelayRefusal(ctx.resolved, "Nothing was published or paid."));
+    return { ok: false, exitCode: 1 };
+  }
+  const relayUrl = ctx.relays[0];
+  if (relayUrl === void 0 || !WS_URL_RE.test(relayUrl)) {
+    throw new InvalidRelayUrlError(
+      relayUrl ?? "",
+      "a paid publish needs a ws:// or wss:// relay"
+    );
+  }
+  const load = deps.loadStandalone ?? defaultLoadStandalone;
+  const standalone = await load({
+    env: deps.env,
+    cwd: deps.cwd,
+    warn: (line) => io.err(line),
+    relayUrl
+  });
+  const identity = identityReport(standalone);
+  if (identity.pubkey.toLowerCase() !== ctx.owner.toLowerCase()) {
+    io.err(
+      `rig: only the repo owner (${ctx.owner.slice(0, 8)}\u2026) can ${what} \u2014 the active identity is ${identity.pubkey.slice(0, 8)}\u2026. A non-owner republish would write your own (ignored) announcement. Nothing was published or paid.`
+    );
+    return { ok: false, exitCode: 1, standalone };
+  }
+  const remote = await fetchRemoteState({
+    relayUrls: [relayUrl],
+    ownerPubkey: ctx.owner,
+    repoId: ctx.repoId,
+    ...deps.webSocketFactory ? { webSocketFactory: deps.webSocketFactory } : {}
+  });
+  if (!remote.announced) {
+    io.err(
+      `rig: 30617:${ctx.owner.slice(0, 8)}\u2026:${ctx.repoId} has no announcement yet \u2014 run \`rig push\` to publish the repo (with its real name/description) ${before}. Nothing was published or paid.`
+    );
+    return { ok: false, exitCode: 1, standalone };
+  }
+  return {
+    ok: true,
+    ctx,
+    relayUrl,
+    standalone,
+    identity,
+    remote,
+    facts: await conformanceFactsFor({ ctx, relayUrl, deps })
+  };
+}
 
 // src/cli/dispatch.ts
 import { createRequire } from "module";
@@ -2378,7 +2475,7 @@ async function runCi(args, deps) {
     case "status":
       return runCiStatus(rest, deps);
     case "serve":
-      return (await import("./ci-serve-PYEHIBN7.js")).runCiServe(rest, deps);
+      return (await import("./ci-serve-T33FCQVT.js")).runCiServe(rest, deps);
     case "--help":
     case "-h":
     case "help":
@@ -2418,6 +2515,11 @@ from Arweave gateways. A clone right after a push may report missing
 objects \u2014 retry after propagation.
 
 Options:
+  --gateway <url>      gateway to read objects through FIRST, on its raw-bytes
+                       route <url>/raw/<txId>, ahead of the public gateway
+                       list \u2014 name a private, local or air-gapped gateway to
+                       clone a repo the public ones do not carry
+                       (env RIG_ARWEAVE_GATEWAY also sets it)
   --concurrency <n>    parallel gateway downloads (default 8)
   --json               machine-readable result envelope
   -h, --help           show this help`;
@@ -2444,6 +2546,7 @@ function parseCloneArgs(args) {
     options: {
       json: { type: "boolean", default: false },
       concurrency: { type: "string" },
+      gateway: { type: "string" },
       help: { type: "boolean", short: "h", default: false }
     },
     allowPositionals: true
@@ -2479,6 +2582,7 @@ function parseCloneArgs(args) {
     repoId,
     dir,
     concurrency,
+    gateway: values.gateway,
     json: values.json === true
   };
 }
@@ -2527,7 +2631,9 @@ async function runClone(args, deps) {
       ownerPubkey: owner,
       repoId,
       ...deps.webSocketFactory ? { webSocketFactory: deps.webSocketFactory } : {},
-      ...deps.resolveSha ? { resolveSha: deps.resolveSha } : {}
+      // The GraphQL fallback for SHAs the map does not cover asks the SAME
+      // permaweb the objects are read from (#183).
+      resolveSha: deps.resolveSha ?? shaResolverFor(parsed.gateway, deps.env)
     });
     if (!remoteState.announced && remoteState.refsEvent === null) {
       throw new RepoNotFoundError(relayUrl, owner, repoId);
@@ -2552,6 +2658,8 @@ async function runClone(args, deps) {
       tips,
       shaToTxId: remoteState.shaToTxId,
       resolveMissing: (shas) => remoteState.resolveMissing(shas),
+      // `--gateway` / RIG_ARWEAVE_GATEWAY first, public list behind it (#176).
+      gateways: readGateways(parsed.gateway, deps.env),
       ...deps.fetchFn ? { fetchFn: deps.fetchFn } : {},
       ...parsed.concurrency !== void 0 ? { concurrency: parsed.concurrency } : {}
     });
@@ -2640,7 +2748,6 @@ async function runClone(args, deps) {
 import { readFile } from "fs/promises";
 import { parseArgs as parseArgs8 } from "util";
 import {
-  REPOSITORY_ANNOUNCEMENT_KIND as REPOSITORY_ANNOUNCEMENT_KIND2,
   STATUS_APPLIED_KIND as STATUS_APPLIED_KIND2,
   STATUS_CLOSED_KIND as STATUS_CLOSED_KIND2,
   STATUS_DRAFT_KIND as STATUS_DRAFT_KIND2,
@@ -2675,9 +2782,10 @@ Options:
 ${READ_COMMON_FLAGS}`;
 var ISSUE_SHOW_USAGE = `Usage: rig issue show <event-id> [options]
 
-Show one issue (kind:1621): metadata, derived state, body, and its
-kind:1622 comments \u2014 FREE (relay reads only). <event-id> is the 64-char hex
-id \`rig issue create\` printed (also visible in \`rig issue list\`).
+Show one issue (kind:1621): metadata, derived state, body, and its comments
+\u2014 NIP-22 kind:1111 merged with legacy kind:1622 in time order \u2014 FREE (relay
+reads only). <event-id> is the 64-char hex id \`rig issue create\` printed
+(also visible in \`rig issue list\`).
 
 Options:
 ${READ_COMMON_FLAGS}`;
@@ -2694,7 +2802,8 @@ var PR_SHOW_USAGE = `Usage: rig pr show <event-id> [options]
 
 Show one patch/PR (kind:1617): metadata, derived state, the FULL patch text
 (real \`git format-patch\` output \u2014 pipe it to \`git am\` to apply), and its
-kind:1622 comments \u2014 FREE (relay reads only).
+comments \u2014 NIP-22 kind:1111 merged with legacy kind:1622 in time order \u2014
+FREE (relay reads only).
 
 Options:
 ${READ_COMMON_FLAGS}`;
@@ -2710,9 +2819,7 @@ var STATUS_KINDS = [
   STATUS_CLOSED_KIND,
   STATUS_DRAFT_KIND
 ];
-function tagValue(tags, name) {
-  return tags.find((t) => t[0] === name)?.[1];
-}
+var tagValue = firstTagValue;
 function tagValues(tags, name) {
   return tags.filter((t) => t[0] === name && t[1]).map((t) => t[1]);
 }
@@ -2729,6 +2836,9 @@ function deriveStatus(targetEventId, statusEvents, authorized) {
   }
   return winner === null ? "open" : STATUS_BY_KIND[winner.kind];
 }
+function withTargetAuthor(authorized, targetAuthorPubkey) {
+  return /* @__PURE__ */ new Set([...authorized, targetAuthorPubkey.toLowerCase()]);
+}
 var RELAY_TIMEOUT_MS = 1e4;
 var HEX64_RE2 = /^[0-9a-f]{64}$/;
 var WS_URL_RE3 = /^wss?:\/\//i;
@@ -2872,7 +2982,7 @@ function parseTrackerItem(event, status) {
   };
   if (event.kind === PATCH_KIND) {
     item.commitShas = tagValues(event.tags, "commit");
-    const branch = tagValue(event.tags, "branch");
+    const branch = tagValue(event.tags, "branch-name") ?? tagValue(event.tags, "branch");
     if (branch !== void 0) item.branch = branch;
     const description = tagValue(event.tags, "description");
     if (description !== void 0) item.description = description;
@@ -2917,7 +3027,14 @@ async function fetchItems(ctx, kind) {
   }
   const authorized = await authorizedPromise;
   return items.map(
-    (event) => parseTrackerItem(event, deriveStatus(event.id, statuses.values(), authorized))
+    (event) => parseTrackerItem(
+      event,
+      deriveStatus(
+        event.id,
+        statuses.values(),
+        withTargetAuthor(authorized, event.pubkey)
+      )
+    )
   ).sort((a, b) => b.createdAt - a.createdAt);
 }
 async function fetchItem(ctx, eventId, expectedKind) {
@@ -2942,16 +3059,23 @@ async function fetchItem(ctx, eventId, expectedKind) {
       [{ kinds: STATUS_KINDS, "#e": [eventId] }],
       ctx.webSocketFactory
     ),
+    // One thread, two wire shapes (#159): NIP-22 kind:1111 comments hang off
+    // the root's UPPERCASE `E` tag (a nested reply's lowercase `e` names its
+    // parent comment, so `#e` would miss it); legacy kind:1622 comments only
+    // ever carry the lowercase `e`. Both are merged below by `created_at`.
     queryAll(
       ctx.relays,
-      [{ kinds: [COMMENT_KIND], "#e": [eventId] }],
+      [
+        { kinds: [COMMENT_KIND], "#E": [eventId] },
+        { kinds: [LEGACY_COMMENT_KIND], "#e": [eventId] }
+      ],
       ctx.webSocketFactory
     )
   ]);
-  const comments = [...commentEvents.values()].filter(
-    (e) => e.kind === COMMENT_KIND && e.tags.some((t) => t[0] === "e" && t[1] === eventId)
-  ).sort((a, b) => a.created_at - b.created_at).map((e) => ({
+  const comments = [...commentEvents.values()].filter((e) => commentBelongsToThread(e, eventId)).sort((a, b) => a.created_at - b.created_at).map((e) => ({
     eventId: e.id,
+    kind: e.kind,
+    replyToEventId: tagValue(e.tags, "e") ?? null,
     authorPubkey: e.pubkey,
     createdAt: e.created_at,
     content: e.content
@@ -2962,7 +3086,11 @@ async function fetchItem(ctx, eventId, expectedKind) {
   return {
     item: parseTrackerItem(
       event,
-      deriveStatus(eventId, statusEvents.values(), authorized)
+      deriveStatus(
+        eventId,
+        statusEvents.values(),
+        withTargetAuthor(authorized, event.pubkey)
+      )
     ),
     comments,
     repoATag: repoATag2
@@ -3028,8 +3156,9 @@ async function runList(args, deps, spec) {
     }
     for (const item of items) {
       const labels = item.labels.length > 0 ? `  [${item.labels.join(", ")}]` : "";
+      const branch = item.branch !== void 0 ? `  \u2192 ${item.branch}` : "";
       io.out(
-        `${item.status.padEnd(7)}  ${item.eventId.slice(0, 8)}  ${item.title}  (${item.authorPubkey.slice(0, 8)}, ${isoDate(item.createdAt)})${labels}`
+        `${item.status.padEnd(7)}  ${item.eventId.slice(0, 8)}  ${item.title}  (${item.authorPubkey.slice(0, 8)}, ${isoDate(item.createdAt)})${labels}${branch}`
       );
     }
     io.out(
@@ -3105,8 +3234,9 @@ async function runShow(args, deps, spec) {
     io.out("");
     io.out(`Comments (${shown.comments.length}):`);
     for (const comment of shown.comments) {
+      const replyTo = comment.replyToEventId !== null && comment.replyToEventId !== item.eventId ? ` in reply to ${comment.replyToEventId.slice(0, 8)}` : "";
       io.out(
-        `--- ${comment.eventId.slice(0, 8)} by ${comment.authorPubkey.slice(0, 8)} on ${isoDate(comment.createdAt)}`
+        `--- ${comment.eventId.slice(0, 8)} by ${comment.authorPubkey.slice(0, 8)} on ${isoDate(comment.createdAt)}${replyTo}`
       );
       for (const line of comment.content.split("\n")) io.out(line);
     }
@@ -3194,18 +3324,27 @@ ${COMMON_FLAGS_USAGE2}
 Related (FREE reads \u2014 no payment):
   rig issue list [--state open|closed|all]   list the repo's issues
   rig issue show <event-id>                  one issue + its comments`;
-var COMMENT_USAGE = `Usage: rig comment <root-event-id> --body <text> [options]
+var COMMENT_USAGE = `Usage: rig comment <target-event-id> --body <text> [options]
+
+Comment (NIP-22 kind:1111) on an issue or patch \u2014 a paid publish; writes are
+permanent and non-refundable. <target-event-id> is the 64-char hex id of
+either:
+
+  the kind:1621 issue / kind:1617 patch being commented on \u2192 a top-level
+    comment, whose NIP-22 root scope (E/K/P) and parent (e/k/p) both name it;
+  an existing kind:1111 comment \u2192 a REPLY: the comment becomes the lowercase
+    parent (k=1111) while the uppercase root stays the issue/patch it hangs
+    off.
 
-Comment (kind:1622) on an issue or patch \u2014 a paid publish; writes are
-permanent and non-refundable. <root-event-id> is the 64-char hex id of the
-kind:1621 issue / kind:1617 patch being commented on.
+The target is read from the resolved relay first (a FREE read) so the root's
+kind and author are taken from the wire rather than guessed. The repo
+coordinate rides along as an \`a\` tag for subscription filtering.
+
+Older rig releases read only the legacy kind:1622 dialect and will NOT see
+comments published by this version.
 
 Options:
   --body <text>            comment body (Markdown) [required]
-  --parent-author <pubkey> pubkey of the TARGET event's author (p threading
-                           tag; default: the repo owner)
-  --marker <root|reply>    e-tag marker (default: root \u2014 commenting directly
-                           on the issue/patch)
 ${COMMON_FLAGS_USAGE2}`;
 var PR_CREATE_USAGE = `Usage: rig pr create --title <title> (--range <range> | --patch-file <path>) [options]
 
@@ -3228,7 +3367,7 @@ Options:
   --patch-file <path>  literal patch text to publish
   --body <text>        PR description (Markdown; description tag)
   --body-file <path>   read the PR description from a file
-  --branch <name>      branch name (t tag)
+  --branch <name>      branch name (branch-name tag)
 ${COMMON_FLAGS_USAGE2}`;
 var PR_STATUS_USAGE = `Usage: rig pr status <target-event-id> <open|applied|closed|draft> [options]
 
@@ -3333,7 +3472,7 @@ async function runEvent(opts) {
     }
     const owner = flags.owner ?? toonConfig.owner ?? identity.pubkey;
     const addr = { ownerPubkey: owner, repoId };
-    const event = await opts.buildEvent(addr);
+    const event = await opts.buildEvent(addr, relaysUsed[0]);
     const action = `kind:${event.kind} ${actionLabel}`;
     if (opts.preConfirm) {
       await opts.preConfirm({ identity, addr, relayUrl: relaysUsed[0] });
@@ -3506,19 +3645,64 @@ async function runIssue(args, deps) {
     })
   });
 }
+var TARGET_LOOKUP_TIMEOUT_MS = 1e4;
+async function resolveCommentTarget(deps, targetEventId, relayUrl) {
+  if (relayUrl === void 0) {
+    throw new Error(
+      "no relay resolved \u2014 a comment needs the target event to derive its NIP-22 root; pass --relay <url> or configure a remote"
+    );
+  }
+  const found = await queryRelay(
+    relayUrl,
+    { ids: [targetEventId] },
+    TARGET_LOOKUP_TIMEOUT_MS,
+    deps.webSocketFactory ?? defaultWebSocketFactory
+  );
+  const target = found.find((e) => e.id === targetEventId);
+  if (!target) {
+    throw new Error(
+      `event ${targetEventId} not found on ${relayUrl} \u2014 nothing was published or paid`
+    );
+  }
+  if (target.kind === LEGACY_COMMENT_KIND) {
+    throw new Error(
+      `event ${targetEventId} is a legacy kind:1622 comment \u2014 replies to it are not representable in NIP-22; comment on the issue or patch instead`
+    );
+  }
+  if (target.kind === COMMENT_KIND) {
+    const rootEventId = firstTagValue(target.tags, "E");
+    const rootKind = Number(firstTagValue(target.tags, "K"));
+    const rootAuthor = firstTagValue(target.tags, "P");
+    if (rootEventId === void 0 || !HEX64_RE3.test(rootEventId) || !Number.isSafeInteger(rootKind) || rootAuthor === void 0 || !HEX64_RE3.test(rootAuthor)) {
+      throw new Error(
+        `kind:1111 comment ${targetEventId} carries no usable NIP-22 root scope (E/K/P tags) \u2014 cannot derive the thread root to reply into`
+      );
+    }
+    return {
+      root: { eventId: rootEventId, kind: rootKind, authorPubkey: rootAuthor },
+      parent: { eventId: target.id, authorPubkey: target.pubkey }
+    };
+  }
+  return {
+    root: {
+      eventId: target.id,
+      kind: target.kind,
+      authorPubkey: target.pubkey
+    }
+  };
+}
 async function runComment(args, deps) {
   const { io } = deps;
   let flags;
-  let rootEventId;
+  let targetEventId;
   let body;
-  let parentAuthor;
-  let marker;
   try {
     const { values, positionals } = parseArgs8({
       args,
       options: {
         ...COMMON_OPTIONS2,
         body: { type: "string" },
+        // Retired by #159 — parsed only to explain the migration.
         "parent-author": { type: "string" },
         marker: { type: "string" }
       },
@@ -3529,49 +3713,59 @@ async function runComment(args, deps) {
       io.out(COMMENT_USAGE);
       return 0;
     }
+    if (values.marker !== void 0 || values["parent-author"] !== void 0) {
+      throw new Error(
+        "--marker and --parent-author were removed with the move to NIP-22 kind:1111 (#159): pass the comment you are replying to as <target-event-id> instead \u2014 its author and the thread root are read from the relay"
+      );
+    }
     if (positionals.length !== 1) {
       throw new Error(
-        positionals.length === 0 ? "<root-event-id> is required" : `expected exactly one <root-event-id>, got ${positionals.length} positionals`
+        positionals.length === 0 ? "<target-event-id> is required" : `expected exactly one <target-event-id>, got ${positionals.length} positionals`
       );
     }
-    rootEventId = positionals[0];
-    assertHex64(rootEventId, "<root-event-id>");
+    targetEventId = positionals[0];
+    assertHex64(targetEventId, "<target-event-id>");
     if (values.body === void 0 || values.body === "") {
       throw new Error("--body is required");
     }
     body = values.body;
-    parentAuthor = values["parent-author"];
-    if (parentAuthor !== void 0) assertHex64(parentAuthor, "--parent-author");
-    const rawMarker = values.marker ?? "root";
-    if (rawMarker !== "root" && rawMarker !== "reply") {
-      throw new Error(`--marker must be root or reply (got ${JSON.stringify(rawMarker)})`);
-    }
-    marker = rawMarker;
   } catch (err) {
     io.err(err instanceof Error ? err.message : String(err));
     io.err(COMMENT_USAGE);
     return 2;
   }
+  let threading;
   return runEvent({
     command: "comment",
     flags,
     deps,
-    actionLabel: `comment on ${rootEventId.slice(0, 8)}\u2026`,
-    buildEvent: async (addr) => buildComment(
-      addr.ownerPubkey,
-      addr.repoId,
-      rootEventId,
-      parentAuthor ?? addr.ownerPubkey,
-      body,
-      marker
-    ),
-    sendDaemon: (client, addr) => client.gitComment({
-      repoAddr: addr,
-      rootEventId,
-      body,
-      ...parentAuthor !== void 0 ? { parentAuthorPubkey: parentAuthor } : {},
-      marker
-    })
+    actionLabel: `comment on ${targetEventId.slice(0, 8)}\u2026`,
+    buildEvent: async (addr, relayUrl) => {
+      threading = await resolveCommentTarget(deps, targetEventId, relayUrl);
+      return buildComment(
+        addr.ownerPubkey,
+        addr.repoId,
+        threading.root,
+        body,
+        threading.parent
+      );
+    },
+    sendDaemon: (client, addr) => {
+      if (threading === void 0) {
+        throw new Error(
+          "internal: the comment target was not resolved before the publish"
+        );
+      }
+      const { root, parent } = threading;
+      return client.gitComment({
+        repoAddr: addr,
+        body,
+        rootEventId: root.eventId,
+        rootKind: root.kind,
+        rootAuthorPubkey: root.authorPubkey,
+        ...parent !== void 0 ? { parentComment: parent } : {}
+      });
+    }
   });
 }
 var PATCH_FROM_RE = /^From ([0-9a-f]{40}) /gm;
@@ -3776,14 +3970,18 @@ async function runPrStatus(args, deps) {
     flags,
     deps,
     actionLabel: `status ${status} on ${targetEventId.slice(0, 8)}\u2026`,
-    buildEvent: async (addr) => {
-      const event = buildStatus(targetEventId, STATUS_KIND_BY_VALUE[status]);
-      event.tags.push([
-        "a",
-        `${REPOSITORY_ANNOUNCEMENT_KIND2}:${addr.ownerPubkey}:${addr.repoId}`
-      ]);
-      return event;
-    },
+    buildEvent: async (addr) => (
+      // buildStatus (rig#160) now emits the root-marked `e` tag and the repo
+      // `a` tag itself, so readers can scope a status stream to the
+      // repository without resolving the target first (mirrors the
+      // daemon's gitStatus).
+      buildStatus(
+        addr.ownerPubkey,
+        addr.repoId,
+        targetEventId,
+        STATUS_KIND_BY_VALUE[status]
+      )
+    ),
     // Authority warning (#287): a status event only moves an issue/PR's
     // resolved state for repo-authority-honoring clients if its author is the
     // owner or a declared maintainer. Warn clearly when the active identity is
@@ -3811,11 +4009,11 @@ async function warnIfNotMaintainer(deps, args) {
     );
     if (authorized.has(identity.pubkey.toLowerCase())) return;
     io.err(
-      `warning: you (${identity.pubkey.slice(0, 8)}\u2026) are not a maintainer of 30617:${addr.ownerPubkey.slice(0, 8)}\u2026:${addr.repoId} \u2014 clients honoring repo authority (rig, rig-web) will IGNORE this status when resolving the issue/PR's state. Publishing anyway (the relay is permissionless); ask the owner to \`rig maintainers add\` you if this should stick.`
+      `warning: you (${identity.pubkey.slice(0, 8)}\u2026) are not a maintainer of 30617:${addr.ownerPubkey.slice(0, 8)}\u2026:${addr.repoId} \u2014 clients honoring repo authority (rig, rig-web) will IGNORE this status when resolving the issue/PR's state, UNLESS you are also the target event's own author (rig#160: an issue/PR author may move their own item\u2019s status even without maintainer standing \u2014 this check cannot tell from here, since it does not know the target's author without a second relay read). Publishing anyway (the relay is permissionless); ask the owner to \`rig maintainers add\` you if this should stick for OTHER items too.`
     );
   } catch {
     io.err(
-      "warning: could not read the repo announcement to verify your maintainer status \u2014 if you are not the owner or a declared maintainer, authority-honoring clients will ignore this status."
+      "warning: could not read the repo announcement to verify your maintainer status \u2014 if you are not the owner, a declared maintainer, or the target event's own author, authority-honoring clients will ignore this status."
     );
   }
 }
@@ -4059,6 +4257,11 @@ Options:
   --repo-id <id>       repository id / NIP-34 d-tag (default: git config)
   --owner <pubkey>     repository owner (npub or 64-char hex; default: git config)
   --relay <url>        ad-hoc relay override \u2014 bypasses the remote's URL
+  --gateway <url>      gateway to read objects through FIRST, on its raw-bytes
+                       route <url>/raw/<txId>, ahead of the public gateway
+                       list \u2014 name a private, local or air-gapped gateway to
+                       fetch objects the public ones do not carry
+                       (env RIG_ARWEAVE_GATEWAY also sets it)
   --concurrency <n>    parallel gateway downloads (default 8)
   --json               machine-readable result envelope
   -h, --help           show this help`;
@@ -4091,6 +4294,7 @@ async function runFetch(args, deps) {
   let relayFlag;
   let repoIdFlag;
   let ownerFlag;
+  let gatewayFlag;
   let concurrency;
   try {
     const { values, positionals } = parseArgs10({
@@ -4100,6 +4304,7 @@ async function runFetch(args, deps) {
         relay: { type: "string" },
         "repo-id": { type: "string" },
         owner: { type: "string" },
+        gateway: { type: "string" },
         concurrency: { type: "string" },
         help: { type: "boolean", short: "h", default: false }
       },
@@ -4119,6 +4324,7 @@ async function runFetch(args, deps) {
     relayFlag = values.relay;
     repoIdFlag = values["repo-id"];
     ownerFlag = values.owner !== void 0 ? ownerToHex(values.owner) : void 0;
+    gatewayFlag = values.gateway;
     if (values.concurrency !== void 0) {
       concurrency = Number.parseInt(values.concurrency, 10);
       if (!Number.isSafeInteger(concurrency) || concurrency < 1) {
@@ -4157,7 +4363,9 @@ async function runFetch(args, deps) {
       ownerPubkey: owner,
       repoId,
       ...deps.webSocketFactory ? { webSocketFactory: deps.webSocketFactory } : {},
-      ...deps.resolveSha ? { resolveSha: deps.resolveSha } : {}
+      // The GraphQL fallback for SHAs the map does not cover asks the SAME
+      // permaweb the objects are read from (#183).
+      resolveSha: deps.resolveSha ?? shaResolverFor(gatewayFlag, deps.env)
     });
     const planned = [];
     for (const [refname, sha] of remoteState.refs) {
@@ -4178,17 +4386,14 @@ async function runFetch(args, deps) {
     }
     const reader = new GitRepoReader(repoRoot);
     const tips = [...new Set(planned.map((p) => p.newSha))];
-    const candidates = [.../* @__PURE__ */ new Set([...remoteState.shaToTxId.keys(), ...tips])];
-    const { missing: absent } = await reader.statObjects(candidates);
-    const absentSet = new Set(absent);
-    const presentLocally = new Set(
-      candidates.filter((sha) => !absentSet.has(sha))
-    );
+    const presentLocally = new Set(await reader.listAllObjectShas());
     const collected = await collectRepoObjects({
       tips,
       shaToTxId: remoteState.shaToTxId,
       resolveMissing: (shas) => remoteState.resolveMissing(shas),
       presentLocally,
+      // `--gateway` / RIG_ARWEAVE_GATEWAY first, public list behind it (#176).
+      gateways: readGateways(gatewayFlag, deps.env),
       ...deps.fetchFn ? { fetchFn: deps.fetchFn } : {},
       ...concurrency !== void 0 ? { concurrency } : {}
     });
@@ -5522,44 +5727,15 @@ async function runMutate(op, args, deps) {
   }
   let standaloneCtx;
   try {
-    const ctx = await resolveRepoContext(flags, deps);
-    if (ctx.relays.length > 1) {
-      io.err(singleRelayRefusal(ctx.resolved, "Nothing was published or paid."));
-      return 1;
-    }
-    const relayUrl = ctx.relays[0];
-    if (relayUrl === void 0 || !WS_URL_RE.test(relayUrl)) {
-      throw new InvalidRelayUrlError(
-        relayUrl ?? "",
-        "a paid publish needs a ws:// or wss:// relay"
-      );
-    }
-    const load = deps.loadStandalone ?? defaultLoadStandalone;
-    standaloneCtx = await load({
-      env: deps.env,
-      cwd: deps.cwd,
-      warn: (line) => io.err(line),
-      relayUrl
+    const opened = await openAnnouncementRepublish({
+      deps,
+      flags,
+      what: "change the maintainer set",
+      before: "before managing maintainers"
     });
-    const identity = identityReport(standaloneCtx);
-    if (identity.pubkey.toLowerCase() !== ctx.owner.toLowerCase()) {
-      io.err(
-        `rig: only the repo owner (${ctx.owner.slice(0, 8)}\u2026) can change the maintainer set \u2014 the active identity is ${identity.pubkey.slice(0, 8)}\u2026. A non-owner republish would write your own (ignored) announcement. Nothing was published or paid.`
-      );
-      return 1;
-    }
-    const remote = await fetchRemoteState({
-      relayUrls: [relayUrl],
-      ownerPubkey: ctx.owner,
-      repoId: ctx.repoId,
-      ...deps.webSocketFactory ? { webSocketFactory: deps.webSocketFactory } : {}
-    });
-    if (!remote.announced) {
-      io.err(
-        `rig: 30617:${ctx.owner.slice(0, 8)}\u2026:${ctx.repoId} has no announcement yet \u2014 run \`rig push\` to publish the repo (with its real name/description) before managing maintainers. Nothing was published or paid.`
-      );
-      return 1;
-    }
+    standaloneCtx = opened.standalone;
+    if (!opened.ok) return opened.exitCode;
+    const { ctx, relayUrl, identity, remote, facts } = opened;
     const current = remote.announceEvent ? parseMaintainers(remote.announceEvent.tags) : [];
     const currentSet = new Set(current);
     if (op === "add" && currentSet.has(pubkey)) {
@@ -5575,21 +5751,23 @@ async function runMutate(op, args, deps) {
       return 0;
     }
     const next = op === "add" ? [...current, pubkey] : current.filter((m) => m !== pubkey);
-    const name = remote.name ?? ctx.repoId;
-    const description = remote.description ?? "";
-    const event = buildRepoAnnouncement(
-      ctx.repoId,
-      name,
-      description,
-      next,
-      remote.payout
-    );
-    const fee = (await standaloneCtx.publisher.getFeeRates()).eventFee.toString();
+    const event = amendRepoAnnouncement(remote.announceEvent, {
+      repoId: ctx.repoId,
+      maintainers: next,
+      ...conformanceEdits(remote.announceEvent, facts)
+    });
+    const diff = diffAnnouncementTags(remote.announceEvent, event);
+    const changes = { added: diff.added, removed: diff.removed };
+    const fee = (await opened.standalone.publisher.getFeeRates()).eventFee.toString();
     const action = `kind:30617 maintainers ${op} ${pubkey.slice(0, 8)}\u2026`;
     if (!flags.json) {
       io.out(`Republish ${action}`);
       io.out(`Repo: 30617:${ctx.owner}:${ctx.repoId}`);
       io.out(`Maintainers after: ${next.length === 0 ? "(none)" : next.join(", ")}`);
+      if (!diff.unchanged) {
+        io.out("Tags changed:");
+        for (const line of describeAnnouncementDiff(diff)) io.out(line);
+      }
       io.out(`Fee: ${feeLabel(fee)}. Writes are permanent and non-refundable.`);
     }
     if (!flags.yes) {
@@ -5601,6 +5779,7 @@ async function runMutate(op, args, deps) {
           executed: false,
           feeEstimate: fee,
           maintainers: next,
+          changes,
           hint: "estimate only \u2014 re-run with --yes to publish (permanent, non-refundable)"
         });
         return 0;
@@ -5619,7 +5798,7 @@ async function runMutate(op, args, deps) {
         return 1;
       }
     }
-    const receipt = await standaloneCtx.publisher.publishEvent(event, [
+    const receipt = await opened.standalone.publisher.publishEvent(event, [
       relayUrl
     ]);
     const result = serializeEventReceipt(event.kind, receipt);
@@ -5631,6 +5810,7 @@ async function runMutate(op, args, deps) {
         executed: true,
         feeEstimate: fee,
         maintainers: next,
+        changes,
         result
       });
     } else {
@@ -5651,9 +5831,167 @@ async function runMutate(op, args, deps) {
   }
 }
 
+// src/cli/refresh.ts
+import { parseArgs as parseArgs15 } from "util";
+var REFRESH_USAGE = `Usage: rig refresh [options]
+
+Republish this repo's kind:30617 announcement with no field edit, refreshing
+its NIP-34 conformance tags (#158) so other clients can find and group it:
+
+  relays          the relay this repo publishes to \u2014 where its issues,
+                  patches and state live. Added to the relays the
+                  announcement already lists; none are removed
+  web             the repo's rig-web viewer URL, added alongside any
+                  viewer URL another client already announced
+  r <sha> euc     the earliest unique commit: the repo's fork identity.
+                  Written only if the announcement has none \u2014 once declared it
+                  never changes, so forks stay grouped
+
+Every other tag rides along verbatim, including tags written by other NIP-34
+clients. rig never writes a \`clone\` tag (it has no git-clonable URL) and never
+removes one.
+
+PAID: republishing the kind:30617 costs one event fee (permanent,
+non-refundable). Nothing is published and nothing is paid when no tag would
+change. Must run under the repo OWNER's identity \u2014 only the owner's
+announcement is authoritative.
+
+Options:
+  --repo-id <id>       repository id / NIP-34 d-tag (default: git config)
+  --owner <pubkey>     repository owner (npub or hex; default: git config)
+  --remote <name>      publish/read via this configured git remote (default: origin)
+  --relay <url>        ad-hoc relay override (exactly one)
+  --yes                skip the fee confirmation (required when not a TTY)
+  --json               machine-readable envelope
+  -h, --help           show this help`;
+async function runRefresh(args, deps) {
+  const { io } = deps;
+  let flags;
+  try {
+    const { values, positionals } = parseArgs15({
+      args,
+      options: REPO_COMMAND_OPTIONS,
+      allowPositionals: true
+    });
+    flags = pickRepoCommandFlags(values);
+    if (flags.help) {
+      io.out(REFRESH_USAGE);
+      return 0;
+    }
+    if (positionals.length > 0) {
+      throw new Error("rig refresh takes no positional arguments");
+    }
+  } catch (err) {
+    io.err(err instanceof Error ? err.message : String(err));
+    io.err(REFRESH_USAGE);
+    return 2;
+  }
+  let standaloneCtx;
+  try {
+    const opened = await openAnnouncementRepublish({
+      deps,
+      flags,
+      what: "refresh the announcement",
+      before: "before refreshing it"
+    });
+    standaloneCtx = opened.standalone;
+    if (!opened.ok) return opened.exitCode;
+    const { ctx, relayUrl, identity, remote, facts } = opened;
+    const event = amendRepoAnnouncement(remote.announceEvent, {
+      repoId: ctx.repoId,
+      ...conformanceEdits(remote.announceEvent, facts)
+    });
+    const diff = diffAnnouncementTags(remote.announceEvent, event);
+    if (diff.unchanged) {
+      const changes2 = { added: diff.added, removed: diff.removed };
+      if (flags.json) {
+        io.emitJson({
+          command: "refresh",
+          repoAddr: { ownerPubkey: ctx.owner, repoId: ctx.repoId },
+          identity,
+          executed: false,
+          feeEstimate: null,
+          changes: changes2,
+          hint: "announcement is already up to date \u2014 nothing published, nothing paid"
+        });
+        return 0;
+      }
+      io.out(
+        `Announcement 30617:${ctx.owner}:${ctx.repoId} is already up to date \u2014 nothing to do (not published, nothing paid).`
+      );
+      return 0;
+    }
+    const fee = (await opened.standalone.publisher.getFeeRates()).eventFee.toString();
+    const changes = { added: diff.added, removed: diff.removed };
+    if (!flags.json) {
+      io.out("Republish kind:30617 announcement (refresh)");
+      io.out(`Repo: 30617:${ctx.owner}:${ctx.repoId}`);
+      io.out("Tags changed:");
+      for (const line of describeAnnouncementDiff(diff)) io.out(line);
+      io.out(`Fee: ${feeLabel(fee)}. Writes are permanent and non-refundable.`);
+    }
+    if (!flags.yes) {
+      if (flags.json) {
+        io.emitJson({
+          command: "refresh",
+          repoAddr: { ownerPubkey: ctx.owner, repoId: ctx.repoId },
+          identity,
+          executed: false,
+          feeEstimate: fee,
+          changes,
+          hint: "estimate only \u2014 re-run with --yes to publish (permanent, non-refundable)"
+        });
+        return 0;
+      }
+      if (!io.isInteractive) {
+        io.err(
+          "refusing to spend channel funds without confirmation in a non-interactive session \u2014 re-run with --yes (or use --json for an estimate)"
+        );
+        return 1;
+      }
+      const proceed = await io.confirm(
+        `Proceed with paid republish (${feeLabel(fee)})? [y/N] `
+      );
+      if (!proceed) {
+        io.err("aborted \u2014 nothing was published.");
+        return 1;
+      }
+    }
+    const receipt = await opened.standalone.publisher.publishEvent(event, [
+      relayUrl
+    ]);
+    const result = serializeEventReceipt(event.kind, receipt);
+    if (flags.json) {
+      io.emitJson({
+        command: "refresh",
+        repoAddr: { ownerPubkey: ctx.owner, repoId: ctx.repoId },
+        identity,
+        executed: true,
+        feeEstimate: fee,
+        changes,
+        result
+      });
+    } else {
+      io.out(
+        `Published kind:30617 refresh: ${result.eventId}  paid ${result.feePaid} base units`
+      );
+    }
+    return 0;
+  } catch (err) {
+    return emitCliError(io, flags.json, "refresh", err);
+  } finally {
+    if (standaloneCtx) {
+      try {
+        await standaloneCtx.stop();
+      } catch {
+      }
+    }
+  }
+}
+
 // src/cli/name.ts
 import { randomUUID } from "crypto";
-import { parseArgs as parseArgs15 } from "util";
+import { parseArgs as parseArgs16 } from "util";
 var ARIO_DECIMALS = 6;
 function renderMario(mario) {
   return `${mario.toString()} mARIO (~${formatUnits(mario.toString(), ARIO_DECIMALS)} ARIO)`;
@@ -6162,7 +6500,7 @@ async function resolveNameContext(deps, network, processId, mode) {
   return { identity, solanaAddress, network, processId, sdk, nostrSecretKey };
 }
 function parseNameFlags(args, env) {
-  const { values, positionals } = parseArgs15({
+  const { values, positionals } = parseArgs16({
     args,
     allowPositionals: true,
     options: {
@@ -6721,7 +7059,7 @@ async function runName(args, deps) {
 }
 
 // src/cli/payout.ts
-import { parseArgs as parseArgs16 } from "util";
+import { parseArgs as parseArgs17 } from "util";
 import { getAddress } from "viem";
 var PAYOUT_USAGE = `Usage: rig payout <set|clear|show> [<address>] [options]
 
@@ -6777,7 +7115,7 @@ async function runShow2(args, deps) {
   const { io } = deps;
   let flags;
   try {
-    const { values, positionals } = parseArgs16({
+    const { values, positionals } = parseArgs17({
       args,
       options: REPO_COMMAND_OPTIONS,
       allowPositionals: true
@@ -6839,7 +7177,7 @@ async function runMutate2(op, args, deps) {
   let flags;
   let nextPayout = null;
   try {
-    const { values, positionals } = parseArgs16({
+    const { values, positionals } = parseArgs17({
       args,
       options: REPO_COMMAND_OPTIONS,
       allowPositionals: true
@@ -6870,44 +7208,15 @@ async function runMutate2(op, args, deps) {
   }
   let standaloneCtx;
   try {
-    const ctx = await resolveRepoContext(flags, deps);
-    if (ctx.relays.length > 1) {
-      io.err(singleRelayRefusal(ctx.resolved, "Nothing was published or paid."));
-      return 1;
-    }
-    const relayUrl = ctx.relays[0];
-    if (relayUrl === void 0 || !WS_URL_RE.test(relayUrl)) {
-      throw new InvalidRelayUrlError(
-        relayUrl ?? "",
-        "a paid publish needs a ws:// or wss:// relay"
-      );
-    }
-    const load = deps.loadStandalone ?? defaultLoadStandalone;
-    standaloneCtx = await load({
-      env: deps.env,
-      cwd: deps.cwd,
-      warn: (line) => io.err(line),
-      relayUrl
+    const opened = await openAnnouncementRepublish({
+      deps,
+      flags,
+      what: "change the payout pointer",
+      before: "before managing the payout pointer"
     });
-    const identity = identityReport(standaloneCtx);
-    if (identity.pubkey.toLowerCase() !== ctx.owner.toLowerCase()) {
-      io.err(
-        `rig: only the repo owner (${ctx.owner.slice(0, 8)}\u2026) can change the payout pointer \u2014 the active identity is ${identity.pubkey.slice(0, 8)}\u2026. A non-owner republish would write your own (ignored) announcement. Nothing was published or paid.`
-      );
-      return 1;
-    }
-    const remote = await fetchRemoteState({
-      relayUrls: [relayUrl],
-      ownerPubkey: ctx.owner,
-      repoId: ctx.repoId,
-      ...deps.webSocketFactory ? { webSocketFactory: deps.webSocketFactory } : {}
-    });
-    if (!remote.announced) {
-      io.err(
-        `rig: 30617:${ctx.owner.slice(0, 8)}\u2026:${ctx.repoId} has no announcement yet \u2014 run \`rig push\` to publish the repo (with its real name/description) before managing the payout pointer. Nothing was published or paid.`
-      );
-      return 1;
-    }
+    standaloneCtx = opened.standalone;
+    if (!opened.ok) return opened.exitCode;
+    const { ctx, relayUrl, identity, remote, facts } = opened;
     const current = remote.payout;
     if (nextPayout !== null && current !== null && current.chain === nextPayout.chain && current.address === nextPayout.address) {
       io.err(
@@ -6919,16 +7228,14 @@ async function runMutate2(op, args, deps) {
       io.err("rig: no payout pointer is set \u2014 nothing to do (not published).");
       return 0;
     }
-    const name = remote.name ?? ctx.repoId;
-    const description = remote.description ?? "";
-    const event = buildRepoAnnouncement(
-      ctx.repoId,
-      name,
-      description,
-      remote.maintainers,
-      nextPayout
-    );
-    const fee = (await standaloneCtx.publisher.getFeeRates()).eventFee.toString();
+    const event = amendRepoAnnouncement(remote.announceEvent, {
+      repoId: ctx.repoId,
+      payout: nextPayout,
+      ...conformanceEdits(remote.announceEvent, facts)
+    });
+    const diff = diffAnnouncementTags(remote.announceEvent, event);
+    const changes = { added: diff.added, removed: diff.removed };
+    const fee = (await opened.standalone.publisher.getFeeRates()).eventFee.toString();
     const action = nextPayout ? `kind:30617 payout set ${nextPayout.chain} ${nextPayout.address}` : "kind:30617 payout clear";
     if (!flags.json) {
       io.out(`Republish ${action}`);
@@ -6936,6 +7243,10 @@ async function runMutate2(op, args, deps) {
       io.out(
         `Payout after: ${nextPayout ? `${nextPayout.chain} ${nextPayout.address}` : "(none)"}`
       );
+      if (!diff.unchanged) {
+        io.out("Tags changed:");
+        for (const line of describeAnnouncementDiff(diff)) io.out(line);
+      }
       io.out(`Fee: ${feeLabel(fee)}. Writes are permanent and non-refundable.`);
     }
     if (!flags.yes) {
@@ -6947,6 +7258,7 @@ async function runMutate2(op, args, deps) {
           executed: false,
           feeEstimate: fee,
           payout: nextPayout,
+          changes,
           hint: "estimate only \u2014 re-run with --yes to publish (permanent, non-refundable)"
         });
         return 0;
@@ -6965,7 +7277,7 @@ async function runMutate2(op, args, deps) {
         return 1;
       }
     }
-    const receipt = await standaloneCtx.publisher.publishEvent(event, [
+    const receipt = await opened.standalone.publisher.publishEvent(event, [
       relayUrl
     ]);
     const result = serializeEventReceipt(event.kind, receipt);
@@ -6977,6 +7289,7 @@ async function runMutate2(op, args, deps) {
         executed: true,
         feeEstimate: fee,
         payout: nextPayout,
+        changes,
         result
       });
     } else {
@@ -6998,7 +7311,7 @@ async function runMutate2(op, args, deps) {
 }
 
 // src/cli/site.ts
-import { parseArgs as parseArgs17 } from "util";
+import { parseArgs as parseArgs18 } from "util";
 
 // src/arweave-manifest.ts
 var DEFAULT_INDEX = "index.html";
@@ -7089,7 +7402,7 @@ Options (publish):
                        estimate (nothing uploaded)
   -h, --help           show this help`;
 function parseSiteArgs(args) {
-  const { values, positionals } = parseArgs17({
+  const { values, positionals } = parseArgs18({
     args,
     options: {
       index: { type: "string" },
@@ -7492,7 +7805,8 @@ Commands rig owns:
   issue list | show <id>     read the repo's issues + comments (free)
   pr list | show <id>        read the repo's patches; show prints the full
                              patch text (free)
-  comment <root-event-id>    comment (kind:1622) on an issue or patch
+  comment <target-event-id>  comment (NIP-22 kind:1111) on an issue or patch,
+                             or reply to an existing kind:1111 comment
   pr create                  publish a patch (kind:1617) with real
                              \`git format-patch\` content
   pr status <event-id> <state>  set an issue/patch status (kind:1630-1633):
@@ -7501,6 +7815,9 @@ Commands rig owns:
   maintainers add <pubkey>   remove republish the kind:30617 to change who may
   maintainers remove <pubkey>  author authoritative issue/PR status (owner is
                              always an implicit maintainer)
+  refresh                    republish the kind:30617 with no field edit to
+                             refresh its NIP-34 tags (relays, web, the euc fork
+                             identity) \u2014 PAID, and free when nothing changes
   payout show                show the repo's declared payout pointer (free);
   payout set <address>       set/clear republish the kind:30617 \u2014 no pointer
   payout clear               means the serving node keeps 100% of
@@ -7619,6 +7936,8 @@ async function dispatch(argv, deps) {
       return runMaintainers(rest, deps);
     case "payout":
       return runPayout(rest, deps);
+    case "refresh":
+      return runRefresh(rest, deps);
     case "channel":
       return runChannel(rest, deps);
     case "channels":
@@ -7661,7 +7980,6 @@ async function dispatch(argv, deps) {
 }
 
 export {
-  PREFERRED_GATEWAY,
   renderIdentityLine,
   withForcedStandalone,
   loadPaidSession,
@@ -7670,4 +7988,4 @@ export {
   rigVersion,
   dispatch
 };
-//# sourceMappingURL=chunk-UZZ2JKEC.js.map
+//# sourceMappingURL=chunk-J6Y3U645.js.map