@agentproto/worktree 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,6 +1,597 @@
-export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-P7FOHOQ3.mjs';
-import './chunk-PSFICTF7.mjs';
-export { execArgv, execGit, execShell, expandGlob, globToRegExp, worktreeProvider } from './chunk-BBAH3VLQ.mjs';
-export { cleanupWorktreeTool, provisionWorktreeTool, runGateTool } from './chunk-FRVPZTQN.mjs';
+export { connectDaemonAgentSessionHost, makeDaemonAgentSessionHost, worktreeAgentInputSchema, worktreeAgentWorkflow } from './chunk-CBEWP5OT.mjs';
+import './chunk-E3EM24BS.mjs';
+import { computeProvenance, execArgv, classify, computeWorktreeStatus, listGitWorktrees, worktreeProvider } from './chunk-SEVCUXPY.mjs';
+export { CONFIG_FILENAME, ConfigError, DEFAULT_PROXY_PORT, ENV_VARS, FileVerdictMemoStore, HookError, InMemoryVerdictMemoStore, ProxyTable, SESSIONS_FILE_PATH, ServiceSupervisor, VERDICT_MEMO_PATH, WorktreeNotRemovableError, allocatePort, classify, computeLiveness, computeProvenance, computeTreeState, computeWorktreeStatus, detectDefaultBranch, disposeSupervisor, ephemeralPort, execArgv, execGit, execShell, expandGlob, getScript, getSupervisor, globToRegExp, hookEnv, isPortFree, listGitWorktrees, listScripts, listServices, listWorktreeStatuses, loadConfigFromBase, normalizeHook, parseConfig, peerEnv, peerEnvKey, readSessionsRegistry, readWorktreeMarker, reconcileIntegration, repoLabel, resolveSupervisor, runSetup, runTeardown, serviceEnv, serviceEnvToken, serviceHostname, serviceUrl, sessionInWorktree, sharedProxyTable, slugify, stripPort, worktreeProvider, writeWorktreeMarker } from './chunk-SEVCUXPY.mjs';
+import { cleanupWorktreeTool } from './chunk-CM3XGWTY.mjs';
+export { cleanupWorktreeTool, listServicesTool, provisionWorktreeTool, runGateTool, runScriptTool, serviceStatusSchema, startServiceTool, stopServiceTool } from './chunk-CM3XGWTY.mjs';
+import { mkdir, copyFile, writeFile, open } from 'fs/promises';
+import { homedir } from 'os';
+import { resolve, join, dirname, basename } from 'path';
+import http from 'http';
+import { connect } from 'net';
+import { z } from 'zod';
+import { runTool } from '@agentproto/driver';
+
+/**
+ * @agentproto/worktree v0.1.0
+ * git-worktree provision / gate / cleanup TOOL contracts + builtin PROVIDER.
+ */
+var SALVAGE_ROOT = () => resolve(homedir(), ".agentproto", "worktree-salvage");
+async function listUntrackedFiles(worktreePath) {
+  const res = await execArgv("git", ["-C", worktreePath, "ls-files", "--others", "--exclude-standard"], worktreePath);
+  if (res.exitCode !== 0) {
+    throw new Error(`git ls-files --others failed in ${worktreePath} (exit ${res.exitCode}): ${res.stderr.trim()}`);
+  }
+  return res.stdout.split("\n").filter(Boolean);
+}
+async function diffHead(worktreePath) {
+  const res = await execArgv("git", ["-C", worktreePath, "diff", "HEAD"], worktreePath);
+  if (res.exitCode !== 0) {
+    throw new Error(`git diff HEAD failed in ${worktreePath} (exit ${res.exitCode}): ${res.stderr.trim()}`);
+  }
+  return res.stdout;
+}
+function sanitizeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+/, "") || "worktree";
+}
+async function fsyncFile(path) {
+  const handle = await open(path, "r+");
+  try {
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function writeFileSynced(path, content) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, content, "utf8");
+  await fsyncFile(path);
+}
+async function salvageWorktree(input) {
+  const now = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const createdAt = now();
+  const tipShort = input.tipSha.slice(0, 7);
+  const dateStamp = createdAt.slice(0, 10);
+  const dirName = `${sanitizeSegment(input.slug)}-${tipShort}-${dateStamp}`;
+  const dir = resolve(input.salvageRoot ?? SALVAGE_ROOT(), sanitizeSegment(input.repoName), dirName);
+  await mkdir(dir, { recursive: true });
+  const [patch, untrackedFiles, provenance] = await Promise.all([
+    diffHead(input.worktreePath),
+    listUntrackedFiles(input.worktreePath),
+    computeProvenance(input.worktreePath, { sessionsPath: input.sessionsPath })
+  ]);
+  await writeFileSynced(join(dir, "changes.patch"), patch);
+  for (const relPath of untrackedFiles) {
+    const dest = join(dir, "untracked", relPath);
+    await mkdir(dirname(dest), { recursive: true });
+    await copyFile(join(input.worktreePath, relPath), dest);
+    await fsyncFile(dest);
+  }
+  const manifest = {
+    repo: input.repoName,
+    branch: input.branch,
+    tipSha: input.tipSha,
+    createdAt,
+    untrackedFiles,
+    hasPatch: patch.length > 0,
+    provenance
+  };
+  await writeFileSynced(join(dir, "MANIFEST.json"), JSON.stringify(manifest, null, 2) + "\n");
+  return { dir, manifest };
+}
+var TARGET_HOST = "127.0.0.1";
+function notFound(table, host) {
+  const known = table.entries().map(([h]) => h);
+  return `worktree-proxy: no service for host "${host ?? "(none)"}"
+` + (known.length ? `known hosts:
+${known.map((h) => `  ${h}`).join("\n")}
+` : "no services registered\n");
+}
+function createProxyServer(table) {
+  const server = http.createServer((req, res) => {
+    const targetPort = table.lookup(req.headers.host);
+    if (targetPort === void 0) {
+      res.writeHead(502, { "content-type": "text/plain" });
+      res.end(notFound(table, req.headers.host));
+      return;
+    }
+    const proxyReq = http.request(
+      {
+        host: TARGET_HOST,
+        port: targetPort,
+        method: req.method,
+        path: req.url,
+        headers: req.headers
+      },
+      (proxyRes) => {
+        res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+        proxyRes.pipe(res);
+      }
+    );
+    proxyReq.on("error", (err) => {
+      if (!res.headersSent) res.writeHead(502, { "content-type": "text/plain" });
+      res.end(`worktree-proxy: upstream error: ${err.message}
+`);
+    });
+    req.pipe(proxyReq);
+  });
+  server.on("upgrade", (req, clientSocket, head) => {
+    const targetPort = table.lookup(req.headers.host);
+    if (targetPort === void 0) {
+      clientSocket.end("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+      return;
+    }
+    const upstream = connect(targetPort, TARGET_HOST, () => {
+      const headerLines = [`${req.method} ${req.url} HTTP/1.1`];
+      for (let i = 0; i < req.rawHeaders.length; i += 2) {
+        headerLines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`);
+      }
+      upstream.write(headerLines.join("\r\n") + "\r\n\r\n");
+      if (head && head.length) upstream.write(head);
+      upstream.pipe(clientSocket);
+      clientSocket.pipe(upstream);
+    });
+    const teardown = () => {
+      clientSocket.destroy();
+      upstream.destroy();
+    };
+    upstream.on("error", teardown);
+    clientSocket.on("error", teardown);
+    upstream.on("close", () => clientSocket.destroy());
+    clientSocket.on("close", () => upstream.destroy());
+  });
+  return server;
+}
+function startProxy(table, port = 0) {
+  const server = createProxyServer(table);
+  const sockets = /* @__PURE__ */ new Set();
+  server.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.once("close", () => sockets.delete(socket));
+  });
+  return new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(port, () => {
+      const address = server.address();
+      const boundPort = address && typeof address === "object" ? address.port : port;
+      resolve2({
+        port: boundPort,
+        server,
+        close: () => new Promise((res) => {
+          for (const socket of sockets) socket.destroy();
+          sockets.clear();
+          server.close(() => res());
+        })
+      });
+    });
+  });
+}
+var ForgeUnavailableError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ForgeUnavailableError";
+  }
+};
+var UnreachableForgeClient = class {
+  constructor(reason) {
+    this.reason = reason;
+  }
+  reason;
+  async pullRequestsForBranch() {
+    throw new ForgeUnavailableError(this.reason);
+  }
+  async pullRequestsForCommit() {
+    throw new ForgeUnavailableError(this.reason);
+  }
+  async ensurePullHeadFetched() {
+    throw new ForgeUnavailableError(this.reason);
+  }
+};
+var ghPrListItemSchema = z.object({
+  number: z.number(),
+  state: z.string(),
+  headRefName: z.string(),
+  headRefOid: z.string(),
+  mergedAt: z.string().nullable()
+});
+var ghPrListSchema = z.array(ghPrListItemSchema);
+function normalizeGhPrListItem(item) {
+  const state = item.state.toUpperCase();
+  return {
+    number: item.number,
+    state: state === "OPEN" ? "open" : "closed",
+    merged: state === "MERGED" || item.mergedAt !== null,
+    mergedAt: item.mergedAt,
+    headRefName: item.headRefName,
+    headRefOid: item.headRefOid
+  };
+}
+var ghApiCommitPullSchema = z.object({
+  number: z.number(),
+  state: z.string(),
+  merged_at: z.string().nullable(),
+  head: z.object({ ref: z.string(), sha: z.string() })
+});
+var ghApiCommitPullListSchema = z.array(ghApiCommitPullSchema);
+function normalizeGhApiCommitPull(item) {
+  return {
+    number: item.number,
+    state: item.state === "open" ? "open" : "closed",
+    merged: item.merged_at !== null,
+    mergedAt: item.merged_at,
+    headRefName: item.head.ref,
+    headRefOid: item.head.sha
+  };
+}
+function isCommitNotFoundError(output) {
+  return /\(HTTP (404|422)\)/.test(output);
+}
+var GhCliForgeClient = class {
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+  }
+  repoRoot;
+  async runRaw(args) {
+    try {
+      return await execArgv("gh", args, this.repoRoot);
+    } catch (err) {
+      throw new ForgeUnavailableError(
+        `gh ${args.join(" ")} could not be run: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+  }
+  async run(args) {
+    const result = await this.runRaw(args);
+    if (result.exitCode !== 0) {
+      throw new ForgeUnavailableError(
+        `gh ${args.join(" ")} failed (exit ${result.exitCode}): ${result.stderr.trim() || result.stdout.trim()}`
+      );
+    }
+    return result.stdout;
+  }
+  parseOutput(stdout, schema, args) {
+    let parsed;
+    try {
+      parsed = JSON.parse(stdout);
+    } catch (err) {
+      throw new ForgeUnavailableError(
+        `gh ${args.join(" ")} produced non-JSON output: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      throw new ForgeUnavailableError(`gh ${args.join(" ")} output did not match the expected shape`);
+    }
+    return result.data;
+  }
+  async pullRequestsForBranch(branch) {
+    const args = [
+      "pr",
+      "list",
+      "--head",
+      branch,
+      "--state",
+      "all",
+      "--json",
+      "number,state,headRefName,headRefOid,mergedAt"
+    ];
+    const stdout = await this.run(args);
+    return this.parseOutput(stdout, ghPrListSchema, args).map(normalizeGhPrListItem);
+  }
+  async pullRequestsForCommit(sha) {
+    const args = ["api", `repos/{owner}/{repo}/commits/${sha}/pulls`];
+    const result = await this.runRaw(args);
+    if (result.exitCode !== 0) {
+      if (isCommitNotFoundError(result.stderr) || isCommitNotFoundError(result.stdout)) return [];
+      throw new ForgeUnavailableError(
+        `gh ${args.join(" ")} failed (exit ${result.exitCode}): ${result.stderr.trim() || result.stdout.trim()}`
+      );
+    }
+    return this.parseOutput(result.stdout, ghApiCommitPullListSchema, args).map(normalizeGhApiCommitPull);
+  }
+  async ensurePullHeadFetched(prNumber, oid) {
+    const check = await execArgv("git", ["-C", this.repoRoot, "cat-file", "-e", `${oid}^{commit}`], this.repoRoot);
+    if (check.exitCode === 0) return;
+    const fetch2 = await execArgv(
+      "git",
+      ["-C", this.repoRoot, "fetch", "origin", `refs/pull/${prNumber}/head`],
+      this.repoRoot
+    );
+    if (fetch2.exitCode !== 0) {
+      throw new ForgeUnavailableError(
+        `git fetch origin refs/pull/${prNumber}/head failed: ${fetch2.stderr.trim() || fetch2.stdout.trim()}`
+      );
+    }
+  }
+};
+var restPullRequestSchema = z.object({
+  number: z.number(),
+  state: z.string(),
+  merged_at: z.string().nullable(),
+  head: z.object({ ref: z.string(), sha: z.string() })
+});
+var restPullRequestListSchema = z.array(restPullRequestSchema);
+function normalizeRestPr(item) {
+  return {
+    number: item.number,
+    state: item.state === "open" ? "open" : "closed",
+    merged: item.merged_at !== null,
+    mergedAt: item.merged_at,
+    headRefName: item.head.ref,
+    headRefOid: item.head.sha
+  };
+}
+function parseGithubOwnerRepo(remoteUrl) {
+  const ssh = remoteUrl.match(/^git@github\.com:([^/]+)\/(.+?)(\.git)?$/);
+  if (ssh?.[1] && ssh[2]) return { owner: ssh[1], repo: ssh[2] };
+  const https = remoteUrl.match(/^https:\/\/github\.com\/([^/]+)\/(.+?)(\.git)?\/?$/);
+  if (https?.[1] && https[2]) return { owner: https[1], repo: https[2] };
+  return null;
+}
+var RestForgeClient = class {
+  constructor(owner, repo, repoRoot, token, fetchFn = fetch) {
+    this.owner = owner;
+    this.repo = repo;
+    this.repoRoot = repoRoot;
+    this.token = token;
+    this.fetchFn = fetchFn;
+  }
+  owner;
+  repo;
+  repoRoot;
+  token;
+  fetchFn;
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28",
+      "User-Agent": "agentproto-worktree-status"
+    };
+  }
+  async get(path) {
+    try {
+      return await this.fetchFn(`https://api.github.com${path}`, { headers: this.headers() });
+    } catch (err) {
+      throw new ForgeUnavailableError(
+        `GitHub REST request to ${path} failed: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+  }
+  async pullRequestList(res) {
+    const body = await res.json();
+    const result = restPullRequestListSchema.safeParse(body);
+    if (!result.success) {
+      throw new ForgeUnavailableError(`GitHub REST response did not match the expected PR list shape`);
+    }
+    return result.data.map(normalizeRestPr);
+  }
+  async pullRequestsForBranch(branch) {
+    const res = await this.get(
+      `/repos/${this.owner}/${this.repo}/pulls?head=${this.owner}:${encodeURIComponent(branch)}&state=all&per_page=100`
+    );
+    if (!res.ok) {
+      throw new ForgeUnavailableError(`GitHub REST pulls?head= failed: ${res.status} ${res.statusText}`);
+    }
+    return this.pullRequestList(res);
+  }
+  async pullRequestsForCommit(sha) {
+    const res = await this.get(`/repos/${this.owner}/${this.repo}/commits/${sha}/pulls?per_page=100`);
+    if (res.status === 404 || res.status === 422) return [];
+    if (!res.ok) {
+      throw new ForgeUnavailableError(`GitHub REST commits/:sha/pulls failed: ${res.status} ${res.statusText}`);
+    }
+    return this.pullRequestList(res);
+  }
+  async ensurePullHeadFetched(prNumber, oid) {
+    const check = await execArgv("git", ["-C", this.repoRoot, "cat-file", "-e", `${oid}^{commit}`], this.repoRoot);
+    if (check.exitCode === 0) return;
+    const fetch2 = await execArgv(
+      "git",
+      ["-C", this.repoRoot, "fetch", "origin", `refs/pull/${prNumber}/head`],
+      this.repoRoot
+    );
+    if (fetch2.exitCode !== 0) {
+      throw new ForgeUnavailableError(
+        `git fetch origin refs/pull/${prNumber}/head failed: ${fetch2.stderr.trim() || fetch2.stdout.trim()}`
+      );
+    }
+  }
+};
+async function ghIsUsable(repoRoot) {
+  try {
+    const res = await execArgv("gh", ["auth", "status"], repoRoot);
+    return res.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function createForgeClient(repoRoot) {
+  if (await ghIsUsable(repoRoot)) return new GhCliForgeClient(repoRoot);
+  const token = process.env.GITHUB_TOKEN;
+  if (token) {
+    const remote = await execArgv("git", ["-C", repoRoot, "remote", "get-url", "origin"], repoRoot);
+    const parsed = remote.exitCode === 0 ? parseGithubOwnerRepo(remote.stdout.trim()) : null;
+    if (parsed) return new RestForgeClient(parsed.owner, parsed.repo, repoRoot, token);
+  }
+  return new UnreachableForgeClient(
+    "no usable forge client: `gh` is not installed/authenticated and GITHUB_TOKEN is not set (or origin isn't a GitHub remote)"
+  );
+}
+var candidates = [worktreeProvider];
+function classifyForGc(tree, integration, liveness, options = {}) {
+  if (options.includeDetached && integration.state === "detached") {
+    const idleOrUnreachable = liveness.state === "idle" || liveness.state === "daemon-unreachable";
+    if (tree.state === "clean" && idleOrUnreachable) return "reclaim";
+  }
+  return classify(tree, integration, liveness, options.nowMs).class;
+}
+async function linkedWorktreesOf(repoRoot) {
+  const worktrees = await listGitWorktrees(repoRoot);
+  return worktrees.filter((w) => w.path !== repoRoot);
+}
+function toPlanEntry(worktree, status, includeDetached, nowMs) {
+  return {
+    path: worktree.path,
+    branch: worktree.branch,
+    head: worktree.head,
+    tree: status.tree,
+    integration: status.integration,
+    liveness: status.liveness,
+    class: classifyForGc(status.tree, status.integration, status.liveness, { includeDetached, nowMs })
+  };
+}
+async function planGc(input) {
+  const includeDetached = Boolean(input.includeDetached);
+  const nowMs = input.nowMs ?? Date.now();
+  const worktrees = await linkedWorktreesOf(input.repoRoot);
+  const entries = [];
+  for (const worktree of worktrees) {
+    const status = await computeWorktreeStatus({
+      repoRoot: input.repoRoot,
+      repoName: input.repoName,
+      worktree,
+      forge: input.forge,
+      memo: input.memo,
+      defaultBranchRef: input.defaultBranchRef,
+      sessionsPath: input.sessionsPath,
+      now: input.now
+    });
+    entries.push(toPlanEntry(worktree, status, includeDetached, nowMs));
+  }
+  return entries;
+}
+async function findWorktree(repoRoot, path) {
+  const worktrees = await linkedWorktreesOf(repoRoot);
+  return worktrees.find((w) => w.path === path) ?? null;
+}
+async function reclaimOne(options, worktree) {
+  try {
+    await runTool({
+      tool: cleanupWorktreeTool,
+      candidates,
+      input: {
+        repoRoot: options.repoRoot,
+        cwd: worktree.path,
+        ...worktree.branch ? { branch: worktree.branch } : {},
+        // Branch deletion only ever runs for a `reclaim`-class entry, which by
+        // construction requires `integration ∈ {merged(*), fresh}` and
+        // `tree = clean` (PLAN.md's invariant: branch -D only when there's
+        // nothing uncommitted to lose, never a hold class).
+        deleteBranch: true
+        // No discardUntracked/discardModified, ever, on this path (PLAN.md
+        // §5.2 layer 3): `reclaim` means `tree = clean`, so plain `git
+        // worktree remove` should succeed on its own; if the tree turned
+        // dirty in the instant between the re-check above and this call, git
+        // itself refuses and that refusal surfaces below as `failed` — never
+        // a force flag "just in case."
+      }
+    });
+  } catch (err) {
+    return {
+      path: worktree.path,
+      branch: worktree.branch,
+      result: "failed",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+  return { path: worktree.path, branch: worktree.branch, result: "reclaimed" };
+}
+async function salvageOne(options, worktree) {
+  let salvageDir;
+  try {
+    const result = await salvageWorktree({
+      repoName: options.repoName,
+      worktreePath: worktree.path,
+      branch: worktree.branch,
+      tipSha: worktree.head,
+      slug: worktree.branch ?? basename(worktree.path),
+      sessionsPath: options.sessionsPath,
+      now: options.now,
+      salvageRoot: options.salvageRoot
+    });
+    salvageDir = result.dir;
+  } catch (err) {
+    return {
+      path: worktree.path,
+      branch: worktree.branch,
+      result: "failed",
+      message: `salvage failed, nothing removed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    await runTool({
+      tool: cleanupWorktreeTool,
+      candidates,
+      input: {
+        repoRoot: options.repoRoot,
+        cwd: worktree.path,
+        ...worktree.branch ? { branch: worktree.branch } : {},
+        deleteBranch: true,
+        // Both discard flags: the snapshot above is already durable (fsynced)
+        // before this call, so nothing on disk is lost by discarding it here
+        // (PLAN.md §5.2 layer 4 — salvage before discard).
+        discardUntracked: true,
+        discardModified: true
+      }
+    });
+  } catch (err) {
+    return {
+      path: worktree.path,
+      branch: worktree.branch,
+      result: "failed",
+      message: `salvaged to ${salvageDir}, but removal failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return { path: worktree.path, branch: worktree.branch, result: "salvaged", salvageDir };
+}
+async function applyOne(entry, options) {
+  if (entry.class === "hold") {
+    return { path: entry.path, branch: entry.branch, result: "held" };
+  }
+  if (entry.class === "salvage" && !options.salvageDirty) {
+    return { path: entry.path, branch: entry.branch, result: "skipped-dirty" };
+  }
+  const fresh = await findWorktree(options.repoRoot, entry.path);
+  if (!fresh) {
+    return { path: entry.path, branch: entry.branch, result: "aborted-vanished" };
+  }
+  const status = await computeWorktreeStatus({
+    repoRoot: options.repoRoot,
+    repoName: options.repoName,
+    worktree: fresh,
+    forge: options.forge,
+    memo: options.memo,
+    defaultBranchRef: options.defaultBranchRef,
+    sessionsPath: options.sessionsPath,
+    now: options.now
+  });
+  const freshClass = classifyForGc(status.tree, status.integration, status.liveness, {
+    includeDetached: Boolean(options.includeDetached),
+    nowMs: options.nowMs
+  });
+  if (freshClass !== entry.class) {
+    return {
+      path: entry.path,
+      branch: fresh.branch,
+      result: "aborted-reclassified",
+      from: entry.class,
+      to: freshClass
+    };
+  }
+  if (freshClass === "reclaim") return reclaimOne(options, fresh);
+  return salvageOne(options, fresh);
+}
+async function applyGc(plan, options) {
+  const outcomes = [];
+  for (const entry of plan) {
+    outcomes.push(await applyOne(entry, options));
+  }
+  return outcomes;
+}
+
+export { ForgeUnavailableError, GhCliForgeClient, RestForgeClient, SALVAGE_ROOT, UnreachableForgeClient, applyGc, classifyForGc, createForgeClient, createProxyServer, parseGithubOwnerRepo, planGc, salvageWorktree, startProxy };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map