@toon-protocol/client-mcp 0.12.1 → 0.13.0

package/dist/{chunk-HLATGATX.js → chunk-GQENVTED.js}

@@ -10,12 +10,13 @@ import {
   defaultConfigPath,
   deriveFullIdentity,
   encodeEventToToon,
+  extractArweaveTxId,
   fundWallet,
   generateKeystore,
   isEventExpired,
   parseIlpPeerInfo,
   readConfigFile
-} from "./chunk-W6T6ZK7U.js";
+} from "./chunk-UXCFHAUC.js";
 import {
   __require
 } from "./chunk-F22GNSF6.js";
@@ -355,10 +356,1077 @@ function defaultWebSocketFactory() {
 }
 
 // src/daemon/client-runner.ts
-import { readFile } from "fs/promises";
+import { readFile, stat } from "fs/promises";
 import { resolve, sep } from "path";
 import { generateSecretKey as generateSecretKey2 } from "nostr-tools/pure";
 
+// ../../node_modules/.pnpm/@toon-protocol+core@1.4.2_@toon-protocol+connector@3.13.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/nip34/index.js
+var REPOSITORY_ANNOUNCEMENT_KIND = 30617;
+var STATUS_OPEN_KIND = 1630;
+var STATUS_APPLIED_KIND = 1631;
+var STATUS_CLOSED_KIND = 1632;
+var STATUS_DRAFT_KIND = 1633;
+
+// ../../node_modules/.pnpm/@toon-protocol+core@1.6.0_@toon-protocol+connector@3.13.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/nip34/index.js
+var REPOSITORY_ANNOUNCEMENT_KIND2 = 30617;
+var PATCH_KIND = 1617;
+var ISSUE_KIND = 1621;
+
+// ../git/dist/chunk-KXXHAUXL.js
+var REPOSITORY_STATE_KIND = 30618;
+var COMMENT_KIND = 1622;
+function buildRepoAnnouncement(repoId, name, description) {
+  return {
+    kind: REPOSITORY_ANNOUNCEMENT_KIND2,
+    content: "",
+    tags: [
+      ["d", repoId],
+      ["name", name],
+      ["description", description]
+    ],
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildRepoRefs(repoId, refs, arweaveMap = {}) {
+  const tags = [["d", repoId]];
+  for (const [refPath, commitSha] of Object.entries(refs)) {
+    tags.push(["r", refPath, commitSha]);
+  }
+  const firstRef = Object.keys(refs)[0];
+  if (firstRef) {
+    tags.push(["HEAD", `ref: ${firstRef}`]);
+  }
+  for (const [sha, txId] of Object.entries(arweaveMap)) {
+    tags.push(["arweave", sha, txId]);
+  }
+  return {
+    kind: REPOSITORY_STATE_KIND,
+    content: "",
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildIssue(repoOwnerPubkey, repoId, title, body, labels = []) {
+  const tags = [
+    ["a", `${REPOSITORY_ANNOUNCEMENT_KIND2}:${repoOwnerPubkey}:${repoId}`],
+    ["p", repoOwnerPubkey],
+    ["subject", title],
+    ...labels.map((label) => ["t", label])
+  ];
+  return {
+    kind: ISSUE_KIND,
+    content: body,
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildComment(repoOwnerPubkey, repoId, issueOrPrEventId, authorPubkey, body, marker = "reply") {
+  return {
+    kind: COMMENT_KIND,
+    content: body,
+    tags: [
+      ["a", `${REPOSITORY_ANNOUNCEMENT_KIND2}:${repoOwnerPubkey}:${repoId}`],
+      ["e", issueOrPrEventId, "", marker],
+      ["p", authorPubkey]
+    ],
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildPatch(repoOwnerPubkey, repoId, title, commits, branchTag, content = "") {
+  const tags = [
+    ["a", `${REPOSITORY_ANNOUNCEMENT_KIND2}:${repoOwnerPubkey}:${repoId}`],
+    ["p", repoOwnerPubkey],
+    ["subject", title]
+  ];
+  for (const commit of commits) {
+    tags.push(["commit", commit.sha]);
+    tags.push(["parent-commit", commit.parentSha]);
+  }
+  if (branchTag) {
+    tags.push(["t", branchTag]);
+  }
+  return {
+    kind: PATCH_KIND,
+    content,
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+function buildStatus(targetEventId, statusKind, targetPubkey) {
+  const tags = [["e", targetEventId]];
+  if (targetPubkey) {
+    tags.push(["p", targetPubkey]);
+  }
+  return {
+    kind: statusKind,
+    content: "",
+    tags,
+    created_at: Math.floor(Date.now() / 1e3)
+  };
+}
+
+// ../git/dist/chunk-M7O4SEVW.js
+var MAX_OBJECT_SIZE = 95 * 1024;
+
+// ../git/dist/chunk-4WFGAICZ.js
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 256 * 1024 * 1024;
+var GitError = class extends Error {
+  constructor(message, exitCode, stderr) {
+    super(message);
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+    this.name = "GitError";
+  }
+  exitCode;
+  stderr;
+};
+var FULL_SHA_RE = /^[0-9a-f]{40}$/;
+var REV_TOKEN_RE = /^[A-Za-z0-9][A-Za-z0-9._/-]*(?:[~^][0-9]*)*$/;
+function isValidRevision(rev) {
+  if (rev.length === 0 || rev.length > 1024) return false;
+  if (!REV_TOKEN_RE.test(rev)) return false;
+  if (rev.includes("..")) return false;
+  if (rev.endsWith(".lock") || rev.endsWith("/") || rev.endsWith(".")) return false;
+  return true;
+}
+function assertRevision(rev, what) {
+  if (!isValidRevision(rev)) {
+    throw new Error(
+      `${what} is not a valid git revision (got ${JSON.stringify(rev)}); expected a SHA or simple refname \u2014 options/ranges are rejected`
+    );
+  }
+}
+function assertFullSha(sha, what) {
+  if (!FULL_SHA_RE.test(sha)) {
+    throw new Error(
+      `${what} is not a full 40-hex SHA-1 (got ${JSON.stringify(sha)})`
+    );
+  }
+}
+function assertRange(range, what) {
+  const parts = range.split(/\.{2,3}/);
+  const separators = range.match(/\.{2,3}/g) ?? [];
+  const ok = parts.length <= 2 && separators.length === parts.length - 1 && parts.every((p) => isValidRevision(p));
+  if (!ok) {
+    throw new Error(
+      `${what} is not a valid revision range (got ${JSON.stringify(range)}); expected <rev>, <rev>..<rev>, or <rev>...<rev>`
+    );
+  }
+}
+var OBJECT_TYPES = /* @__PURE__ */ new Set(["blob", "tree", "commit", "tag"]);
+var BatchParser = class {
+  buf = Buffer.alloc(0);
+  pending = null;
+  objects = [];
+  missing = [];
+  push(chunk) {
+    this.buf = this.buf.length === 0 ? chunk : Buffer.concat([this.buf, chunk]);
+    this.drain();
+  }
+  /** True when no partially-parsed record remains. */
+  isComplete() {
+    return this.pending === null && this.buf.length === 0;
+  }
+  drain() {
+    for (; ; ) {
+      if (this.pending) {
+        const needed = this.pending.size + 1;
+        if (this.buf.length < needed) return;
+        const body = Buffer.from(this.buf.subarray(0, this.pending.size));
+        this.objects.push({ sha: this.pending.sha, type: this.pending.type, body });
+        this.buf = this.buf.subarray(needed);
+        this.pending = null;
+        continue;
+      }
+      const nl = this.buf.indexOf(10);
+      if (nl === -1) return;
+      const header = this.buf.subarray(0, nl).toString("utf-8");
+      this.buf = this.buf.subarray(nl + 1);
+      const [name, second, third] = header.split(" ");
+      if (name && second === "missing" && third === void 0) {
+        this.missing.push(name);
+        continue;
+      }
+      if (name && second && third !== void 0 && OBJECT_TYPES.has(second)) {
+        const size = Number.parseInt(third, 10);
+        if (Number.isSafeInteger(size) && size >= 0) {
+          this.pending = { sha: name, type: second, size };
+          continue;
+        }
+      }
+      throw new GitError(
+        `unexpected cat-file --batch header: ${JSON.stringify(header)}`,
+        void 0,
+        ""
+      );
+    }
+  }
+};
+var GitRepoReader = class {
+  constructor(repoPath) {
+    this.repoPath = repoPath;
+  }
+  repoPath;
+  /** Run git with argument-array safety; resolves stdout as UTF-8. */
+  async git(args, opts = {}) {
+    try {
+      const { stdout } = await execFileAsync("git", args, {
+        cwd: this.repoPath,
+        maxBuffer: MAX_BUFFER,
+        encoding: "utf-8"
+      });
+      return { stdout, exitCode: 0 };
+    } catch (err) {
+      const e = err;
+      const exitCode = typeof e.code === "number" ? e.code : void 0;
+      if (exitCode !== void 0 && opts.allowExitCodes?.includes(exitCode)) {
+        return { stdout: e.stdout ?? "", exitCode };
+      }
+      throw new GitError(
+        `git ${args[0]} failed${exitCode !== void 0 ? ` (exit ${exitCode})` : ""}: ${(e.stderr ?? e.message ?? "").trim()}`,
+        exitCode,
+        (e.stderr ?? "").trim()
+      );
+    }
+  }
+  /**
+   * List all branches and tags plus the symbolic HEAD.
+   *
+   * Annotated tags report the tag object's SHA/type with the peeled target
+   * in `peeledSha`. A detached HEAD is tolerated (`head` is `undefined`).
+   */
+  async listRefs() {
+    const format = "%(refname)%00%(objectname)%00%(objecttype)%00%(*objectname)";
+    const [refsRes, headRes] = await Promise.all([
+      this.git(["for-each-ref", `--format=${format}`, "refs/heads", "refs/tags"]),
+      // Exit 1 = detached HEAD (or unborn branch pointer oddities) — tolerated.
+      this.git(["symbolic-ref", "--quiet", "HEAD"], { allowExitCodes: [1] })
+    ]);
+    const refs = [];
+    for (const line of refsRes.stdout.split("\n")) {
+      if (!line) continue;
+      const [refname, sha, objecttype, peeled] = line.split("\0");
+      if (!refname || !sha || !objecttype || !OBJECT_TYPES.has(objecttype)) {
+        throw new GitError(`unexpected for-each-ref line: ${JSON.stringify(line)}`, void 0, "");
+      }
+      refs.push({
+        refname,
+        sha,
+        type: objecttype,
+        ...peeled ? { peeledSha: peeled } : {}
+      });
+    }
+    const head = headRes.exitCode === 0 ? headRes.stdout.trim() || void 0 : void 0;
+    return { head, refs };
+  }
+  /**
+   * SHAs of every object reachable from `want` but not from `have`
+   * (`git rev-list --objects <want…> --not <have…>`), i.e. the push delta.
+   *
+   * Haves that don't exist locally (e.g. remote tips we never fetched) are
+   * filtered out first via one `cat-file --batch-check` pass — rev-list
+   * would otherwise die on them.
+   */
+  async objectsBetween(want, have) {
+    const objects = await this.objectsBetweenWithPaths(want, have);
+    return objects.map((o) => o.sha);
+  }
+  /**
+   * Like {@link objectsBetween} but keeps the path each object was reached
+   * by (`rev-list --objects` emits `<sha> <path>` for blobs and non-root
+   * trees) — used by push planning to report actionable oversize errors.
+   */
+  async objectsBetweenWithPaths(want, have) {
+    for (const w of want) assertRevision(w, "want");
+    for (const h of have) assertRevision(h, "have");
+    if (want.length === 0) return [];
+    const knownHaves = await this.filterExisting(have);
+    const args = ["rev-list", "--objects", ...want];
+    if (knownHaves.length > 0) args.push("--not", ...knownHaves);
+    args.push("--");
+    const { stdout } = await this.git(args);
+    const objects = [];
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx === -1) {
+        objects.push({ sha: line });
+      } else {
+        const path = line.slice(spaceIdx + 1);
+        objects.push({
+          sha: line.slice(0, spaceIdx),
+          ...path ? { path } : {}
+        });
+      }
+    }
+    return objects;
+  }
+  /** Run git feeding `input` on stdin; resolves collected stdout bytes. */
+  runWithStdin(args, input) {
+    return new Promise((resolve2, reject) => {
+      const child = spawn("git", args, {
+        cwd: this.repoPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const out = [];
+      let stderr = "";
+      child.stdout.on("data", (chunk) => out.push(chunk));
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        reject(new GitError(`failed to spawn git ${args[0]}: ${err.message}`, void 0, ""));
+      });
+      child.on("close", (code) => {
+        if (code !== 0) {
+          return reject(
+            new GitError(`git ${args[0]} failed (exit ${code}): ${stderr.trim()}`, code ?? void 0, stderr.trim())
+          );
+        }
+        resolve2(Buffer.concat(out));
+      });
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(input);
+      child.stdin.end();
+    });
+  }
+  /** Of the given revisions, keep only those resolvable locally. */
+  async filterExisting(revs) {
+    if (revs.length === 0) return [];
+    const { missing } = await this.batchCheck(revs);
+    const missingSet = new Set(missing);
+    return revs.filter((r) => !missingSet.has(r));
+  }
+  /** One `cat-file --batch-check` pass; returns names reported missing. */
+  async batchCheck(names) {
+    const stdout = await this.runWithStdin(
+      ["cat-file", "--batch-check"],
+      names.join("\n") + "\n"
+    );
+    const missing = [];
+    for (const line of stdout.toString("utf-8").split("\n")) {
+      if (line.endsWith(" missing")) missing.push(line.slice(0, -" missing".length));
+    }
+    return { missing };
+  }
+  /**
+   * Object metadata (type + body size) for a batch of SHAs via one
+   * `cat-file --batch-check` pass — no bodies are read. Missing objects are
+   * reported, not thrown.
+   */
+  async statObjects(shas) {
+    for (const sha of shas) assertFullSha(sha, "sha");
+    if (shas.length === 0) return { objects: [], missing: [] };
+    const stdout = await this.runWithStdin(
+      ["cat-file", "--batch-check"],
+      shas.join("\n") + "\n"
+    );
+    const objects = [];
+    const missing = [];
+    for (const line of stdout.toString("utf-8").split("\n")) {
+      if (!line) continue;
+      if (line.endsWith(" missing")) {
+        missing.push(line.slice(0, -" missing".length));
+        continue;
+      }
+      const [sha, type, sizeStr] = line.split(" ");
+      const size = Number.parseInt(sizeStr ?? "", 10);
+      if (!sha || !type || !OBJECT_TYPES.has(type) || !Number.isSafeInteger(size) || size < 0) {
+        throw new GitError(
+          `unexpected cat-file --batch-check line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      objects.push({ sha, type, size });
+    }
+    return { objects, missing };
+  }
+  /**
+   * Read raw object bodies via a single streaming `git cat-file --batch`
+   * child process. Bodies may be binary and are parsed size-driven across
+   * chunk boundaries. Missing objects are reported, not thrown.
+   */
+  async readObjects(shas) {
+    for (const sha of shas) assertFullSha(sha, "sha");
+    if (shas.length === 0) return { objects: [], missing: [] };
+    const parser = new BatchParser();
+    await new Promise((resolve2, reject) => {
+      const child = spawn("git", ["cat-file", "--batch"], {
+        cwd: this.repoPath,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stderr = "";
+      let parseError = null;
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.stdout.on("data", (chunk) => {
+        if (parseError) return;
+        try {
+          parser.push(chunk);
+        } catch (err) {
+          parseError = err;
+          child.kill();
+        }
+      });
+      child.on("error", (err) => {
+        reject(new GitError(`failed to spawn git cat-file: ${err.message}`, void 0, ""));
+      });
+      child.on("close", (code) => {
+        if (parseError) return reject(parseError);
+        if (code !== 0) {
+          return reject(
+            new GitError(`git cat-file --batch failed (exit ${code}): ${stderr.trim()}`, code ?? void 0, stderr.trim())
+          );
+        }
+        if (!parser.isComplete()) {
+          return reject(
+            new GitError("git cat-file --batch output ended mid-record", code ?? void 0, stderr.trim())
+          );
+        }
+        resolve2();
+      });
+      child.stdin.on("error", () => {
+      });
+      child.stdin.write(shas.join("\n") + "\n");
+      child.stdin.end();
+    });
+    return { objects: parser.objects, missing: parser.missing };
+  }
+  /**
+   * `git merge-base --is-ancestor <a> <b>` — true when `a` is an ancestor
+   * of `b` (fast-forward check / force detection). Exit codes other than
+   * 0/1 (e.g. unknown revisions) throw.
+   */
+  async isAncestor(a, b) {
+    assertRevision(a, "ancestor candidate");
+    assertRevision(b, "descendant candidate");
+    const { exitCode } = await this.git(
+      ["merge-base", "--is-ancestor", a, b],
+      { allowExitCodes: [1] }
+    );
+    return exitCode === 0;
+  }
+  /**
+   * `git format-patch --stdout <range>` — the full mbox-formatted patch
+   * series text (empty string when the range selects no commits).
+   */
+  async formatPatch(range) {
+    assertRange(range, "range");
+    const { stdout } = await this.git(["format-patch", "--stdout", range, "--"]);
+    return stdout;
+  }
+  /**
+   * Parent SHAs for a batch of commit SHAs via one
+   * `git rev-list --no-walk=unsorted --parents` pass. Root commits map to an
+   * empty array. Used to derive the kind:1617 `commit`/`parent-commit` tag
+   * pairs for exactly the commits a format-patch series carries.
+   */
+  async commitParents(shas) {
+    for (const sha of shas) assertFullSha(sha, "sha");
+    if (shas.length === 0) return /* @__PURE__ */ new Map();
+    const { stdout } = await this.git([
+      "rev-list",
+      "--no-walk=unsorted",
+      "--parents",
+      ...shas,
+      "--"
+    ]);
+    const parents = /* @__PURE__ */ new Map();
+    for (const line of stdout.split("\n")) {
+      if (!line) continue;
+      const [sha, ...rest] = line.split(" ");
+      if (!sha || !FULL_SHA_RE.test(sha) || rest.some((p) => !FULL_SHA_RE.test(p))) {
+        throw new GitError(
+          `unexpected rev-list --parents line: ${JSON.stringify(line)}`,
+          void 0,
+          ""
+        );
+      }
+      parents.set(sha, rest);
+    }
+    return parents;
+  }
+  /**
+   * Resolve a ref/revision to a full SHA via `git rev-parse --verify`.
+   * Throws {@link GitError} when the name doesn't resolve.
+   */
+  async resolveRef(name) {
+    assertRevision(name, "ref name");
+    const { stdout } = await this.git(["rev-parse", "--verify", "--quiet", name]);
+    const sha = stdout.trim();
+    if (!FULL_SHA_RE.test(sha)) {
+      throw new GitError(
+        `rev-parse --verify returned unexpected output for ${JSON.stringify(name)}: ${JSON.stringify(sha)}`,
+        void 0,
+        ""
+      );
+    }
+    return sha;
+  }
+};
+var NonFastForwardError = class extends Error {
+  constructor(refs) {
+    super(
+      `non-fast-forward update rejected for ${refs.map((r) => r.refname).join(", ")} \u2014 re-run with force to overwrite the remote ref(s)`
+    );
+    this.refs = refs;
+    this.name = "NonFastForwardError";
+  }
+  refs;
+};
+var OversizeObjectsError = class extends Error {
+  constructor(objects) {
+    super(
+      `${objects.length} object(s) exceed the ${MAX_OBJECT_SIZE} byte upload limit: ` + objects.map((o) => `${o.path ?? o.sha} (${o.size} bytes)`).join(", ")
+    );
+    this.objects = objects;
+    this.name = "OversizeObjectsError";
+  }
+  objects;
+};
+async function planPush(options) {
+  const { repoReader, remoteState, feeRates, repoId, force = false } = options;
+  const resolveMissing = options.resolveMissing ?? remoteState.resolveMissing.bind(remoteState);
+  const { head, refs: localRefs } = await repoReader.listRefs();
+  const localByName = new Map(localRefs.map((r) => [r.refname, r]));
+  let selected;
+  if (options.refs !== void 0) {
+    selected = options.refs.map((name) => {
+      const ref = localByName.get(name);
+      if (!ref) {
+        throw new Error(
+          `ref ${JSON.stringify(name)} does not exist locally (ref deletion is out of scope in v1)`
+        );
+      }
+      return ref;
+    });
+  } else {
+    selected = localRefs;
+  }
+  const refUpdates = [];
+  const rejected = [];
+  for (const ref of selected) {
+    const remoteSha = remoteState.refs.get(ref.refname) ?? null;
+    if (remoteSha === null) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "new" });
+      continue;
+    }
+    if (remoteSha === ref.sha) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "up-to-date" });
+      continue;
+    }
+    let fastForward = false;
+    try {
+      fastForward = await repoReader.isAncestor(remoteSha, ref.sha);
+    } catch (err) {
+      if (!(err instanceof GitError)) throw err;
+      fastForward = false;
+    }
+    if (fastForward) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "fast-forward" });
+    } else if (force) {
+      refUpdates.push({ refname: ref.refname, localSha: ref.sha, remoteSha, kind: "forced" });
+    } else {
+      rejected.push({ refname: ref.refname, localSha: ref.sha, remoteSha });
+    }
+  }
+  if (rejected.length > 0) throw new NonFastForwardError(rejected);
+  const updates = refUpdates.filter((u) => u.kind !== "up-to-date");
+  const wantTips = [...new Set(updates.map((u) => u.localSha))];
+  const haveTips = [...new Set(remoteState.refs.values())];
+  const delta = wantTips.length > 0 ? await repoReader.objectsBetweenWithPaths(wantTips, haveTips) : [];
+  const knownShaToTxId = new Map(remoteState.shaToTxId);
+  let candidates = delta.filter((o) => !knownShaToTxId.has(o.sha));
+  if (candidates.length > 0) {
+    const resolved = await resolveMissing(candidates.map((o) => o.sha));
+    for (const [sha, txId] of resolved) knownShaToTxId.set(sha, txId);
+    candidates = candidates.filter((o) => !knownShaToTxId.has(o.sha));
+  }
+  const pathBySha = new Map(candidates.map((c) => [c.sha, c.path]));
+  const { objects: stats, missing } = await repoReader.statObjects(
+    candidates.map((c) => c.sha)
+  );
+  if (missing.length > 0) {
+    throw new Error(
+      `objects vanished from the local repository during planning: ${missing.join(", ")}`
+    );
+  }
+  const oversize = [];
+  for (const stat2 of stats) {
+    if (stat2.size > MAX_OBJECT_SIZE) {
+      const path = pathBySha.get(stat2.sha);
+      oversize.push({ ...stat2, ...path ? { path } : {} });
+    }
+  }
+  if (oversize.length > 0) throw new OversizeObjectsError(oversize);
+  const tipShas = new Set(updates.map((u) => u.localSha));
+  const planned = stats.map((stat2) => {
+    const path = pathBySha.get(stat2.sha);
+    return { ...stat2, ...path ? { path } : {}, isRefTip: tipShas.has(stat2.sha) };
+  });
+  const objects = [
+    ...planned.filter((o) => !o.isRefTip),
+    ...planned.filter((o) => o.isRefTip)
+  ];
+  const newRefsMap = new Map(remoteState.refs);
+  for (const update of updates) newRefsMap.set(update.refname, update.localSha);
+  const headSymref = head && newRefsMap.has(head) ? head : remoteState.headSymref && newRefsMap.has(remoteState.headSymref) ? remoteState.headSymref : [...newRefsMap.keys()][0] ?? null;
+  const newRefs = {};
+  const headSha = headSymref ? newRefsMap.get(headSymref) : void 0;
+  if (headSymref && headSha) newRefs[headSymref] = headSha;
+  for (const [refname, sha] of newRefsMap) {
+    if (refname !== headSymref) newRefs[refname] = sha;
+  }
+  const announceNeeded = !remoteState.announced;
+  const totalObjectBytes = objects.reduce((sum, o) => sum + o.size, 0);
+  const uploadFee = BigInt(totalObjectBytes) * feeRates.uploadFeePerByte;
+  const eventCount = 1 + (announceNeeded ? 1 : 0);
+  const eventFees = BigInt(eventCount) * feeRates.eventFee;
+  return {
+    repoId,
+    refUpdates,
+    newRefs,
+    headSymref,
+    objects,
+    knownShaToTxId,
+    announceNeeded,
+    announcement: {
+      name: options.announcement?.name ?? repoId,
+      description: options.announcement?.description ?? ""
+    },
+    estimate: {
+      objectCount: objects.length,
+      totalObjectBytes,
+      uploadFee,
+      eventCount,
+      eventFees,
+      totalFee: uploadFee + eventFees
+    }
+  };
+}
+var READ_BATCH_SIZE = 100;
+async function executePush(options) {
+  const { plan, publisher, remoteState, repoReader, relayUrls } = options;
+  const merged = new Map([...remoteState.shaToTxId, ...plan.knownShaToTxId]);
+  const resultBySha = /* @__PURE__ */ new Map();
+  let totalFeePaid = 0n;
+  const pending = [];
+  for (const object of plan.objects) {
+    const knownTxId = merged.get(object.sha);
+    if (knownTxId !== void 0) {
+      resultBySha.set(object.sha, {
+        sha: object.sha,
+        txId: knownTxId,
+        feePaid: 0n,
+        skipped: true
+      });
+    } else {
+      pending.push(object);
+    }
+  }
+  for (let i = 0; i < pending.length; i += READ_BATCH_SIZE) {
+    const batch = pending.slice(i, i + READ_BATCH_SIZE);
+    const { objects: read, missing } = await repoReader.readObjects(
+      batch.map((o) => o.sha)
+    );
+    if (missing.length > 0) {
+      throw new Error(
+        `objects vanished from the local repository during push: ${missing.join(", ")}`
+      );
+    }
+    const bodyBySha = new Map(read.map((r) => [r.sha, r.body]));
+    for (const object of batch) {
+      const body = bodyBySha.get(object.sha);
+      if (!body) {
+        throw new Error(
+          `internal: cat-file returned no body for ${object.sha}`
+        );
+      }
+      const receipt = await publisher.uploadGitObject({
+        sha: object.sha,
+        type: object.type,
+        body,
+        repoId: plan.repoId
+      });
+      merged.set(object.sha, receipt.txId);
+      totalFeePaid += receipt.feePaid;
+      resultBySha.set(object.sha, {
+        sha: object.sha,
+        txId: receipt.txId,
+        feePaid: receipt.feePaid,
+        skipped: false
+      });
+    }
+  }
+  let announceReceipt = null;
+  if (plan.announceNeeded && !remoteState.announced) {
+    const announceEvent = buildRepoAnnouncement(
+      plan.repoId,
+      plan.announcement.name,
+      plan.announcement.description
+    );
+    announceReceipt = await publisher.publishEvent(announceEvent, relayUrls);
+    totalFeePaid += announceReceipt.feePaid;
+  }
+  const refsEvent = buildRepoRefs(
+    plan.repoId,
+    plan.newRefs,
+    Object.fromEntries(merged)
+  );
+  const refsReceipt = await publisher.publishEvent(refsEvent, relayUrls);
+  totalFeePaid += refsReceipt.feePaid;
+  const uploads = plan.objects.map((o) => {
+    const step = resultBySha.get(o.sha);
+    if (!step) {
+      throw new Error(`internal: no upload result recorded for ${o.sha}`);
+    }
+    return step;
+  });
+  return {
+    uploads,
+    announceReceipt,
+    refsReceipt,
+    arweaveMap: merged,
+    totalFeePaid
+  };
+}
+
+// ../git/dist/chunk-R3JVS6SX.js
+import { decode as decodeToon } from "@toon-format/toon";
+var ARWEAVE_FETCH_TIMEOUT_MS = 15e3;
+var ARWEAVE_GRAPHQL_URL = "https://arweave.net/graphql";
+var SHA_CACHE_MAX_SIZE = 1e4;
+var shaToTxIdCache = /* @__PURE__ */ new Map();
+function isValidGitSha(sha) {
+  return /^[0-9a-f]{40}$/i.test(sha);
+}
+function sanitizeGraphQLValue(value) {
+  return value.replace(/["\\\n\r\u0000-\u001f`]/g, "");
+}
+function shaCacheKey(sha, repo) {
+  return `${sha}:${repo}`;
+}
+function seedShaCache(mappings) {
+  const entries = mappings instanceof Map ? mappings.entries() : mappings;
+  for (const [key2, txId] of entries) {
+    if (shaToTxIdCache.size >= SHA_CACHE_MAX_SIZE) {
+      const firstKey = shaToTxIdCache.keys().next().value;
+      if (firstKey !== void 0) {
+        shaToTxIdCache.delete(firstKey);
+      }
+    }
+    shaToTxIdCache.set(key2, txId);
+  }
+}
+var ARWEAVE_TX_ID_RE = /^[a-zA-Z0-9_-]{43}$/;
+function isValidArweaveTxId(txId) {
+  return ARWEAVE_TX_ID_RE.test(txId);
+}
+async function resolveGitSha(sha, repo) {
+  if (!isValidGitSha(sha)) {
+    return null;
+  }
+  const cacheKey = shaCacheKey(sha, repo);
+  const cached = shaToTxIdCache.get(cacheKey);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const safeSha = sanitizeGraphQLValue(sha);
+  const safeRepo = sanitizeGraphQLValue(repo);
+  const query = `query {
+  transactions(tags: [
+    { name: "Git-SHA", values: ["${safeSha}"] },
+    { name: "Repo", values: ["${safeRepo}"] }
+  ]) {
+    edges { node { id } }
+  }
+}`;
+  try {
+    const response = await fetch(ARWEAVE_GRAPHQL_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query }),
+      signal: AbortSignal.timeout(ARWEAVE_FETCH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const json = await response.json();
+    const edges = json.data?.transactions?.edges;
+    if (!edges || edges.length === 0) {
+      return null;
+    }
+    const txId = edges[0]?.node?.id;
+    if (!txId || !isValidArweaveTxId(txId)) {
+      return null;
+    }
+    if (shaToTxIdCache.size >= SHA_CACHE_MAX_SIZE) {
+      const firstKey = shaToTxIdCache.keys().next().value;
+      if (firstKey !== void 0) {
+        shaToTxIdCache.delete(firstKey);
+      }
+    }
+    shaToTxIdCache.set(cacheKey, txId);
+    return txId;
+  } catch {
+    return null;
+  }
+}
+function isValidRelayUrl(url) {
+  return /^wss?:\/\//i.test(url);
+}
+var WS_OPEN = 1;
+function defaultWebSocketFactory2(url) {
+  const ctor = globalThis.WebSocket;
+  if (!ctor) {
+    throw new Error(
+      "No global WebSocket constructor (Node >= 22 required) \u2014 pass webSocketFactory"
+    );
+  }
+  return new ctor(url);
+}
+function decodeEventPayload(payload) {
+  if (payload !== null && typeof payload === "object") {
+    return payload;
+  }
+  if (typeof payload !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(payload);
+    if (parsed !== null && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch {
+  }
+  try {
+    return decodeToon(payload);
+  } catch {
+    return null;
+  }
+}
+function queryRelay(relayUrl, filter, timeoutMs, webSocketFactory) {
+  return new Promise((resolve2, reject) => {
+    const events = [];
+    const subId = `git-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    let ws;
+    let timeoutHandle;
+    let settled = false;
+    const settle = (outcome, error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeoutHandle);
+      try {
+        if (ws.readyState === WS_OPEN) {
+          ws.send(JSON.stringify(["CLOSE", subId]));
+        }
+        ws.close();
+      } catch {
+      }
+      if (outcome === "reject") {
+        reject(error);
+      } else {
+        resolve2(events);
+      }
+    };
+    if (!isValidRelayUrl(relayUrl)) {
+      reject(
+        new Error(
+          `Invalid relay URL protocol (must be ws:// or wss://): ${relayUrl}`
+        )
+      );
+      return;
+    }
+    try {
+      ws = webSocketFactory(relayUrl);
+    } catch (err) {
+      reject(new Error(`Failed to connect to relay ${relayUrl}: ${String(err)}`));
+      return;
+    }
+    timeoutHandle = setTimeout(() => {
+      settle("resolve");
+    }, timeoutMs);
+    ws.addEventListener("open", () => {
+      ws.send(JSON.stringify(["REQ", subId, filter]));
+    });
+    ws.addEventListener("message", (msgEvent) => {
+      try {
+        const msg = JSON.parse(String(msgEvent.data));
+        if (!Array.isArray(msg) || msg.length < 2) return;
+        const msgType = msg[0];
+        if (msgType === "EVENT" && msg[1] === subId && msg[2] !== void 0) {
+          const event = decodeEventPayload(msg[2]);
+          if (event) events.push(event);
+        } else if (msgType === "EOSE" && msg[1] === subId) {
+          settle("resolve");
+        }
+      } catch {
+      }
+    });
+    ws.addEventListener("error", (event) => {
+      const detail = typeof event === "object" && event !== null && "message" in event ? String(event.message) : "unknown";
+      settle(
+        "reject",
+        new Error(`WebSocket error connecting to ${relayUrl}: ${detail}`)
+      );
+    });
+    ws.addEventListener("close", () => {
+      settle("resolve");
+    });
+  });
+}
+function latestReplaceable(events) {
+  let winner = null;
+  for (const event of events) {
+    if (winner === null || event.created_at > winner.created_at || event.created_at === winner.created_at && event.id < winner.id) {
+      winner = event;
+    }
+  }
+  return winner;
+}
+function getTagValue(tags, name) {
+  const tag = tags.find((t) => t[0] === name);
+  return tag?.[1];
+}
+var MAX_REFS_PER_EVENT = 1e3;
+var SYMREF_PREFIX = "ref: ";
+function parseRefsEvent(event) {
+  const refs = /* @__PURE__ */ new Map();
+  const shaToTxId = /* @__PURE__ */ new Map();
+  let headSymref = null;
+  for (const tag of event.tags) {
+    const [tagName, v1, v2] = tag;
+    if (tagName === "r" && v1 && v2) {
+      if (v1 === "HEAD" && v2.startsWith(SYMREF_PREFIX)) {
+        headSymref = v2.slice(SYMREF_PREFIX.length);
+        continue;
+      }
+      if (refs.size >= MAX_REFS_PER_EVENT) continue;
+      refs.set(v1, v2);
+    } else if (tagName === "HEAD" && v1?.startsWith(SYMREF_PREFIX)) {
+      headSymref = v1.slice(SYMREF_PREFIX.length);
+    } else if (tagName === "arweave" && v1 && v2) {
+      shaToTxId.set(v1, v2);
+    }
+  }
+  return { refs, headSymref, shaToTxId };
+}
+async function fetchRemoteState(options) {
+  const {
+    relayUrls,
+    ownerPubkey,
+    repoId,
+    timeoutMs = 1e4,
+    resolveSha = resolveGitSha,
+    webSocketFactory = defaultWebSocketFactory2
+  } = options;
+  if (relayUrls.length === 0) {
+    throw new Error("fetchRemoteState: relayUrls must not be empty");
+  }
+  if (!ownerPubkey) {
+    throw new Error("fetchRemoteState: ownerPubkey is required");
+  }
+  if (!repoId) {
+    throw new Error("fetchRemoteState: repoId is required");
+  }
+  const filter = {
+    kinds: [REPOSITORY_ANNOUNCEMENT_KIND2, REPOSITORY_STATE_KIND],
+    authors: [ownerPubkey],
+    "#d": [repoId]
+  };
+  const results = await Promise.allSettled(
+    relayUrls.map((url) => queryRelay(url, filter, timeoutMs, webSocketFactory))
+  );
+  const failures = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (result.status === "rejected") {
+      failures.push(String(result.reason?.message ?? result.reason));
+      continue;
+    }
+    for (const event of result.value) {
+      if (event.pubkey !== ownerPubkey) continue;
+      if (getTagValue(event.tags, "d") !== repoId) continue;
+      if (typeof event.id === "string" && !byId.has(event.id)) {
+        byId.set(event.id, event);
+      }
+    }
+  }
+  if (failures.length === relayUrls.length) {
+    throw new Error(
+      `fetchRemoteState: all ${relayUrls.length} relay(s) failed: ${failures.join("; ")}`
+    );
+  }
+  const events = [...byId.values()];
+  const refsEvent = latestReplaceable(
+    events.filter((e) => e.kind === REPOSITORY_STATE_KIND)
+  );
+  const announceEvent = latestReplaceable(
+    events.filter((e) => e.kind === REPOSITORY_ANNOUNCEMENT_KIND2)
+  );
+  const { refs, headSymref, shaToTxId } = refsEvent ? parseRefsEvent(refsEvent) : {
+    refs: /* @__PURE__ */ new Map(),
+    headSymref: null,
+    shaToTxId: /* @__PURE__ */ new Map()
+  };
+  if (shaToTxId.size > 0) {
+    seedShaCache(
+      [...shaToTxId].map(
+        ([sha, txId]) => [shaCacheKey(sha, repoId), txId]
+      )
+    );
+  }
+  const name = announceEvent ? getTagValue(announceEvent.tags, "name") ?? null : null;
+  const description = announceEvent ? getTagValue(announceEvent.tags, "description") ?? announceEvent.content : null;
+  const relays = [];
+  if (announceEvent) {
+    for (const tag of announceEvent.tags) {
+      if (tag[0] === "relays") {
+        relays.push(...tag.slice(1).filter((url) => url.length > 0));
+      }
+    }
+  }
+  const resolveMissing = async (shas) => {
+    const resolved = /* @__PURE__ */ new Map();
+    const missing = [];
+    for (const sha of new Set(shas)) {
+      const known = shaToTxId.get(sha);
+      if (known !== void 0) {
+        resolved.set(sha, known);
+      } else {
+        missing.push(sha);
+      }
+    }
+    const lookups = await Promise.all(
+      missing.map(
+        async (sha) => [sha, await resolveSha(sha, repoId)]
+      )
+    );
+    for (const [sha, txId] of lookups) {
+      if (txId) resolved.set(sha, txId);
+    }
+    return resolved;
+  };
+  return {
+    announced: announceEvent !== null,
+    refs,
+    headSymref,
+    shaToTxId,
+    refsEvent,
+    announceEvent,
+    name,
+    description,
+    relays,
+    resolveMissing
+  };
+}
+
 // ../../node_modules/.pnpm/@toon-protocol+sdk@0.5.1_@toon-protocol+connector@3.13.0_mina-signer@3.1.0_typescript@5.9.3/node_modules/@toon-protocol/sdk/dist/chunk-UP2VWCW5.js
 var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
@@ -1406,6 +2474,10 @@ var ClientRunner = class {
   createRelay;
   log;
   targetsPath;
+  /** Remote-state reader for `/git/*` (injectable — opens relay sockets). */
+  fetchGitRemoteState;
+  /** Local-repo reader factory for `/git/*` (injectable for tests). */
+  createRepoReader;
   /**
    * Identity-level chain-read client. Reading your OWN on-chain wallet balance is
    * a pure (wallet keys + chain RPC) operation that has nothing to do with the
@@ -1448,6 +2520,8 @@ var ClientRunner = class {
     this.createClient = deps.createClient;
     this.log = deps.logger ?? (() => void 0);
     if (deps.targetsPath !== void 0) this.targetsPath = deps.targetsPath;
+    this.fetchGitRemoteState = deps.gitDeps?.fetchRemoteState ?? fetchRemoteState;
+    this.createRepoReader = deps.gitDeps?.createRepoReader ?? ((repoPath) => new GitRepoReader(repoPath));
     this.defaultBtpUrl = deps.config.toonClientConfig.btpUrl ?? "";
     this.defaultRelayUrl = deps.config.relayUrl;
     this.createRelay = deps.createRelay ?? ((opts) => new RelaySubscription({
@@ -2032,18 +3106,26 @@ var ClientRunner = class {
     return { relays, apexes };
   }
   // ── Paid operations ──────────────────────────────────────────────────────
-  /** Pay-to-write a single event through the selected (or default) apex. */
-  async publish(req) {
-    const apex = this.selectApex(req.btpUrl);
-    this.assertApexReady(apex);
+  /**
+   * Lazily open the apex channel on first paid write (deferred at bootstrap so
+   * the wallet can be funded after start, #69) and persist it for resume.
+   */
+  async ensureApexChannel(apex, destination) {
     let channelId = apex.apexChannelId;
     if (!channelId) {
-      channelId = await apex.client.openChannel(req.destination);
-      if (!req.destination || req.destination === apex.destination) {
+      channelId = await apex.client.openChannel(destination);
+      if (!destination || destination === apex.destination) {
         apex.apexChannelId = channelId;
         this.persistApexChannel(apex, channelId);
       }
     }
+    return channelId;
+  }
+  /** Pay-to-write a single event through the selected (or default) apex. */
+  async publish(req) {
+    const apex = this.selectApex(req.btpUrl);
+    this.assertApexReady(apex);
+    const channelId = await this.ensureApexChannel(apex, req.destination);
     const fee = req.fee !== void 0 ? BigInt(req.fee) : apex.feePerEvent;
     const claim = await apex.client.signBalanceProof(channelId, fee);
     const result = await apex.client.publishEvent(req.event, {
@@ -2276,7 +3358,7 @@ var ClientRunner = class {
    * toon_status means it is WIRED, not that its RPC is live). A stall here used
    * to block the whole control request until the client aborted, surfacing as a
    * misleading "relay/apex unreachable" timeout (#199). Bound each attempt well
-   * under the control-plane timeout and retry once so a single transient
+   * under the control API timeout and retry once so a single transient
    * provider stall FAST-FAILS with an honest "balances handler / provider
    * stalled" error instead of hanging.
    */
@@ -2387,6 +3469,238 @@ var ClientRunner = class {
       body: await res.text()
     };
   }
+  // ── Git write path (/git/*, epic #222 ticket #227) ────────────────────────
+  /**
+   * The daemon `Publisher` implementation (see @toon-protocol/git) for one
+   * apex. Maps the interface onto the runner's production paid-write
+   * machinery:
+   *
+   *  - `getFeeRates`: flat `apex.feePerEvent` per publish + the network
+   *    per-byte upload rate.
+   *  - `uploadGitObject`: kind:5094 store write with Git-SHA/Git-Type/Repo
+   *    tags (the proven seed-pipeline shape), signed with the daemon key,
+   *    paid via signBalanceProof on the apex channel, routed to the store
+   *    destination (`POST /store`); the Arweave txId is decoded from the
+   *    FULFILL HTTP envelope.
+   *  - `publishEvent`: sign with the daemon key + the standard paid publish
+   *    path (signBalanceProof → publishEvent → feePaid). The daemon owns its
+   *    write routing (config-seeded relay via the apex), so the advisory
+   *    `relayUrls` list is not consulted here — remote-state reads DO use it.
+   */
+  gitPublisher(apex) {
+    return {
+      getFeeRates: async () => ({
+        uploadFeePerByte: UPLOAD_FEE_PER_BYTE,
+        eventFee: apex.feePerEvent
+      }),
+      uploadGitObject: (upload) => this.gitUploadObject(apex, upload),
+      publishEvent: (event) => this.gitPublishEvent(apex, event)
+    };
+  }
+  /** Upload one git object body as a paid kind:5094 store write. */
+  async gitUploadObject(apex, upload) {
+    const channelId = await this.ensureApexChannel(apex);
+    const fee = BigInt(upload.body.length) * UPLOAD_FEE_PER_BYTE;
+    const claim = await apex.client.signBalanceProof(channelId, fee);
+    const signed = await apex.client.signEvent({
+      kind: 5094,
+      content: "",
+      tags: [
+        ["i", upload.body.toString("base64"), "blob"],
+        ["bid", fee.toString(), "usdc"],
+        ["output", "application/octet-stream"],
+        ["Git-SHA", upload.sha],
+        ["Git-Type", upload.type],
+        ["Repo", upload.repoId]
+      ],
+      created_at: nowSeconds()
+    });
+    const result = await apex.client.publishEvent(signed, {
+      destination: this.config.storeDestination,
+      claim,
+      ilpAmount: fee,
+      // The store/DVM backend serves POST /store (not the relay's /write).
+      proxyPath: "/store"
+    });
+    if (!result.success) {
+      throw new PublishRejectedError(
+        `git object ${upload.sha} upload failed (store ${this.config.storeDestination}): ${result.error ?? "store rejected the write"}`
+      );
+    }
+    if (!result.data) {
+      throw new PublishRejectedError(
+        `git object ${upload.sha} upload FULFILL carried no data \u2014 expected the Arweave tx ID`
+      );
+    }
+    let txId;
+    try {
+      txId = extractArweaveTxId(result.data);
+    } catch (err) {
+      throw new PublishRejectedError(
+        `git object ${upload.sha} upload: ${errMsg2(err)}`
+      );
+    }
+    return { txId, feePaid: fee };
+  }
+  /** Sign (daemon key) + pay-to-publish one NIP-34 event via the apex. */
+  async gitPublishEvent(apex, event) {
+    const signed = await apex.client.signEvent(event);
+    const pub = await this.publish({
+      event: signed,
+      ...apex.btpUrl ? { btpUrl: apex.btpUrl } : {}
+    });
+    return { eventId: pub.eventId, feePaid: BigInt(pub.feePaid) };
+  }
+  /**
+   * Plan a push: read the local repo + the remote NIP-34 state, classify ref
+   * updates, compute the object delta, and price it. Shared by
+   * estimate (returns the plan) and push (executes it).
+   */
+  async planGitPush(apex, req) {
+    await assertRepoPath(req.repoPath);
+    if (typeof req.repoId !== "string" || req.repoId === "") {
+      throw new InvalidPayloadError("repoId is required.");
+    }
+    const relayUrls = req.relayUrls && req.relayUrls.length > 0 ? req.relayUrls : [this.defaultRelayUrl];
+    const ownerPubkey = apex.client.getPublicKey();
+    const repoReader = this.createRepoReader(req.repoPath);
+    const remoteState = await this.fetchGitRemoteState({
+      relayUrls,
+      ownerPubkey,
+      repoId: req.repoId
+    });
+    const publisher = this.gitPublisher(apex);
+    const feeRates = await publisher.getFeeRates();
+    const plan = await planPush({
+      repoReader,
+      remoteState,
+      feeRates,
+      repoId: req.repoId,
+      ...req.refspecs !== void 0 ? { refs: req.refspecs } : {},
+      ...req.force !== void 0 ? { force: req.force } : {},
+      ...req.announcement !== void 0 ? { announcement: req.announcement } : {}
+    });
+    return { plan, remoteState, repoReader, relayUrls, publisher };
+  }
+  /** Plan + price a push WITHOUT paying (backs `POST /git/estimate`). */
+  async gitEstimate(req) {
+    const apex = this.selectApex();
+    this.assertApexReady(apex);
+    const { plan } = await this.planGitPush(apex, req);
+    return serializePushPlan2(plan);
+  }
+  /** Plan + EXECUTE a push: paid uploads + paid publishes (`POST /git/push`). */
+  async gitPush(req) {
+    if (req.confirm !== true) {
+      throw new InvalidPayloadError(
+        "a push uploads objects to Arweave and publishes events \u2014 permanent and paid. Run /git/estimate first, then set confirm: true to proceed."
+      );
+    }
+    const apex = this.selectApex();
+    this.assertApexReady(apex);
+    const { plan, remoteState, repoReader, relayUrls, publisher } = await this.planGitPush(apex, req);
+    const result = await executePush({
+      plan,
+      publisher,
+      remoteState,
+      repoReader,
+      relayUrls
+    });
+    return serializePushResult2(plan, result);
+  }
+  /** Build, sign, and pay-to-publish a kind:1621 issue. */
+  async gitIssue(req) {
+    const addr = validateRepoAddr(req.repoAddr);
+    assertNonEmptyString(req.title, "title");
+    assertNonEmptyString(req.body, "body");
+    const event = buildIssue(
+      addr.ownerPubkey,
+      addr.repoId,
+      req.title,
+      req.body,
+      req.labels ?? []
+    );
+    return this.gitPublishSigned(event);
+  }
+  /** Build, sign, and pay-to-publish a kind:1622 comment on an issue/patch. */
+  async gitComment(req) {
+    const addr = validateRepoAddr(req.repoAddr);
+    assertNonEmptyString(req.rootEventId, "rootEventId");
+    assertNonEmptyString(req.body, "body");
+    const event = buildComment(
+      addr.ownerPubkey,
+      addr.repoId,
+      req.rootEventId,
+      req.parentAuthorPubkey ?? addr.ownerPubkey,
+      req.body,
+      req.marker ?? "root"
+    );
+    return this.gitPublishSigned(event);
+  }
+  /**
+   * Build, sign, and pay-to-publish a kind:1617 patch. Content is either the
+   * supplied `patchText` or real `git format-patch --stdout <range>` output
+   * from a local repository — exactly one source must be given.
+   */
+  async gitPatch(req) {
+    const addr = validateRepoAddr(req.repoAddr);
+    assertNonEmptyString(req.title, "title");
+    const hasText = typeof req.patchText === "string" && req.patchText !== "";
+    const hasRange = typeof req.repoPath === "string" && req.repoPath !== "" && typeof req.range === "string" && req.range !== "";
+    if (hasText === hasRange) {
+      throw new InvalidPayloadError(
+        "exactly one of patchText | repoPath+range is required."
+      );
+    }
+    let content;
+    if (hasRange) {
+      await assertRepoPath(req.repoPath);
+      content = await this.createRepoReader(req.repoPath).formatPatch(
+        req.range
+      );
+      if (content === "") {
+        throw new InvalidPayloadError(
+          `range ${JSON.stringify(req.range)} selects no commits \u2014 nothing to publish.`
+        );
+      }
+    } else {
+      content = req.patchText;
+    }
+    const event = buildPatch(
+      addr.ownerPubkey,
+      addr.repoId,
+      req.title,
+      req.commits ?? [],
+      req.branch,
+      content
+    );
+    return this.gitPublishSigned(event);
+  }
+  /** Build, sign, and pay-to-publish a kind:1630-1633 status event. */
+  async gitStatus(req) {
+    const addr = validateRepoAddr(req.repoAddr);
+    assertNonEmptyString(req.targetEventId, "targetEventId");
+    const kind = STATUS_KIND_BY_VALUE[req.status];
+    if (kind === void 0) {
+      throw new InvalidPayloadError(
+        "status must be one of open | applied | closed | draft."
+      );
+    }
+    const event = buildStatus(req.targetEventId, kind, req.targetPubkey);
+    event.tags.push([
+      "a",
+      `${REPOSITORY_ANNOUNCEMENT_KIND}:${addr.ownerPubkey}:${addr.repoId}`
+    ]);
+    return this.gitPublishSigned(event);
+  }
+  /** Sign a built NIP-34 event with the daemon key and pay-to-publish it. */
+  async gitPublishSigned(event) {
+    const apex = this.selectApex();
+    this.assertApexReady(apex);
+    const signed = await apex.client.signEvent(event);
+    const pub = await this.publish({ event: signed });
+    return { ...pub, kind: event.kind };
+  }
   /** Graceful teardown: close every relay + stop every apex client. */
   async stop() {
     if (this.stopped) return;
@@ -2459,6 +3773,89 @@ var BalancesUnavailableError = class extends Error {
     if (providerError !== void 0) this.providerError = providerError;
   }
 };
+var UPLOAD_FEE_PER_BYTE = 10n;
+var STATUS_KIND_BY_VALUE = {
+  open: STATUS_OPEN_KIND,
+  applied: STATUS_APPLIED_KIND,
+  closed: STATUS_CLOSED_KIND,
+  draft: STATUS_DRAFT_KIND
+};
+async function assertRepoPath(repoPath) {
+  if (typeof repoPath !== "string" || repoPath === "") {
+    throw new InvalidPayloadError("repoPath is required.");
+  }
+  let stats;
+  try {
+    stats = await stat(resolve(repoPath));
+  } catch {
+    throw new InvalidPayloadError(`repoPath does not exist: ${repoPath}`);
+  }
+  if (!stats.isDirectory()) {
+    throw new InvalidPayloadError(`repoPath is not a directory: ${repoPath}`);
+  }
+}
+function assertNonEmptyString(value, what) {
+  if (typeof value !== "string" || value === "") {
+    throw new InvalidPayloadError(`${what} is required.`);
+  }
+}
+function validateRepoAddr(addr) {
+  if (!addr || typeof addr.ownerPubkey !== "string" || !/^[0-9a-f]{64}$/.test(addr.ownerPubkey)) {
+    throw new InvalidPayloadError(
+      "repoAddr.ownerPubkey must be a 64-char lowercase hex Nostr pubkey."
+    );
+  }
+  if (typeof addr.repoId !== "string" || addr.repoId === "") {
+    throw new InvalidPayloadError("repoAddr.repoId is required.");
+  }
+  return addr;
+}
+function serializePushPlan2(plan) {
+  return {
+    repoId: plan.repoId,
+    refUpdates: plan.refUpdates,
+    newRefs: plan.newRefs,
+    headSymref: plan.headSymref,
+    objects: plan.objects,
+    knownShaToTxId: Object.fromEntries(plan.knownShaToTxId),
+    announceNeeded: plan.announceNeeded,
+    announcement: plan.announcement,
+    estimate: serializeFeeEstimate2(plan)
+  };
+}
+function serializeFeeEstimate2(plan) {
+  return {
+    objectCount: plan.estimate.objectCount,
+    totalObjectBytes: plan.estimate.totalObjectBytes,
+    uploadFee: plan.estimate.uploadFee.toString(),
+    eventCount: plan.estimate.eventCount,
+    eventFees: plan.estimate.eventFees.toString(),
+    totalFee: plan.estimate.totalFee.toString()
+  };
+}
+function serializePushResult2(plan, result) {
+  return {
+    repoId: plan.repoId,
+    refUpdates: plan.refUpdates,
+    uploads: result.uploads.map((u) => ({
+      sha: u.sha,
+      txId: u.txId,
+      feePaid: u.feePaid.toString(),
+      skipped: u.skipped
+    })),
+    announceReceipt: result.announceReceipt ? {
+      eventId: result.announceReceipt.eventId,
+      feePaid: result.announceReceipt.feePaid.toString()
+    } : null,
+    refsReceipt: {
+      eventId: result.refsReceipt.eventId,
+      feePaid: result.refsReceipt.feePaid.toString()
+    },
+    arweaveMap: Object.fromEntries(result.arweaveMap),
+    totalFeePaid: result.totalFeePaid.toString(),
+    estimate: serializeFeeEstimate2(plan)
+  };
+}
 function nowSeconds() {
   return Math.floor(Date.now() / 1e3);
 }
@@ -2747,6 +4144,107 @@ function registerRoutes(app, runner) {
       return mapError(reply, err);
     }
   });
+  app.post("/git/estimate", async (req, reply) => {
+    const body = req.body;
+    if (!body || !isNonEmptyString(body.repoPath) || !isNonEmptyString(body.repoId)) {
+      return sendError(reply, 400, "invalid_git_request", {
+        detail: "body.repoPath (local repository path) and body.repoId are required."
+      });
+    }
+    try {
+      return await runner.gitEstimate(body);
+    } catch (err) {
+      return mapGitError(reply, err);
+    }
+  });
+  app.post("/git/push", async (req, reply) => {
+    const body = req.body;
+    if (!body || !isNonEmptyString(body.repoPath) || !isNonEmptyString(body.repoId)) {
+      return sendError(reply, 400, "invalid_git_request", {
+        detail: "body.repoPath (local repository path) and body.repoId are required."
+      });
+    }
+    try {
+      return await runner.gitPush(body);
+    } catch (err) {
+      return mapGitError(reply, err);
+    }
+  });
+  app.post("/git/issue", async (req, reply) => {
+    const body = req.body;
+    if (!body || !body.repoAddr || !isNonEmptyString(body.title) || !isNonEmptyString(body.body)) {
+      return sendError(reply, 400, "invalid_git_request", {
+        detail: "body.repoAddr ({ ownerPubkey, repoId }), body.title, and body.body are required."
+      });
+    }
+    try {
+      return await runner.gitIssue(body);
+    } catch (err) {
+      return mapGitError(reply, err);
+    }
+  });
+  app.post("/git/comment", async (req, reply) => {
+    const body = req.body;
+    if (!body || !body.repoAddr || !isNonEmptyString(body.rootEventId) || !isNonEmptyString(body.body)) {
+      return sendError(reply, 400, "invalid_git_request", {
+        detail: "body.repoAddr ({ ownerPubkey, repoId }), body.rootEventId, and body.body are required."
+      });
+    }
+    try {
+      return await runner.gitComment(body);
+    } catch (err) {
+      return mapGitError(reply, err);
+    }
+  });
+  app.post("/git/patch", async (req, reply) => {
+    const body = req.body;
+    if (!body || !body.repoAddr || !isNonEmptyString(body.title)) {
+      return sendError(reply, 400, "invalid_git_request", {
+        detail: "body.repoAddr ({ ownerPubkey, repoId }) and body.title are required (plus exactly one of patchText | repoPath+range)."
+      });
+    }
+    try {
+      return await runner.gitPatch(body);
+    } catch (err) {
+      return mapGitError(reply, err);
+    }
+  });
+  app.post("/git/status", async (req, reply) => {
+    const body = req.body;
+    if (!body || !body.repoAddr || !isNonEmptyString(body.targetEventId) || !isNonEmptyString(body.status)) {
+      return sendError(reply, 400, "invalid_git_request", {
+        detail: "body.repoAddr ({ ownerPubkey, repoId }), body.targetEventId, and body.status (open | applied | closed | draft) are required."
+      });
+    }
+    try {
+      return await runner.gitStatus(body);
+    } catch (err) {
+      return mapGitError(reply, err);
+    }
+  });
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function mapGitError(reply, err) {
+  if (err instanceof NonFastForwardError) {
+    return reply.status(409).send({
+      error: "non_fast_forward",
+      detail: err.message,
+      refs: err.refs
+    });
+  }
+  if (err instanceof OversizeObjectsError) {
+    return reply.status(413).send({
+      error: "oversize_objects",
+      detail: err.message,
+      objects: err.objects
+    });
+  }
+  if (err instanceof GitError) {
+    return sendError(reply, 400, "git_error", { detail: err.message });
+  }
+  return mapError(reply, err);
 }
 function isSignedEvent(event) {
   if (typeof event !== "object" || event === null) return false;
@@ -2785,10 +4283,27 @@ function mapError(reply, err) {
   if (err instanceof Error && err.name === "SettleTooEarlyError") {
     return sendError(reply, 425, "settle_too_early", { detail: err.message, retryable: true });
   }
+  const funding = findChannelFundingError(err);
+  if (funding) {
+    return sendError(reply, 402, "insufficient_gas", {
+      detail: funding.message,
+      retryable: true
+    });
+  }
   return sendError(reply, 500, "internal_error", {
     detail: err instanceof Error ? err.message : String(err)
   });
 }
+function findChannelFundingError(err) {
+  let cur = err;
+  for (let i = 0; i < 10 && cur != null; i++) {
+    if (cur instanceof Error && cur.name === "ChannelFundingError") {
+      return cur;
+    }
+    cur = cur instanceof Error ? cur.cause : void 0;
+  }
+  return void 0;
+}
 function sendError(reply, status, error, extra = {}) {
   return reply.status(status).send({
     error,
@@ -2807,4 +4322,4 @@ export {
   PublishRejectedError,
   registerRoutes
 };
-//# sourceMappingURL=chunk-HLATGATX.js.map
+//# sourceMappingURL=chunk-GQENVTED.js.map