mergestorm 0.3.63 → 0.3.66

package/dist/gh.d.ts

@@ -10,7 +10,6 @@ export type GhResult = {
 };
 export type GhRunner = (args: string[], input?: string) => GhResult;
 export type GithubApi = "graphql" | "rest";
-export declare const GITHUB_API_ENV = "MERGESTORM_GITHUB_API";
 export declare function githubApiFromEnv(env?: NodeJS.ProcessEnv): GithubApi;
 export declare function isGraphqlEndpointBlocked(text: string): boolean;
 export declare class GraphqlBlockedError extends CommandError {
@@ -34,7 +33,6 @@ export declare function findOpenPrNumber(owner: string, repo: string, headBranch
     api?: GithubApi;
     gh?: GhRunner;
 }): number | null;
-export declare function findOpenPrNumberViaRest(owner: string, repo: string, headBranch: string, gh: GhRunner): number | null;
 export type NewPr = {
     base: string;
     head: string;
@@ -63,13 +61,11 @@ type GraphqlSpawn = (command: string, args: string[], options: {
     encoding: "utf8";
     input: string;
 }) => GraphqlSpawnResult;
-export declare const CREATE_PR_BATCH_SIZE = 5;
 export declare function ghGraphql(request: GraphqlRequest, cwd?: string, spawn?: GraphqlSpawn): GraphqlResponse;
 export declare function chunkCreatePrs<T>(items: readonly T[], size?: number): T[][];
 export declare function buildCreatePrsMutation(repositoryId: string, prs: readonly NewPr[]): GraphqlRequest;
 export declare function fetchRepositoryId(owner: string, repo: string, graphql: GraphqlRunner): string;
 export declare function createPrsOnRepository(repositoryId: string, prs: readonly NewPr[], graphql: GraphqlRunner): number[];
-export declare function createPrsViaRest(owner: string, repo: string, prs: readonly NewPr[], gh: GhRunner, opened?: readonly number[]): number[];
 export declare function createPrs(input: {
     owner: string;
     repo: string;

package/dist/gh.js

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { CommandError } from "./errors.js";
-export const GITHUB_API_ENV = "MERGESTORM_GITHUB_API";
+const GITHUB_API_ENV = "MERGESTORM_GITHUB_API";
 export function githubApiFromEnv(env = process.env) {
     return env[GITHUB_API_ENV]?.trim().toLowerCase() === "rest" ? "rest" : "graphql";
 }
@@ -83,7 +83,7 @@ function findOpenPrNumberViaGraphql(owner, repo, headBranch, gh) {
     }
     return firstPrNumber(res.stdout);
 }
-export function findOpenPrNumberViaRest(owner, repo, headBranch, gh) {
+function findOpenPrNumberViaRest(owner, repo, headBranch, gh) {
     const res = gh([
         "api",
         "-X",
@@ -111,7 +111,7 @@ function firstPrNumber(stdout) {
         throw new CommandError(`Failed to parse PR list response: ${e instanceof Error ? e.message : String(e)}`);
     }
 }
-export const CREATE_PR_BATCH_SIZE = 5;
+const CREATE_PR_BATCH_SIZE = 5;
 export function ghGraphql(request, cwd = process.cwd(), spawn = spawnSync) {
     const result = spawn("gh", ["api", "graphql", "--input", "-"], {
         cwd,
@@ -231,7 +231,7 @@ function restErrorText(res) {
         return body.message.trim();
     return res.stderr;
 }
-export function createPrsViaRest(owner, repo, prs, gh, opened = []) {
+function createPrsViaRest(owner, repo, prs, gh, opened = []) {
     const numbers = [...opened];
     for (const pr of prs.slice(numbers.length)) {
         const res = gh(["api", "-X", "POST", `repos/${owner}/${repo}/pulls`, "--input", "-"], JSON.stringify({ title: pr.title, head: pr.head, base: pr.base, body: pr.body }));

package/dist/git.d.ts

@@ -1,4 +1,4 @@
-export declare function git(args: string[], cwd?: string): string;
+export declare function git(args: string[], cwd?: string, env?: NodeJS.ProcessEnv): string;
 /** Parse `origin` remote into GitHub owner/repo when possible. */
 export declare function parseGithubOriginRepo(cwd?: string): {
     owner: string;

package/dist/git.js

@@ -2,9 +2,9 @@ import { spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
-export function git(args, cwd = process.cwd()) {
+export function git(args, cwd = process.cwd(), env) {
     try {
-        const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+        const result = spawnSync("git", args, { cwd, encoding: "utf8", env });
         if (result.status !== 0) {
             throw new Error(result.stderr?.trim() || `git ${args.join(" ")} failed`);
         }

package/dist/memory-api.d.ts

@@ -0,0 +1,74 @@
+import { type Config } from "./config.js";
+export declare const MEMORY_MODES: readonly ["off", "on_request", "all"];
+export declare const MEMORY_SCOPES: readonly ["user", "repo"];
+export declare const MEMORY_KINDS: readonly ["rule", "style", "preference", "fact", "project"];
+export declare const MEMORY_SEARCH_LIMIT_MAX = 20;
+export type MemoryMode = (typeof MEMORY_MODES)[number];
+export type MemoryScope = (typeof MEMORY_SCOPES)[number];
+export type MemoryKind = (typeof MEMORY_KINDS)[number];
+export type MemoryItem = {
+    id: string;
+    scope: MemoryScope;
+    repo: string | null;
+    kind: MemoryKind;
+    text: string;
+    source: string | null;
+    source_url: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export type MemoryList = {
+    memory_mode: MemoryMode;
+    items: MemoryItem[];
+};
+export type MemorySearch = {
+    memory_mode: MemoryMode;
+    rules: MemoryItem[];
+    items: MemoryItem[];
+    total: number;
+};
+export type MemorySaved = {
+    id: string;
+    merged: boolean;
+};
+export type MemoryUpdated = {
+    id: string;
+    text: string;
+    kind?: MemoryKind;
+};
+export declare function memoryChatId(value?: string | null | undefined): string | null;
+export declare function isMemoryMode(value: unknown): value is MemoryMode;
+export declare function isMemoryKind(value: unknown): value is MemoryKind;
+export declare function isMemoryScope(value: unknown): value is MemoryScope;
+export declare function listMemories(filter?: {
+    scope?: MemoryScope;
+    repo?: string;
+    kind?: MemoryKind;
+}, cfg?: Config): Promise<MemoryList>;
+export declare function searchMemories(input: {
+    query: string;
+    repo?: string;
+    limit?: number;
+    chatId?: string | null;
+}, cfg?: Config): Promise<MemorySearch>;
+export declare function saveMemory(input: {
+    text: string;
+    kind: MemoryKind;
+    repo?: string | null;
+    chatId?: string | null;
+    keepBoth?: boolean;
+}, cfg?: Config): Promise<MemorySaved>;
+export declare function updateMemory(id: string, change: {
+    text: string;
+    kind?: MemoryKind;
+}, cfg?: Config): Promise<MemoryUpdated>;
+export declare function deleteMemory(id: string, cfg?: Config): Promise<{
+    id: string;
+    deleted: true;
+}>;
+export declare function getMemoryMode(cfg?: Config): Promise<{
+    memory_mode: MemoryMode;
+}>;
+export declare function setMemoryMode(mode: MemoryMode, cfg?: Config): Promise<{
+    memory_mode: MemoryMode;
+}>;

package/dist/memory-api.js

@@ -0,0 +1,69 @@
+import { apiFetch } from "./api.js";
+import { loadConfig } from "./config.js";
+import { CommandError, REVIEW_EXIT, rateLimitedMessage } from "./errors.js";
+export const MEMORY_MODES = ["off", "on_request", "all"];
+export const MEMORY_SCOPES = ["user", "repo"];
+export const MEMORY_KINDS = ["rule", "style", "preference", "fact", "project"];
+export const MEMORY_SEARCH_LIMIT_MAX = 20;
+const CHAT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export function memoryChatId(value = process.env.MERGESTORM_CHAT_ID) {
+    const trimmed = value?.trim() ?? "";
+    return CHAT_ID.test(trimmed) ? trimmed.toLowerCase() : null;
+}
+export function isMemoryMode(value) {
+    return typeof value === "string" && MEMORY_MODES.includes(value);
+}
+export function isMemoryKind(value) {
+    return typeof value === "string" && MEMORY_KINDS.includes(value);
+}
+export function isMemoryScope(value) {
+    return typeof value === "string" && MEMORY_SCOPES.includes(value);
+}
+const KNOWN_CODES = new Set(["invalid_input", "not_found", "memory_off", "memory_full", "memory_similar", "memory_unavailable", "payload_too_large"]);
+function memoryFailure(status, body, retryAfterSeconds, action) {
+    const row = (body && typeof body === "object" ? body : {});
+    if (status === 429 || row.error === "rate_limited") {
+        return new CommandError(rateLimitedMessage(retryAfterSeconds), REVIEW_EXIT.rate_limited, "rate_limited", retryAfterSeconds !== undefined ? { retryAfterSeconds } : undefined);
+    }
+    const message = typeof row.message === "string" && row.message ? row.message : null;
+    const code = typeof row.error === "string" && KNOWN_CODES.has(row.error) ? row.error : undefined;
+    if (status === 404 && !code)
+        return new CommandError("This Mergestorm server does not manage memories yet.", 1, "not_found");
+    return new CommandError(message ?? `${action} (HTTP ${status})`, 1, code);
+}
+async function call(cfg, route, init, ok, action) {
+    const { status, body, retryAfterSeconds } = await apiFetch(cfg ?? (await loadConfig()), route, init);
+    if (!ok.includes(status))
+        throw memoryFailure(status, body, retryAfterSeconds, action);
+    return body;
+}
+function query(params) {
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params))
+        if (value !== undefined && value !== null && value !== "")
+            search.set(key, String(value));
+    const text = search.toString();
+    return text ? `?${text}` : "";
+}
+export function listMemories(filter = {}, cfg) {
+    return call(cfg, `/api/v1/memories${query(filter)}`, {}, [200], "Could not list memories");
+}
+export function searchMemories(input, cfg) {
+    return call(cfg, `/api/v1/memories/search${query({ query: input.query, repo: input.repo, limit: input.limit, chat_id: input.chatId })}`, {}, [200], "Could not search memories");
+}
+export function saveMemory(input, cfg) {
+    const json = { text: input.text, kind: input.kind, ...(input.repo ? { repo: input.repo } : {}), ...(input.chatId ? { chat_id: input.chatId } : {}), ...(input.keepBoth ? { keep_both: true } : {}) };
+    return call(cfg, "/api/v1/memories", { method: "POST", json }, [200, 201], "Could not save the memory");
+}
+export function updateMemory(id, change, cfg) {
+    return call(cfg, `/api/v1/memories/${encodeURIComponent(id)}`, { method: "PATCH", json: change }, [200], "Could not update the memory");
+}
+export function deleteMemory(id, cfg) {
+    return call(cfg, `/api/v1/memories/${encodeURIComponent(id)}`, { method: "DELETE" }, [200], "Could not delete the memory");
+}
+export function getMemoryMode(cfg) {
+    return call(cfg, "/api/v1/memories/mode", {}, [200], "Could not read the memory mode");
+}
+export function setMemoryMode(mode, cfg) {
+    return call(cfg, "/api/v1/memories/mode", { method: "PUT", json: { memory_mode: mode } }, [200], "Could not set the memory mode");
+}

package/dist/node-version.d.ts

@@ -1,5 +1,3 @@
-/** Mergestorm CLI requires Node 22+ (matches package.json engines). */
-export declare const MIN_NODE_MAJOR = 22;
 /** Parse major version from a Node version string (e.g. "22.22.3" → 22). */
 export declare function nodeMajor(version?: string): number;
 /**

package/dist/node-version.js

@@ -1,5 +1,5 @@
 /** Mergestorm CLI requires Node 22+ (matches package.json engines). */
-export const MIN_NODE_MAJOR = 22;
+const MIN_NODE_MAJOR = 22;
 /** Parse major version from a Node version string (e.g. "22.22.3" → 22). */
 export function nodeMajor(version = process.versions.node) {
     const major = Number.parseInt(version.split(".")[0] ?? "", 10);

package/dist/pr-body.d.ts

@@ -6,3 +6,7 @@
  * Turn `git log -1 --format=%B` output into a non-empty PR description.
  */
 export declare function buildPrBodyFromCommit(fullMessage: string): string;
+export declare function linkedIssueNumbers(repo: {
+    owner: string;
+    repo: string;
+}, ...texts: string[]): number[];

package/dist/pr-body.js

@@ -49,6 +49,21 @@ export function buildPrBodyFromCommit(fullMessage) {
     }
     return parts.join("\n") + "\n";
 }
+const LINKED_ISSUE_RE = /(?<![\w/#.-])(?:fix(?:es|ed)?|close[sd]?|resolve[sd]?)\s*:?\s+(?:([\w.-]+)\/([\w.-]+))?#(\d+)\b/gi;
+export function linkedIssueNumbers(repo, ...texts) {
+    const numbers = new Set();
+    const same = `${repo.owner}/${repo.repo}`.toLowerCase();
+    for (const text of texts) {
+        for (const match of text.matchAll(LINKED_ISSUE_RE)) {
+            if (match[1] && `${match[1]}/${match[2]}`.toLowerCase() !== same)
+                continue;
+            const n = Number(match[3]);
+            if (Number.isSafeInteger(n) && n > 0)
+                numbers.add(n);
+        }
+    }
+    return [...numbers].sort((a, b) => a - b);
+}
 function uniqueTrailers(trailers) {
     const seen = new Set();
     const out = [];

package/dist/repo-identity.d.ts

@@ -1,3 +1,5 @@
+/** Classify git "not a repo" failures once at the boundary; callers match on code. */
+export declare function isNotARepoGitError(detail: string): boolean;
 export declare function gitTopLevel(cwd?: string): string;
 /**
  * Each worktree has its own authoring state.
@@ -5,5 +7,4 @@ export declare function gitTopLevel(cwd?: string): string;
  */
 export declare function stableRepoId(cwd?: string): string;
 export declare function cliStacksRoot(): string;
-export declare function repoStateDir(cwd?: string, stacksRoot?: string): string;
 export declare function stackMetaPath(cwd?: string, stacksRoot?: string): string;

package/dist/repo-identity.js

@@ -5,16 +5,20 @@ import { mergestormHome } from "./config.js";
 import { CommandError } from "./errors.js";
 import { git } from "./git.js";
 /** Classify git "not a repo" failures once at the boundary; callers match on code. */
+export function isNotARepoGitError(detail) {
+    return /not a git repository|gitfile does not point to a valid repository/i.test(detail);
+}
+const classifierEnv = { ...process.env, LC_ALL: "C" };
 function rethrowIfNotARepo(err) {
     const detail = err instanceof Error ? err.message : String(err);
-    if (/not a git repository/i.test(detail)) {
+    if (isNotARepoGitError(detail)) {
         throw new CommandError(detail, 1, "not_a_repo");
     }
     throw err;
 }
 export function gitTopLevel(cwd = process.cwd()) {
     try {
-        return realpathSync(git(["rev-parse", "--show-toplevel"], cwd).trim());
+        return realpathSync(git(["rev-parse", "--show-toplevel"], cwd, classifierEnv).trim());
     }
     catch (err) {
         rethrowIfNotARepo(err);
@@ -27,7 +31,7 @@ export function gitTopLevel(cwd = process.cwd()) {
 export function stableRepoId(cwd = process.cwd()) {
     let raw;
     try {
-        raw = git(["rev-parse", "--git-dir"], cwd).trim();
+        raw = git(["rev-parse", "--git-dir"], cwd, classifierEnv).trim();
     }
     catch (err) {
         rethrowIfNotARepo(err);
@@ -41,7 +45,7 @@ export function stableRepoId(cwd = process.cwd()) {
 export function cliStacksRoot() {
     return path.join(mergestormHome(), "stacks");
 }
-export function repoStateDir(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+function repoStateDir(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     return path.join(stacksRoot, stableRepoId(cwd));
 }
 export function stackMetaPath(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {

package/dist/server-publish.d.ts

@@ -1,33 +1,18 @@
-import { getStackPublication, submitStackPublication, type StackPublication, type StackPublicationChange, type StackPublicationCommit, type StackPublicationIdentity, type StackPublicationStatus } from "./api.js";
+import { getStackPublication, submitStackPublication, type StackPublication, type StackPublicationCommit, type StackPublicationStatus } from "./api.js";
 import { loadConfig, type Config } from "./config.js";
 import { discoverTrunk } from "./git-stack.js";
-export declare const SERVER_PUBLISH_MAX_COMMITS = 20;
-export declare const SERVER_PUBLISH_MAX_CHANGES = 500;
 export declare const SERVER_PUBLISH_MAX_FILE_BYTES: number;
-export declare const SERVER_PUBLISH_MAX_TOTAL_BYTES: number;
-export declare const SERVER_PUBLISH_MAX_COMMIT_BYTES: number;
-export declare const SERVER_PUBLISH_FILE_MODES: readonly ["100644", "100755", "120000"];
-export declare const SERVER_PUBLISH_HISTORY_SCAN = 500;
-export type GitRead = (args: string[], cwd: string) => Buffer;
+export type GitRead = (args: string[], cwd: string) => Buffer | Promise<Buffer>;
+export declare const READ_ONLY_GIT: Set<string>;
 export declare function readGit(args: string[], cwd: string): Buffer;
-export declare function readCommitHeader(read: GitRead, sha: string, cwd: string): {
-    tree: string;
-    parents: string[];
-    author: StackPublicationIdentity;
-    committer: StackPublicationIdentity;
-    message: string;
-};
-export declare function readCommitChanges(read: GitRead, parent: string, sha: string, cwd: string, budget: {
-    changes: number;
-    bytes: number;
-}): StackPublicationChange[];
-export declare function readPublicationCommits(read: GitRead, from: string, to: string, cwd: string): StackPublicationCommit[];
+export declare function readPublicationCommits(read: GitRead, from: string, to: string, cwd: string): Promise<StackPublicationCommit[]>;
 export type ServerPublishInput = {
     cfg: Config;
     cwd: string;
     owner: string;
     repo: string;
     branch: string;
+    localRef?: string;
     baseBranch: string;
     localBaseRef?: string;
     remoteBaseSha?: string;
@@ -71,12 +56,6 @@ export declare function assertExplicitStacking(input: {
     stackCommand: string;
     trunkCommand: string;
 }): void;
-export declare function workingBranchTarget(input: WorkingBranchInput): {
-    cwd: string;
-    owner: string;
-    repo: string;
-    branch: string;
-};
 export declare function publishWorkingBranch(input: WorkingBranchInput, deps?: WorkingBranchDeps): Promise<ServerPublishResult & {
     stacked: boolean;
 }>;

package/dist/server-publish.js

@@ -1,37 +1,41 @@
 import { spawnSync } from "node:child_process";
 import { getStackPublication, submitStackPublication, } from "./api.js";
 import { loadConfig } from "./config.js";
-import { CommandError } from "./errors.js";
+import { CommandError, isCommandErrorCode } from "./errors.js";
 import { parseGithubOriginRepo } from "./git.js";
 import { currentBranch, discoverTrunk, tipCommitMessage, tipCommitSubject } from "./git-stack.js";
 import { buildPrBodyFromCommit } from "./pr-body.js";
-export const SERVER_PUBLISH_MAX_COMMITS = 20;
-export const SERVER_PUBLISH_MAX_CHANGES = 500;
+const SERVER_PUBLISH_MAX_COMMITS = 20;
+const SERVER_PUBLISH_MAX_CHANGES = 500;
 export const SERVER_PUBLISH_MAX_FILE_BYTES = 2 * 1024 * 1024;
-export const SERVER_PUBLISH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
-export const SERVER_PUBLISH_MAX_COMMIT_BYTES = 1024 * 1024;
-export const SERVER_PUBLISH_FILE_MODES = ["100644", "100755", "120000"];
-export const SERVER_PUBLISH_HISTORY_SCAN = 500;
-const READ_ONLY_GIT = new Set(["cat-file", "diff-tree", "merge-base", "rev-list", "rev-parse", "symbolic-ref"]);
+const SERVER_PUBLISH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+const SERVER_PUBLISH_MAX_COMMIT_BYTES = 1024 * 1024;
+const SERVER_PUBLISH_FILE_MODES = ["100644", "100755", "120000"];
+const SERVER_PUBLISH_HISTORY_SCAN = 500;
+export const READ_ONLY_GIT = new Set(["cat-file", "diff-tree", "merge-base", "rev-list", "rev-parse", "symbolic-ref"]);
 export function readGit(args, cwd) {
     if (!READ_ONLY_GIT.has(args[0] ?? "")) {
         throw new Error(`server-side publication only reads the repository; refusing git ${args[0] ?? ""}`);
     }
     const result = spawnSync("git", args, { cwd, maxBuffer: 256 * 1024 * 1024 });
+    if (result.error)
+        throw result.error;
     if (result.status !== 0) {
-        throw new Error(result.stderr?.toString("utf8").trim() || `git ${args.join(" ")} failed`);
+        throw new CommandError(result.stderr?.toString("utf8").trim() || `git ${args.join(" ")} failed`, 1, "git_failed");
     }
     return result.stdout;
 }
-function text(read, args, cwd) {
-    return read(args, cwd).toString("utf8").trim();
+async function text(read, args, cwd) {
+    return (await read(args, cwd)).toString("utf8").trim();
 }
-function resolves(read, ref, cwd) {
+async function resolves(read, ref, cwd) {
     try {
-        return text(read, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd) || null;
+        return await text(read, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], cwd) || null;
     }
-    catch {
-        return null;
+    catch (err) {
+        if (isCommandErrorCode(err, "git_failed"))
+            return null;
+        throw err;
     }
 }
 function isoWithOffset(epochSeconds, offset) {
@@ -52,12 +56,12 @@ function parseIdentity(line, sha) {
     }
     return { name: match[1].trim() ? match[1] : match[2], email: match[2], date };
 }
-export function readCommitHeader(read, sha, cwd) {
-    const commitBytes = Number(text(read, ["cat-file", "-s", sha], cwd));
+async function readCommitHeader(read, sha, cwd) {
+    const commitBytes = Number(await text(read, ["cat-file", "-s", sha], cwd));
     if (commitBytes > SERVER_PUBLISH_MAX_COMMIT_BYTES) {
         throw new CommandError(`Commit ${sha} is ${commitBytes} bytes; server-side publication reads commits up to ${SERVER_PUBLISH_MAX_COMMIT_BYTES} bytes.`, 1, "payload_too_large");
     }
-    const commitObject = read(["cat-file", "commit", sha], cwd);
+    const commitObject = await read(["cat-file", "commit", sha], cwd);
     let raw;
     try {
         raw = new TextDecoder("utf-8", { fatal: true }).decode(commitObject);
@@ -87,8 +91,8 @@ export function readCommitHeader(read, sha, cwd) {
     }
     return { tree, parents, author: parseIdentity(author, sha), committer: parseIdentity(committer, sha), message };
 }
-export function readCommitChanges(read, parent, sha, cwd, budget) {
-    const listing = read(["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-commit-id", "--abbrev=40", parent, sha], cwd);
+async function readCommitChanges(read, parent, sha, cwd, budget) {
+    const listing = await read(["diff-tree", "-r", "-z", "--raw", "--no-renames", "--no-commit-id", "--abbrev=40", parent, sha], cwd);
     let raw;
     try {
         raw = new TextDecoder("utf-8", { fatal: true }).decode(listing);
@@ -114,7 +118,7 @@ export function readCommitChanges(read, parent, sha, cwd, budget) {
             throw new CommandError(`${path} has Git mode ${newMode}, which server-side publication does not support` +
                 `${newMode === "160000" ? " (it is a submodule)" : ""}. Supported modes are ${SERVER_PUBLISH_FILE_MODES.join(", ")}.`, 1, "unsupported_publication");
         }
-        const size = Number(text(read, ["cat-file", "-s", newSha], cwd));
+        const size = Number(await text(read, ["cat-file", "-s", newSha], cwd));
         if (size > SERVER_PUBLISH_MAX_FILE_BYTES) {
             throw new CommandError(`${path} is ${size} bytes; server-side publication carries files up to ${SERVER_PUBLISH_MAX_FILE_BYTES} bytes.`, 1, "payload_too_large");
         }
@@ -122,30 +126,32 @@ export function readCommitChanges(read, parent, sha, cwd, budget) {
         if (budget.bytes > SERVER_PUBLISH_MAX_TOTAL_BYTES) {
             throw new CommandError(`More than ${SERVER_PUBLISH_MAX_TOTAL_BYTES} bytes of file content; server-side publication cannot carry this branch in one request.`, 1, "payload_too_large");
         }
-        const content = read(["cat-file", "blob", newSha], cwd);
+        const content = await read(["cat-file", "blob", newSha], cwd);
         changes.push({ path, mode: newMode, sha: newSha, content: content.toString("base64") });
     }
     return changes;
 }
-export function readPublicationCommits(read, from, to, cwd) {
+export async function readPublicationCommits(read, from, to, cwd) {
     try {
-        read(["merge-base", "--is-ancestor", from, to], cwd);
+        await read(["merge-base", "--is-ancestor", from, to], cwd);
     }
-    catch {
+    catch (err) {
+        if (!isCommandErrorCode(err, "git_failed"))
+            throw err;
         throw new CommandError(`${from} is not an ancestor of ${to}; the commits to publish are not a straight line.`, 1, "unsupported_publication");
     }
-    if (text(read, ["rev-list", "--min-parents=2", "--max-count=1", `${from}..${to}`], cwd)) {
+    if (await text(read, ["rev-list", "--min-parents=2", "--max-count=1", `${from}..${to}`], cwd)) {
         throw new CommandError(`A merge commit sits between ${from} and ${to}. Server-side publication carries single-parent commits only; rebase or squash the branch.`, 1, "unsupported_publication");
     }
-    const shas = text(read, ["rev-list", "--reverse", `${from}..${to}`], cwd).split("\n").filter(Boolean);
+    const shas = (await text(read, ["rev-list", "--reverse", `${from}..${to}`], cwd)).split("\n").filter(Boolean);
     if (shas.length > SERVER_PUBLISH_MAX_COMMITS) {
         throw new CommandError(`${shas.length} commits to publish; server-side publication carries at most ${SERVER_PUBLISH_MAX_COMMITS} at once. Squash the branch.`, 1, "payload_too_large");
     }
     const commits = [];
     const budget = { changes: 0, bytes: 0 };
     for (const sha of shas) {
-        const header = readCommitHeader(read, sha, cwd);
-        const changes = readCommitChanges(read, header.parents[0], sha, cwd, budget);
+        const header = await readCommitHeader(read, sha, cwd);
+        const changes = await readCommitChanges(read, header.parents[0], sha, cwd, budget);
         commits.push({
             message: header.message,
             author: header.author,
@@ -156,8 +162,8 @@ export function readPublicationCommits(read, from, to, cwd) {
     }
     return commits;
 }
-function localCommitWithTree(read, from, branch, head, cwd) {
-    const lines = text(read, ["rev-list", `--max-count=${SERVER_PUBLISH_HISTORY_SCAN}`, "--format=%H %T", "--no-commit-header", `${from}..${branch}`], cwd)
+async function localCommitWithTree(read, from, branch, head, cwd) {
+    const lines = (await text(read, ["rev-list", `--max-count=${SERVER_PUBLISH_HISTORY_SCAN}`, "--format=%H %T", "--no-commit-header", `${from}..${branch}`], cwd))
         .split("\n")
         .filter(Boolean);
     let match = null;
@@ -176,22 +182,23 @@ export async function publishBranchServerSide(input, deps = {}) {
     const status = deps.getStackPublication ?? getStackPublication;
     const submit = deps.submitStackPublication ?? submitStackPublication;
     const { cfg, cwd, owner, repo, branch } = input;
-    if (!resolves(read, branch, cwd))
-        throw new CommandError(`Branch missing locally: ${branch}`);
+    const local = input.localRef ?? branch;
+    if (!(await resolves(read, local, cwd)))
+        throw new CommandError(`Branch missing locally: ${local}`);
     const remote = await status(cfg, { owner, repo, branch });
     const baseBranch = remote.pr?.base ?? input.baseBranch;
     deps.assertBase?.(baseBranch);
     const localBase = input.localBaseRef ??
-        (resolves(read, `refs/remotes/origin/${input.baseBranch}`, cwd) ? `refs/remotes/origin/${input.baseBranch}` : input.baseBranch);
-    if (!resolves(read, localBase, cwd))
+        ((await resolves(read, `refs/remotes/origin/${input.baseBranch}`, cwd)) ? `refs/remotes/origin/${input.baseBranch}` : input.baseBranch);
+    if (!(await resolves(read, localBase, cwd)))
         throw new CommandError(`Base branch missing locally: ${localBase}`);
-    const fork = text(read, ["merge-base", localBase, branch], cwd);
+    const fork = await text(read, ["merge-base", localBase, local], cwd);
     const baseSha = input.remoteBaseSha ?? fork;
     let onto = "base";
     let expectedHead = null;
     let from = fork;
     if (remote.head) {
-        const published = remote.head.tree ? localCommitWithTree(read, fork, branch, { sha: remote.head.sha, tree: remote.head.tree }, cwd) : null;
+        const published = remote.head.tree ? await localCommitWithTree(read, fork, local, { sha: remote.head.sha, tree: remote.head.tree }, cwd) : null;
         if (published) {
             onto = "head";
             expectedHead = remote.head.sha;
@@ -209,7 +216,7 @@ export async function publishBranchServerSide(input, deps = {}) {
                 `To replace that head with your local branch, pass --replace-head ${remote.head.sha}.`, 1, "head_changed");
         }
     }
-    const commits = readPublicationCommits(read, from, branch, cwd);
+    const commits = await readPublicationCommits(read, from, local, cwd);
     if (commits.length === 0 && onto === "base") {
         throw new CommandError(`No commits on \`${branch}\` ahead of \`${input.baseBranch}\`. Commit your changes, then retry.`);
     }
@@ -224,7 +231,7 @@ export async function publishBranchServerSide(input, deps = {}) {
         pr: { title: input.title, body: input.body },
         ...(typeof input.autoLand === "boolean" ? { autoLand: input.autoLand } : {}),
     });
-    const localTree = text(read, ["rev-parse", `${branch}^{tree}`], cwd);
+    const localTree = await text(read, ["rev-parse", `${local}^{tree}`], cwd);
     if (publication.head.tree !== localTree) {
         throw new CommandError(`GitHub has tree ${publication.head.tree} at ${branch}, but your local branch has tree ${localTree}.`, 1, "tree_mismatch");
     }
@@ -237,7 +244,7 @@ export function assertExplicitStacking(input) {
         `• Stack onto \`${input.parent}\`: ${input.stackCommand}\n` +
         `• New stack from \`${input.trunk}\`: ${input.trunkCommand}`, 1, "implicit_stack");
 }
-export function workingBranchTarget(input) {
+function workingBranchTarget(input) {
     const cwd = input.cwd ?? process.cwd();
     const origin = input.owner && input.repo ? { owner: input.owner, repo: input.repo } : parseGithubOriginRepo(cwd);
     if (!origin) {