@agentproto/worktree 0.2.0 → 0.3.0

package/dist/chunk-SEVCUXPY.mjs

@@ -0,0 +1,1176 @@
+import { provisionWorktreeTool, cleanupWorktreeTool, runGateTool, runScriptTool, startServiceTool, stopServiceTool, listServicesTool } from './chunk-CM3XGWTY.mjs';
+import { implementTool, defineDriver } from '@agentproto/driver';
+import { randomUUID } from 'crypto';
+import { lstat, mkdir, symlink, copyFile, writeFile, readdir, stat, readFile } from 'fs/promises';
+import { resolve, join, dirname, posix, basename, sep } from 'path';
+import { ToolError } from '@agentproto/tool';
+import { spawn } from 'child_process';
+import { z } from 'zod';
+import { homedir } from 'os';
+import { createServer } from 'net';
+
+/**
+ * @agentproto/worktree v0.1.0
+ * git-worktree provision / gate / cleanup TOOL contracts + builtin PROVIDER.
+ */
+function mergedEnv(extra) {
+  return extra ? { ...process.env, ...extra } : process.env;
+}
+function execArgv(command, args, cwd, opts = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, { cwd, shell: false, env: mergedEnv(opts.env) });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => stdout += d.toString("utf8"));
+    child.stderr?.on("data", (d) => stderr += d.toString("utf8"));
+    child.on("error", reject);
+    child.on("close", (code) => resolvePromise({ exitCode: code ?? -1, stdout, stderr }));
+  });
+}
+function execShell(cmd, cwd, opts = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(cmd, { cwd, shell: true, env: mergedEnv(opts.env) });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => stdout += d.toString("utf8"));
+    child.stderr?.on("data", (d) => stderr += d.toString("utf8"));
+    child.on("error", reject);
+    child.on("close", (code) => resolvePromise({ exitCode: code ?? -1, stdout, stderr }));
+  });
+}
+async function execGit(repoRoot, args) {
+  const result = await execArgv("git", ["-C", repoRoot, ...args], repoRoot);
+  if (result.exitCode !== 0) {
+    throw new Error(`git ${args.join(" ")} failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+  }
+  return result;
+}
+function escapeSegment(seg) {
+  let out = "";
+  for (const ch of seg) {
+    if (ch === "*") out += "[^/]*";
+    else if (ch === "?") out += "[^/]";
+    else out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return out;
+}
+function globToRegExp(pattern) {
+  const segments = pattern.split("/");
+  let out = "^";
+  segments.forEach((seg, i) => {
+    const isLast = i === segments.length - 1;
+    if (seg === "**") {
+      out += isLast ? ".*" : "(?:[^/]+/)*";
+      return;
+    }
+    out += escapeSegment(seg);
+    if (!isLast) out += "/";
+  });
+  return new RegExp(out + "$");
+}
+function globBaseDir(pattern) {
+  const segments = pattern.split("/");
+  const literal = [];
+  for (const seg of segments) {
+    if (seg.includes("*") || seg.includes("?")) break;
+    literal.push(seg);
+  }
+  if (literal.length === segments.length) literal.pop();
+  return literal.join("/");
+}
+async function walk(root, dirRel) {
+  const abs = dirRel ? join(root, dirRel) : root;
+  let entries;
+  try {
+    entries = await readdir(abs, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") continue;
+    const rel = dirRel ? posix.join(dirRel, entry.name) : entry.name;
+    if (entry.isDirectory()) {
+      const children = await walk(root, rel);
+      for (const child of children) out.push(child);
+    } else if (entry.isFile()) {
+      out.push(rel);
+    }
+  }
+  return out;
+}
+async function expandGlob(root, pattern) {
+  const regex = globToRegExp(pattern);
+  const base = globBaseDir(pattern);
+  const candidates = await walk(root, base);
+  return candidates.filter((rel) => regex.test(rel));
+}
+var CONFIG_FILENAME = "agentproto.json";
+var hookSchema = z.union([z.string(), z.array(z.string())]);
+var scriptSchema = z.object({
+  command: z.string().min(1, "script command must be non-empty"),
+  type: z.literal("service").optional(),
+  port: z.number().int().min(1).max(65535).optional()
+});
+var configSchema = z.object({
+  worktree: z.object({
+    setup: hookSchema.optional(),
+    teardown: hookSchema.optional()
+  }).optional(),
+  scripts: z.record(z.string(), scriptSchema).optional()
+});
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function parseConfig(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    throw new ConfigError(
+      `${CONFIG_FILENAME} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const result = configSchema.safeParse(json);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".") || "<root>"}: ${i.message}`).join("; ");
+    throw new ConfigError(`${CONFIG_FILENAME} failed validation: ${issues}`);
+  }
+  return result.data;
+}
+function normalizeHook(hook) {
+  if (hook === void 0) return [];
+  return typeof hook === "string" ? [hook] : [...hook];
+}
+function listScripts(config) {
+  return Object.entries(config.scripts ?? {}).map(([name, cfg]) => ({ name, ...cfg }));
+}
+function listServices(config) {
+  return listScripts(config).filter((s) => s.type === "service");
+}
+function getScript(config, name) {
+  const cfg = config.scripts?.[name];
+  return cfg ? { name, ...cfg } : void 0;
+}
+async function loadConfigFromBase(repoRoot, base = "origin/main") {
+  const spec = `${base}:${CONFIG_FILENAME}`;
+  const result = await execArgv("git", ["-C", repoRoot, "show", spec], repoRoot);
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toLowerCase();
+    const pathAbsent = stderr.includes("does not exist") || stderr.includes("exists on disk, but not in");
+    const refAbsent = stderr.includes("unknown revision") || stderr.includes("bad revision") || stderr.includes("invalid object name") || stderr.includes("ambiguous argument");
+    if (pathAbsent || refAbsent) return null;
+    throw new ConfigError(
+      `could not read ${CONFIG_FILENAME} from '${spec}': ${result.stderr.trim() || `git exited ${result.exitCode}`}`
+    );
+  }
+  return parseConfig(result.stdout);
+}
+
+// src/env.ts
+var ENV_VARS = {
+  /** Absolute path to the original repo checkout the worktree was cut from. */
+  sourceCheckoutPath: "AGENTPROTO_SOURCE_CHECKOUT_PATH",
+  /** Absolute path to the worktree directory. */
+  worktreePath: "AGENTPROTO_WORKTREE_PATH",
+  /** The worktree's branch name. */
+  branchName: "AGENTPROTO_BRANCH_NAME",
+  /** A service's own allocated port. */
+  port: "AGENTPROTO_PORT",
+  /** A service's own reverse-proxy URL. */
+  url: "AGENTPROTO_URL"
+};
+function hookEnv(ctx) {
+  return {
+    [ENV_VARS.sourceCheckoutPath]: ctx.sourceCheckoutPath,
+    [ENV_VARS.worktreePath]: ctx.worktreePath,
+    [ENV_VARS.branchName]: ctx.branchName
+  };
+}
+function serviceEnvToken(name) {
+  return name.toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function peerEnvKey(name, suffix) {
+  return `AGENTPROTO_SERVICE_${serviceEnvToken(name)}_${suffix}`;
+}
+function peerEnv(peers) {
+  const out = {};
+  for (const peer of peers) {
+    out[peerEnvKey(peer.name, "PORT")] = String(peer.port);
+    out[peerEnvKey(peer.name, "URL")] = peer.url;
+  }
+  return out;
+}
+function serviceEnv(args) {
+  return {
+    ...hookEnv(args.ctx),
+    [ENV_VARS.port]: String(args.self.port),
+    [ENV_VARS.url]: args.self.url,
+    ...peerEnv(args.peers)
+  };
+}
+
+// src/lifecycle.ts
+var HookError = class extends Error {
+  command;
+  result;
+  constructor(phase, run) {
+    super(
+      `worktree ${phase} hook failed (exit ${run.result.exitCode}): ${run.command}
+` + (run.result.stderr || run.result.stdout).trim()
+    );
+    this.name = "HookError";
+    this.command = run.command;
+    this.result = run.result;
+  }
+};
+async function runSetup(config, ctx) {
+  const commands = normalizeHook(config.worktree?.setup);
+  const runs = [];
+  const env = hookEnv(ctx);
+  for (const command of commands) {
+    const result = await execShell(command, ctx.worktreePath, { env });
+    const run = { command, result };
+    runs.push(run);
+    if (result.exitCode !== 0) throw new HookError("setup", run);
+  }
+  return runs;
+}
+async function runTeardown(config, ctx) {
+  const commands = normalizeHook(config.worktree?.teardown);
+  const runs = [];
+  const env = hookEnv(ctx);
+  for (const command of commands) {
+    const result = await execShell(command, ctx.worktreePath, { env });
+    runs.push({ command, result });
+  }
+  return runs;
+}
+var SESSIONS_FILE_PATH = () => resolve(homedir(), ".agentproto", "sessions.json");
+var sessionRefSchema = z.object({
+  id: z.string(),
+  label: z.string().optional(),
+  startedAt: z.string(),
+  endedAt: z.string().optional(),
+  status: z.string(),
+  cwd: z.string().optional()
+});
+var sessionsFileSchema = z.object({ sessions: z.array(z.unknown()) });
+async function readSessionsRegistry(path = SESSIONS_FILE_PATH()) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    if (typeof err === "object" && err !== null && Reflect.get(err, "code") === "ENOENT") return [];
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const file = sessionsFileSchema.safeParse(parsed);
+  if (!file.success) return null;
+  const refs = [];
+  for (const entry of file.data.sessions) {
+    const ref = sessionRefSchema.safeParse(entry);
+    if (ref.success) refs.push(ref.data);
+  }
+  return refs;
+}
+function sessionInWorktree(session, worktreePath) {
+  if (session.cwd === void 0) return false;
+  return session.cwd === worktreePath || session.cwd.startsWith(worktreePath + sep);
+}
+var worktreeMarkerSchema = z.object({
+  worktreeId: z.string(),
+  createdAt: z.string(),
+  createdBySessionId: z.string().optional()
+});
+async function readWorktreeMarker(worktreePath) {
+  const gitDirRes = await execArgv(
+    "git",
+    ["-C", worktreePath, "rev-parse", "--path-format=absolute", "--git-dir"],
+    worktreePath
+  );
+  if (gitDirRes.exitCode !== 0) return null;
+  const gitDir = gitDirRes.stdout.trim();
+  if (!gitDir) return null;
+  let raw;
+  try {
+    raw = await readFile(resolve(gitDir, "agentproto-worktree.json"), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const result = worktreeMarkerSchema.safeParse(parsed);
+  return result.success ? result.data : null;
+}
+async function writeWorktreeMarker(worktreePath, marker) {
+  const gitDirRes = await execArgv(
+    "git",
+    ["-C", worktreePath, "rev-parse", "--path-format=absolute", "--git-dir"],
+    worktreePath
+  );
+  if (gitDirRes.exitCode !== 0) {
+    throw new Error(
+      `git rev-parse --git-dir failed in ${worktreePath} (exit ${gitDirRes.exitCode}): ${gitDirRes.stderr.trim()}`
+    );
+  }
+  const gitDir = gitDirRes.stdout.trim();
+  await writeFile(resolve(gitDir, "agentproto-worktree.json"), JSON.stringify(marker, null, 2) + "\n", "utf8");
+}
+async function computeProvenance(worktreePath, options = {}) {
+  const [registry, marker] = await Promise.all([
+    readSessionsRegistry(options.sessionsPath ?? SESSIONS_FILE_PATH()),
+    readWorktreeMarker(worktreePath)
+  ]);
+  const sessions = registry ?? [];
+  const matched = sessions.filter((s) => sessionInWorktree(s, worktreePath)).filter((s) => marker ? s.startedAt >= marker.createdAt : true).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+  return {
+    confidence: marker ? "exact" : "best-effort",
+    sessions: matched
+  };
+}
+
+// src/provider/bodies/provision-worktree.body.ts
+var provisionWorktreeBuiltin = implementTool(
+  provisionWorktreeTool,
+  async ({ input }) => {
+    const base = input.base ?? "origin/main";
+    const branch = input.branch ?? `wt/${input.slug}`;
+    const cwd = input.dir ? resolve(input.dir) : resolve(input.repoRoot, "..", "_worktrees", input.slug);
+    await execGit(input.repoRoot, ["worktree", "add", "-b", branch, cwd, base]);
+    await writeWorktreeMarker(cwd, {
+      worktreeId: `wt_${randomUUID().slice(0, 8)}`,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    for (const rel of input.linkPaths ?? []) {
+      const target = resolve(input.repoRoot, rel);
+      const dest = join(cwd, rel);
+      const existing = await lstat(dest).catch(() => null);
+      if (existing) continue;
+      await mkdir(dirname(dest), { recursive: true });
+      await symlink(target, dest, "dir");
+    }
+    if (input.depsCmd) {
+      const result = await execShell(input.depsCmd, cwd);
+      if (result.exitCode !== 0) {
+        throw new ToolError({
+          code: "execution_failed",
+          message: `depsCmd '${input.depsCmd}' failed (exit ${result.exitCode}): ${result.stderr || result.stdout}`
+        });
+      }
+    }
+    for (const pattern of input.copyGlobs ?? []) {
+      const matches = await expandGlob(input.repoRoot, pattern);
+      for (const rel of matches) {
+        const dest = join(cwd, rel);
+        await mkdir(dirname(dest), { recursive: true });
+        await copyFile(join(input.repoRoot, rel), dest);
+      }
+    }
+    if (input.runSetup !== false) {
+      const config = await loadConfigFromBase(input.repoRoot, base);
+      if (config) {
+        try {
+          await runSetup(config, {
+            sourceCheckoutPath: input.repoRoot,
+            worktreePath: cwd,
+            branchName: branch
+          });
+        } catch (err) {
+          if (err instanceof HookError) {
+            throw new ToolError({ code: "execution_failed", message: err.message });
+          }
+          throw err;
+        }
+      }
+    }
+    return { cwd, branch };
+  }
+);
+function isPortFree(port) {
+  return new Promise((resolve4) => {
+    const server = createServer();
+    server.once("error", () => resolve4(false));
+    server.once("listening", () => {
+      server.close(() => resolve4(true));
+    });
+    server.listen(port, "127.0.0.1");
+  });
+}
+function ephemeralPort() {
+  return new Promise((resolve4, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const port = address.port;
+        server.close(() => resolve4(port));
+      } else {
+        server.close(() => reject(new Error("could not determine an ephemeral port")));
+      }
+    });
+  });
+}
+async function allocatePort(preferred, reserved = /* @__PURE__ */ new Set()) {
+  if (preferred !== void 0 && !reserved.has(preferred) && await isPortFree(preferred)) {
+    return preferred;
+  }
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const port = await ephemeralPort();
+    if (!reserved.has(port)) return port;
+  }
+  throw new Error("could not allocate a free port after 20 attempts");
+}
+
+// src/services/slug.ts
+function slugify(input) {
+  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function serviceHostname(parts) {
+  const labels = parts.isDefaultBranch ? [slugify(parts.script), slugify(parts.repo)] : [slugify(parts.script), slugify(parts.branch), slugify(parts.repo)];
+  return `${labels.join("--")}.localhost`;
+}
+function serviceUrl(parts, proxyPort) {
+  return `http://${serviceHostname(parts)}:${proxyPort}`;
+}
+
+// src/services/supervisor.ts
+var ServiceSupervisor = class _ServiceSupervisor {
+  opts;
+  tracked = /* @__PURE__ */ new Map();
+  constructor(opts, tracked) {
+    this.opts = opts;
+    this.tracked = tracked;
+  }
+  /**
+   * Build a supervisor, allocating a port for every declared service (declared
+   * port if free, else ephemeral) and resolving each one's hostname + URL.
+   * Nothing is spawned yet.
+   */
+  static async create(opts) {
+    const tracked = /* @__PURE__ */ new Map();
+    const reserved = /* @__PURE__ */ new Set();
+    for (const svc of opts.services) {
+      const port = await allocatePort(svc.port, reserved);
+      reserved.add(port);
+      const hostname = serviceHostname({
+        script: svc.name,
+        branch: opts.ctx.branchName,
+        repo: opts.repo,
+        isDefaultBranch: opts.isDefaultBranch
+      });
+      const runtime = {
+        name: svc.name,
+        command: svc.command,
+        hostname,
+        port,
+        url: `http://${hostname}:${opts.proxyPort}`
+      };
+      tracked.set(svc.name, {
+        runtime,
+        child: null,
+        status: "exited",
+        exitCode: null,
+        startedAt: null
+      });
+    }
+    return new _ServiceSupervisor(opts, tracked);
+  }
+  /** Every declared service's resolved runtime (ports/urls), regardless of state. */
+  runtimes() {
+    return [...this.tracked.values()].map((t) => t.runtime);
+  }
+  /** Peers of `name` — every other declared service, as `PeerService` records. */
+  peersOf(name) {
+    return this.runtimes().filter((r) => r.name !== name).map((r) => ({ name: r.name, port: r.port, url: r.url }));
+  }
+  toStatus(t) {
+    return {
+      name: t.runtime.name,
+      hostname: t.runtime.hostname,
+      port: t.runtime.port,
+      url: t.runtime.url,
+      pid: t.child?.pid ?? null,
+      status: t.status,
+      exitCode: t.exitCode,
+      startedAt: t.startedAt
+    };
+  }
+  /**
+   * Start a declared service. Idempotent: returns the current status if it's
+   * already running. Injects `AGENTPROTO_PORT` / `AGENTPROTO_URL` for itself
+   * plus `AGENTPROTO_SERVICE_<PEER>_PORT|URL` for every sibling.
+   */
+  start(name) {
+    const t = this.tracked.get(name);
+    if (!t) throw new Error(`no service "${name}" declared in agentproto.json`);
+    if (t.status === "running" && t.child) return this.toStatus(t);
+    const env = {
+      ...hookEnv(this.opts.ctx),
+      [ENV_VARS.port]: String(t.runtime.port),
+      [ENV_VARS.url]: t.runtime.url,
+      ...peerEnv(this.peersOf(name))
+    };
+    const child = spawn(t.runtime.command, {
+      cwd: this.opts.ctx.worktreePath,
+      shell: true,
+      env: { ...process.env, ...env },
+      stdio: "inherit"
+    });
+    t.child = child;
+    t.status = "running";
+    t.exitCode = null;
+    t.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    child.on("exit", (code) => {
+      t.status = "exited";
+      t.exitCode = code;
+    });
+    child.on("error", () => {
+      t.status = "exited";
+      if (t.exitCode === null) t.exitCode = -1;
+    });
+    this.opts.proxyTable?.set(t.runtime.hostname, t.runtime.port);
+    return this.toStatus(t);
+  }
+  /** Stop a running service (SIGTERM). Returns whether one was running. */
+  async stop(name) {
+    const t = this.tracked.get(name);
+    if (!t) throw new Error(`no service "${name}" declared in agentproto.json`);
+    this.opts.proxyTable?.delete(t.runtime.hostname);
+    const child = t.child;
+    if (!child || t.status !== "running") return false;
+    return new Promise((resolve4) => {
+      const done = () => {
+        t.status = "exited";
+        resolve4(true);
+      };
+      child.once("exit", done);
+      child.kill("SIGTERM");
+    });
+  }
+  /** Stop every running service. */
+  async stopAll() {
+    await Promise.all([...this.tracked.keys()].map((name) => this.stop(name)));
+  }
+  /** Current status of a single service, or `undefined` if not declared. */
+  get(name) {
+    const t = this.tracked.get(name);
+    return t ? this.toStatus(t) : void 0;
+  }
+  /** Current status of every declared service. */
+  list() {
+    return [...this.tracked.values()].map((t) => this.toStatus(t));
+  }
+};
+
+// src/services/proxy-table.ts
+var ProxyTable = class {
+  routes = /* @__PURE__ */ new Map();
+  /** Register (or replace) the target port for a hostname. */
+  set(hostname, port) {
+    this.routes.set(hostname.toLowerCase(), port);
+  }
+  /** Remove a hostname's route. Returns whether it was present. */
+  delete(hostname) {
+    return this.routes.delete(hostname.toLowerCase());
+  }
+  /** The target port registered for an exact hostname, if any. */
+  get(hostname) {
+    return this.routes.get(hostname.toLowerCase());
+  }
+  /**
+   * Resolve a raw `Host` header (which may carry a `:port` suffix, and for
+   * IPv6 a bracketed host) to a target port.
+   */
+  lookup(hostHeader) {
+    if (!hostHeader) return void 0;
+    const host = stripPort(hostHeader).toLowerCase();
+    return this.routes.get(host);
+  }
+  /** All `[hostname, port]` routes currently registered. */
+  entries() {
+    return [...this.routes.entries()];
+  }
+  /** Number of registered routes. */
+  get size() {
+    return this.routes.size;
+  }
+};
+function stripPort(hostHeader) {
+  const trimmed = hostHeader.trim();
+  if (trimmed.startsWith("[")) {
+    const close = trimmed.indexOf("]");
+    return close === -1 ? trimmed : trimmed.slice(0, close + 1);
+  }
+  const colon = trimmed.indexOf(":");
+  return colon === -1 ? trimmed : trimmed.slice(0, colon);
+}
+function repoLabel(repoRoot) {
+  return basename(repoRoot.replace(/[/\\]+$/, ""));
+}
+async function detectDefaultBranch(repoRoot) {
+  const head = await execArgv(
+    "git",
+    ["-C", repoRoot, "symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+    repoRoot
+  );
+  if (head.exitCode === 0) {
+    const ref = head.stdout.trim();
+    const slash = ref.lastIndexOf("/");
+    if (slash !== -1) return ref.slice(slash + 1);
+    if (ref) return ref;
+  }
+  for (const candidate of ["main", "master"]) {
+    const exists = await execArgv(
+      "git",
+      ["-C", repoRoot, "rev-parse", "--verify", "--quiet", `refs/heads/${candidate}`],
+      repoRoot
+    );
+    if (exists.exitCode === 0) return candidate;
+  }
+  return "main";
+}
+
+// src/services/runtime.ts
+var supervisors = /* @__PURE__ */ new Map();
+var sharedProxyTable = new ProxyTable();
+var DEFAULT_PROXY_PORT = 18780;
+async function resolveSupervisor(input) {
+  const config = await loadConfigFromBase(input.repoRoot, input.base) ?? {};
+  const existing = supervisors.get(input.worktreePath);
+  if (existing) return { supervisor: existing, config };
+  const ctx = {
+    sourceCheckoutPath: input.repoRoot,
+    worktreePath: input.worktreePath,
+    branchName: input.branch
+  };
+  const defaultBranch = await detectDefaultBranch(input.repoRoot);
+  const supervisor = await ServiceSupervisor.create({
+    ctx,
+    services: listServices(config),
+    repo: repoLabel(input.repoRoot),
+    isDefaultBranch: input.branch === defaultBranch,
+    proxyPort: input.proxyPort ?? DEFAULT_PROXY_PORT,
+    proxyTable: sharedProxyTable
+  });
+  supervisors.set(input.worktreePath, supervisor);
+  return { supervisor, config };
+}
+function getSupervisor(worktreePath) {
+  return supervisors.get(worktreePath);
+}
+async function disposeSupervisor(worktreePath) {
+  const supervisor = supervisors.get(worktreePath);
+  if (!supervisor) return;
+  await supervisor.stopAll();
+  supervisors.delete(worktreePath);
+}
+async function computeTreeState(worktreePath) {
+  const res = await execArgv("git", ["-C", worktreePath, "status", "--porcelain=v2"], worktreePath);
+  if (res.exitCode !== 0) {
+    throw new Error(
+      `git status --porcelain=v2 failed in ${worktreePath} (exit ${res.exitCode}): ${res.stderr.trim() || res.stdout.trim()}`
+    );
+  }
+  let modified = 0;
+  let staged = 0;
+  let untracked = 0;
+  for (const line of res.stdout.split("\n")) {
+    if (!line) continue;
+    if (line.startsWith("? ")) {
+      untracked++;
+      continue;
+    }
+    if (line.startsWith("1 ") || line.startsWith("2 ") || line.startsWith("u ")) {
+      const xy = line.split(" ", 2)[1] ?? "..";
+      if (xy[0] !== ".") staged++;
+      if (xy[1] !== ".") modified++;
+    }
+  }
+  if (modified === 0 && staged === 0 && untracked === 0) return { state: "clean" };
+  return { state: "dirty", modified, staged, untracked, newestMtimeMs: await newestDirtyMtimeMs(worktreePath) };
+}
+async function newestDirtyMtimeMs(worktreePath) {
+  const [unstaged, staged, untracked] = await Promise.all([
+    execArgv("git", ["-C", worktreePath, "diff", "--name-only", "-z"], worktreePath),
+    execArgv("git", ["-C", worktreePath, "diff", "--cached", "--name-only", "-z"], worktreePath),
+    execArgv("git", ["-C", worktreePath, "ls-files", "--others", "--exclude-standard", "-z"], worktreePath)
+  ]);
+  const paths = /* @__PURE__ */ new Set();
+  for (const res of [unstaged, staged, untracked]) {
+    if (res.exitCode !== 0) continue;
+    for (const p of res.stdout.split("\0")) if (p) paths.add(p);
+  }
+  let newest = null;
+  for (const p of paths) {
+    try {
+      const st = await stat(resolve(worktreePath, p));
+      if (newest === null || st.mtimeMs > newest) newest = st.mtimeMs;
+    } catch {
+    }
+  }
+  return newest;
+}
+var integrationBase = { checkedAt: z.string() };
+var integrationStateSchema = z.union([
+  z.object({ ...integrationBase, state: z.literal("fresh") }),
+  z.object({
+    ...integrationBase,
+    state: z.literal("merged"),
+    via: z.literal("squash"),
+    pr: z.number(),
+    offline: z.boolean()
+  }),
+  z.object({
+    ...integrationBase,
+    state: z.literal("partial"),
+    pr: z.number(),
+    aheadBy: z.number(),
+    offline: z.boolean()
+  }),
+  z.object({ ...integrationBase, state: z.literal("open"), pr: z.number(), offline: z.boolean() }),
+  z.object({ ...integrationBase, state: z.literal("pushed-no-pr") }),
+  z.object({ ...integrationBase, state: z.literal("unpushed"), aheadBy: z.number() }),
+  z.object({ ...integrationBase, state: z.literal("local-only") }),
+  z.object({ ...integrationBase, state: z.literal("gone-unexplained") }),
+  z.object({ ...integrationBase, state: z.literal("diverged"), offline: z.boolean() }),
+  z.object({ ...integrationBase, state: z.literal("detached") }),
+  z.object({ ...integrationBase, state: z.literal("unknown"), reason: z.literal("offline") })
+]);
+var verdictMemoRecordSchema = z.object({
+  repo: z.string(),
+  branch: z.string(),
+  tipSha: z.string(),
+  verdict: integrationStateSchema,
+  checkedAt: z.string()
+});
+var verdictMemoFileSchema = z.object({ entries: z.array(verdictMemoRecordSchema) });
+var VERDICT_MEMO_PATH = () => resolve(homedir(), ".agentproto", "worktree-verdicts.json");
+function memoKey(repo, branch, tipSha) {
+  return `${repo}\0${branch}\0${tipSha}`;
+}
+var FileVerdictMemoStore = class {
+  constructor(path = VERDICT_MEMO_PATH()) {
+    this.path = path;
+  }
+  path;
+  cache = null;
+  async load() {
+    if (this.cache) return this.cache;
+    const map = /* @__PURE__ */ new Map();
+    this.cache = map;
+    let raw;
+    try {
+      raw = await readFile(this.path, "utf8");
+    } catch {
+      return map;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return map;
+    }
+    const result = verdictMemoFileSchema.safeParse(parsed);
+    if (!result.success) return map;
+    for (const entry of result.data.entries) map.set(memoKey(entry.repo, entry.branch, entry.tipSha), entry);
+    return map;
+  }
+  async get(repo, branch, tipSha) {
+    const map = await this.load();
+    return map.get(memoKey(repo, branch, tipSha)) ?? null;
+  }
+  async set(record) {
+    const map = await this.load();
+    map.set(memoKey(record.repo, record.branch, record.tipSha), record);
+    await mkdir(dirname(this.path), { recursive: true });
+    await writeFile(this.path, JSON.stringify({ entries: [...map.values()] }, null, 2) + "\n", "utf8");
+  }
+};
+var InMemoryVerdictMemoStore = class {
+  map = /* @__PURE__ */ new Map();
+  async get(repo, branch, tipSha) {
+    return this.map.get(memoKey(repo, branch, tipSha)) ?? null;
+  }
+  async set(record) {
+    this.map.set(memoKey(record.repo, record.branch, record.tipSha), record);
+  }
+};
+async function isAncestor(repoRoot, ancestor, descendant) {
+  const res = await execArgv(
+    "git",
+    ["-C", repoRoot, "merge-base", "--is-ancestor", ancestor, descendant],
+    repoRoot
+  );
+  if (res.exitCode === 0) return true;
+  if (res.exitCode === 1) return false;
+  throw new Error(
+    `git merge-base --is-ancestor ${ancestor} ${descendant} failed (exit ${res.exitCode}): ${res.stderr.trim()}`
+  );
+}
+async function revListCount(repoRoot, range) {
+  const res = await execGit(repoRoot, ["rev-list", "--count", range]);
+  return Number.parseInt(res.stdout.trim(), 10);
+}
+async function readUpstreamTrack(repoRoot, branch) {
+  const res = await execArgv(
+    "git",
+    ["-C", repoRoot, "for-each-ref", "--format=%(upstream)%09%(upstream:track)", `refs/heads/${branch}`],
+    repoRoot
+  );
+  if (res.exitCode !== 0) return { upstream: null, gone: false, aheadBy: 0 };
+  const [rawUpstream, rawTrack] = res.stdout.split("	");
+  const upstream = (rawUpstream ?? "").trim();
+  if (!upstream) return { upstream: null, gone: false, aheadBy: 0 };
+  const track = (rawTrack ?? "").trim();
+  const aheadMatch = track.match(/ahead (\d+)/);
+  return {
+    upstream,
+    gone: track.includes("[gone]"),
+    aheadBy: aheadMatch ? Number.parseInt(aheadMatch[1] ?? "0", 10) : 0
+  };
+}
+async function listGitWorktrees(repoRoot) {
+  const res = await execGit(repoRoot, ["worktree", "list", "--porcelain"]);
+  const entries = [];
+  let current = null;
+  for (const line of res.stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current) entries.push(current);
+      current = { path: line.slice("worktree ".length), branch: null, head: "" };
+    } else if (current && line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length);
+    } else if (current && line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+    } else if (current && line === "detached") {
+      current.branch = null;
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+function newestMergedFirst(prs) {
+  return prs.filter((pr) => pr.merged).slice().sort((a, b) => (b.mergedAt ?? "").localeCompare(a.mergedAt ?? ""));
+}
+function dedupeByNumber(prs) {
+  const byNumber = /* @__PURE__ */ new Map();
+  for (const pr of prs) byNumber.set(pr.number, pr);
+  return [...byNumber.values()];
+}
+async function reconcileIntegration(input) {
+  const now = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const defaultBranchRef = input.defaultBranchRef ?? "origin/main";
+  if (input.branch === null) {
+    return { state: "detached", checkedAt: now() };
+  }
+  const branch = input.branch;
+  const ancestryOk = await isAncestor(input.repoRoot, input.tipSha, defaultBranchRef).catch(() => false);
+  if (ancestryOk) {
+    return { state: "fresh", checkedAt: now() };
+  }
+  let candidatePrs;
+  try {
+    const [byBranch, byCommit] = await Promise.all([
+      input.forge.pullRequestsForBranch(branch),
+      input.forge.pullRequestsForCommit(input.tipSha)
+    ]);
+    candidatePrs = dedupeByNumber([...byBranch, ...byCommit]);
+  } catch {
+    return reconcileOffline(input, now());
+  }
+  let verdict;
+  try {
+    verdict = await classifyAgainstPulls(input.repoRoot, input.tipSha, candidatePrs, now, input.forge);
+  } catch {
+    return reconcileOffline(input, now());
+  }
+  if (verdict) {
+    await input.memo.set({ repo: input.repoName, branch, tipSha: input.tipSha, verdict, checkedAt: verdict.checkedAt }).catch(() => {
+    });
+    return verdict;
+  }
+  const upstream = await readUpstreamTrack(input.repoRoot, branch);
+  if (upstream.upstream === null) return { state: "local-only", checkedAt: now() };
+  if (upstream.gone) return { state: "gone-unexplained", checkedAt: now() };
+  if (upstream.aheadBy > 0) return { state: "unpushed", aheadBy: upstream.aheadBy, checkedAt: now() };
+  return { state: "pushed-no-pr", checkedAt: now() };
+}
+async function classifyAgainstPulls(repoRoot, tipSha, candidatePrs, now, forge) {
+  for (const pr of newestMergedFirst(candidatePrs)) {
+    const H = pr.headRefOid;
+    await forge.ensurePullHeadFetched(pr.number, H);
+    if (await isAncestor(repoRoot, tipSha, H)) {
+      return { state: "merged", via: "squash", pr: pr.number, checkedAt: now(), offline: false };
+    }
+    if (await isAncestor(repoRoot, H, tipSha)) {
+      const aheadBy = await revListCount(repoRoot, `${H}..${tipSha}`);
+      return { state: "partial", pr: pr.number, aheadBy, checkedAt: now(), offline: false };
+    }
+  }
+  const [firstOpenPr] = candidatePrs.filter((pr) => pr.state === "open").sort((a, b) => a.number - b.number);
+  if (firstOpenPr) {
+    return { state: "open", pr: firstOpenPr.number, checkedAt: now(), offline: false };
+  }
+  if (newestMergedFirst(candidatePrs).length > 0) {
+    return { state: "diverged", checkedAt: now(), offline: false };
+  }
+  return null;
+}
+async function reconcileOffline(input, checkedAt) {
+  if (input.branch === null) return { state: "detached", checkedAt };
+  const cached = await input.memo.get(input.repoName, input.branch, input.tipSha);
+  if (cached) {
+    return offlineCopy(cached.verdict, checkedAt);
+  }
+  return { state: "unknown", reason: "offline", checkedAt };
+}
+function offlineCopy(verdict, checkedAt) {
+  if (verdict.state === "merged" && verdict.via === "squash") {
+    return { ...verdict, checkedAt, offline: true };
+  }
+  if (verdict.state === "partial" || verdict.state === "open" || verdict.state === "diverged") {
+    return { ...verdict, checkedAt, offline: true };
+  }
+  return verdict;
+}
+var LIVE_SESSION_STATUSES = /* @__PURE__ */ new Set(["starting", "running"]);
+async function computeLiveness(worktreePath, options = {}) {
+  const registry = await readSessionsRegistry(options.sessionsPath ?? SESSIONS_FILE_PATH());
+  if (registry === null) return { state: "daemon-unreachable", sessions: [], services: [] };
+  const live = registry.filter((s) => sessionInWorktree(s, worktreePath)).filter((s) => LIVE_SESSION_STATUSES.has(s.status));
+  if (live.length > 0) return { state: "sessions", sessions: live, services: [] };
+  return { state: "idle", sessions: [], services: [] };
+}
+var RECENT_WRITE_HOLD_WINDOW_MS = 15 * 60 * 1e3;
+function classify(tree, integration, liveness, nowMs = Date.now()) {
+  const merged = integration.state === "merged";
+  const fresh = integration.state === "fresh";
+  const clean = tree.state === "clean";
+  const idleOrUnreachable = liveness.state === "idle" || liveness.state === "daemon-unreachable";
+  if ((merged || fresh) && clean && idleOrUnreachable) return { reclaimable: true, class: "reclaim" };
+  if (merged && !clean) {
+    const writtenRecently = tree.state === "dirty" && typeof tree.newestMtimeMs === "number" && nowMs - tree.newestMtimeMs < RECENT_WRITE_HOLD_WINDOW_MS;
+    if (writtenRecently) return { reclaimable: false, class: "hold" };
+    return { reclaimable: false, class: "salvage" };
+  }
+  return { reclaimable: false, class: "hold" };
+}
+async function computeWorktreeStatus(input) {
+  const [tree, integration, liveness, provenance] = await Promise.all([
+    computeTreeState(input.worktree.path),
+    reconcileIntegration({
+      repoRoot: input.repoRoot,
+      repoName: input.repoName,
+      branch: input.worktree.branch,
+      tipSha: input.worktree.head,
+      forge: input.forge,
+      memo: input.memo,
+      defaultBranchRef: input.defaultBranchRef,
+      now: input.now
+    }),
+    computeLiveness(input.worktree.path, { sessionsPath: input.sessionsPath }),
+    computeProvenance(input.worktree.path, { sessionsPath: input.sessionsPath })
+  ]);
+  const { reclaimable, class: cls } = classify(tree, integration, liveness, input.nowMs);
+  return {
+    path: input.worktree.path,
+    branch: input.worktree.branch,
+    head: input.worktree.head,
+    tree,
+    integration,
+    liveness,
+    provenance,
+    gate: { state: "none" },
+    reclaimable,
+    class: cls
+  };
+}
+async function listWorktreeStatuses(input) {
+  const worktrees = await listGitWorktrees(input.repoRoot);
+  const results = [];
+  for (const worktree of worktrees) {
+    results.push(
+      await computeWorktreeStatus({
+        repoRoot: input.repoRoot,
+        repoName: input.repoName,
+        worktree,
+        forge: input.forge,
+        memo: input.memo,
+        defaultBranchRef: input.defaultBranchRef,
+        sessionsPath: input.sessionsPath,
+        now: input.now
+      })
+    );
+  }
+  return results;
+}
+
+// src/provider/bodies/cleanup-worktree.body.ts
+var WorktreeNotRemovableError = class extends Error {
+  cwd;
+  blocked;
+  /**
+   * `blocked` is empty when git itself refused without us categorizing the
+   * tree first (the no-flags default path, PLAN.md §5.2 layer 3) — `detail`
+   * then carries git's own stderr instead of a named class.
+   */
+  constructor(cwd, blocked, detail) {
+    const flags = blocked.map((b) => b === "untracked" ? "discardUntracked" : "discardModified");
+    const message = blocked.length > 0 ? `worktree at ${cwd} has ${blocked.join(" and ")} changes; refusing to remove. Pass ${flags.join(" and ")} to authorize discarding ${blocked.length > 1 ? "them" : "it"}, or use 'worktree archive' to salvage first.` : `worktree at ${cwd} is not clean; git refused to remove it${detail ? `: ${detail}` : ""}. Pass discardUntracked/discardModified to authorize discarding, or use 'worktree archive' to salvage first.`;
+    super(message);
+    this.name = "WorktreeNotRemovableError";
+    this.cwd = cwd;
+    this.blocked = blocked;
+  }
+};
+var cleanupWorktreeBuiltin = implementTool(
+  cleanupWorktreeTool,
+  async ({ input }) => {
+    await disposeSupervisor(input.cwd);
+    if (input.runTeardown !== false) {
+      const config = await loadConfigFromBase(input.repoRoot, input.base).catch(() => null);
+      if (config) {
+        const runs = await runTeardown(config, {
+          sourceCheckoutPath: input.repoRoot,
+          worktreePath: input.cwd,
+          branchName: input.branch ?? ""
+        }).catch((err) => {
+          process.stderr.write(
+            `worktree.cleanup: teardown hook error (ignored): ${err instanceof Error ? err.message : String(err)}
+`
+          );
+          return [];
+        });
+        for (const run of runs) {
+          if (run.result.exitCode !== 0) {
+            process.stderr.write(
+              `worktree.cleanup: teardown '${run.command}' exited ${run.result.exitCode} (ignored): ${(run.result.stderr || run.result.stdout).trim()}
+`
+            );
+          }
+        }
+      }
+    }
+    const discardUntracked = input.discardUntracked === true;
+    const discardModified = input.discardModified === true;
+    if (discardUntracked || discardModified) {
+      const tree = await computeTreeState(input.cwd);
+      if (tree.state === "dirty") {
+        const blocked = [];
+        if (tree.untracked > 0 && !discardUntracked) blocked.push("untracked");
+        if ((tree.modified > 0 || tree.staged > 0) && !discardModified) blocked.push("modified");
+        if (blocked.length > 0) throw new WorktreeNotRemovableError(input.cwd, blocked);
+        await execGit(input.repoRoot, ["worktree", "remove", "--force", input.cwd]);
+      } else {
+        await execGit(input.repoRoot, ["worktree", "remove", input.cwd]);
+      }
+    } else {
+      try {
+        await execGit(input.repoRoot, ["worktree", "remove", input.cwd]);
+      } catch (err) {
+        throw new WorktreeNotRemovableError(input.cwd, [], err instanceof Error ? err.message : String(err));
+      }
+    }
+    if (input.deleteBranch && input.branch) {
+      await execGit(input.repoRoot, ["branch", "-D", input.branch]);
+    }
+    return { removed: true };
+  }
+);
+var runGateBuiltin = implementTool(runGateTool, async ({ input }) => {
+  const result = await execShell(input.cmd, input.cwd);
+  return { passed: result.exitCode === 0, ...result };
+});
+var runScriptBuiltin = implementTool(runScriptTool, async ({ input }) => {
+  const config = await loadConfigFromBase(input.repoRoot, input.base);
+  const script = config ? getScript(config, input.script) : void 0;
+  if (!script) {
+    throw new ToolError({
+      code: "not_found",
+      message: `no script "${input.script}" in ${input.base ?? "origin/main"}:agentproto.json`
+    });
+  }
+  const env = hookEnv({
+    sourceCheckoutPath: input.repoRoot,
+    worktreePath: input.worktreePath,
+    branchName: input.branch
+  });
+  const result = await execShell(script.command, input.worktreePath, { env });
+  return { passed: result.exitCode === 0, ...result };
+});
+var startServiceBuiltin = implementTool(startServiceTool, async ({ input }) => {
+  const { supervisor } = await resolveSupervisor({
+    repoRoot: input.repoRoot,
+    worktreePath: input.worktreePath,
+    branch: input.branch,
+    base: input.base,
+    proxyPort: input.proxyPort
+  });
+  if (!supervisor.get(input.script)) {
+    throw new ToolError({
+      code: "not_found",
+      message: `no service "${input.script}" declared (type: "service") in ${input.base ?? "origin/main"}:agentproto.json`
+    });
+  }
+  return supervisor.start(input.script);
+});
+var stopServiceBuiltin = implementTool(stopServiceTool, async ({ input }) => {
+  const supervisor = getSupervisor(input.worktreePath);
+  if (!supervisor) return { stopped: false };
+  const stopped = await supervisor.stop(input.script);
+  return { stopped };
+});
+var listServicesBuiltin = implementTool(listServicesTool, async ({ input }) => {
+  const { supervisor } = await resolveSupervisor({
+    repoRoot: input.repoRoot,
+    worktreePath: input.worktreePath,
+    branch: input.branch,
+    base: input.base,
+    proxyPort: input.proxyPort
+  });
+  return { services: supervisor.list() };
+});
+
+// src/provider/worktree-provider.ts
+var worktreeProvider = defineDriver({
+  id: "worktree-builtin",
+  name: "Git Worktree (built-in)",
+  description: "In-process provision / gate / cleanup of git worktrees via direct git and shell invocations. No sandboxing \u2014 the host owns the filesystem and process boundary.",
+  version: "0.1.0",
+  kind: "builtin",
+  implements: [
+    { tool: "worktree.provision", version: "0.2.0" },
+    { tool: "worktree.cleanup", version: "0.2.0" },
+    { tool: "worktree.run-gate", version: "0.1.0" },
+    { tool: "worktree.run-script", version: "0.1.0" },
+    { tool: "worktree.start-service", version: "0.1.0" },
+    { tool: "worktree.stop-service", version: "0.1.0" },
+    { tool: "worktree.list-services", version: "0.1.0" }
+  ],
+  implementations: [
+    provisionWorktreeBuiltin,
+    cleanupWorktreeBuiltin,
+    runGateBuiltin,
+    runScriptBuiltin,
+    startServiceBuiltin,
+    stopServiceBuiltin,
+    listServicesBuiltin
+  ]
+});
+
+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 };
+//# sourceMappingURL=chunk-SEVCUXPY.mjs.map
+//# sourceMappingURL=chunk-SEVCUXPY.mjs.map