@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/watch.js

@@ -0,0 +1,195 @@
+import { git } from "./git.js";
+import { CODEFLOW_MARKER, failedLogs, GH_AUTH_ERROR, ghAuthStatus, githubUser, prChecks, prStatus, safeFence } from "./github.js";
+import { logWarn } from "./log.js";
+const ACTIVE = /* @__PURE__ */ new Set(["watching", "fixing", "green"]);
+const FAILURES_BEFORE_NEEDS_YOU = 3;
+const MAX_BACKOFF_MS = 30 * 6e4;
+const MAX_QUIET_MS = 10 * 6e4;
+class PrWatcher {
+  constructor(manager, intervalMs = Number(process.env.CODEFLOW_WATCH_INTERVAL_MS) || 6e4) {
+    this.manager = manager;
+    this.intervalMs = intervalMs;
+  }
+  timer;
+  polling;
+  stopped = false;
+  /** Watches whose polls are failing, by `<run id>/<branch>`; forgotten on restart. */
+  failing = /* @__PURE__ */ new Map();
+  /** Watches with nothing to do lately, by `<run id>/<branch>`; forgotten on restart. */
+  quiet = /* @__PURE__ */ new Map();
+  start() {
+    if (this.timer) return;
+    this.stopped = false;
+    this.timer = setInterval(() => void this.poll(), this.intervalMs);
+    this.timer.unref?.();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    return this.polling;
+  }
+  /** One pass over every active watch; concurrent calls share the pass in progress. `now` is for tests. */
+  poll(now) {
+    if (this.stopped) return Promise.resolve();
+    this.polling ??= this.pollAll(now).finally(() => this.polling = void 0);
+    return this.polling;
+  }
+  async pollAll(now = Date.now()) {
+    for (const run of this.manager.watchedRuns()) {
+      for (const watch of Object.values(run.watches)) {
+        if (this.stopped) return;
+        const key = `${run.id}/${watch.branch}`;
+        const failing = this.failing.get(key);
+        const retrying = watch.state === "needs-you" && !!failing;
+        if (!ACTIVE.has(watch.state) && !retrying || run.status === "running" || run.archived) {
+          if (!retrying) this.failing.delete(key);
+          this.quiet.delete(key);
+          continue;
+        }
+        if (failing && failing.nextAt > now) continue;
+        if ((this.quiet.get(key)?.nextAt ?? 0) > now) continue;
+        try {
+          this.noteQuiet(key, await this.pollOne(run, watch), now);
+          this.failing.delete(key);
+        } catch (err) {
+          this.quiet.delete(key);
+          await this.pollFailed(run, watch, key, err, now);
+        }
+      }
+    }
+  }
+  /** After a poll: `seen` is what a poll with nothing to do found (undefined when it found something). */
+  noteQuiet(key, seen, now) {
+    if (!seen) {
+      this.quiet.delete(key);
+      return;
+    }
+    const prev = this.quiet.get(key);
+    const count = prev?.seen === seen ? prev.count + 1 : 1;
+    const wait = Math.min(MAX_QUIET_MS, this.intervalMs * 2 ** Math.min(count - 1, 20));
+    this.quiet.set(key, { count, seen, nextAt: wait > this.intervalMs ? now + wait - this.intervalMs / 2 : 0 });
+  }
+  /** Count a failed poll and wait longer before the next; the third in a row hands the PR to you. */
+  async pollFailed(run, watch, key, err, now) {
+    const count = (this.failing.get(key)?.count ?? 0) + 1;
+    let error = err.message;
+    if (count === 1 || GH_AUTH_ERROR.test(error)) {
+      const auth = await ghAuthStatus(run.repo).catch(() => void 0);
+      if (auth && !auth.ok) error = `gh isn't signed in \u2014 run \`gh auth login\`${auth.message ? ` (gh auth status: ${auth.message.slice(0, 200)})` : ""}`;
+    }
+    const wait = Math.min(MAX_BACKOFF_MS, this.intervalMs * 2 ** (count - 1));
+    this.failing.set(key, { count, nextAt: now + wait, error });
+    const detail = `Couldn't check the PR ${count} time${count === 1 ? "" : "s"} in a row: ${error}`;
+    if (count >= FAILURES_BEFORE_NEEDS_YOU) {
+      if (count === FAILURES_BEFORE_NEEDS_YOU) logWarn(`PR watch on ${watch.pr} keeps failing`, { run: run.id, error });
+      this.manager.updateWatch(run.id, watch.branch, { state: "needs-you", detail, lastPolled: now });
+    } else {
+      this.manager.updateWatch(run.id, watch.branch, { detail, lastPolled: now });
+    }
+  }
+  /** One poll. Returns what it found when there was nothing to do (green, no new comments), else undefined. */
+  async pollOne(run, w) {
+    const update = (patch) => {
+      this.manager.updateWatch(run.id, w.branch, { lastPolled: Date.now(), ...patch });
+      return void 0;
+    };
+    const status = await prStatus(run.repo, w.pr);
+    if (status.state !== "OPEN") {
+      return update({ state: "closed", detail: status.state === "MERGED" ? "The pull request was merged" : "The pull request was closed" });
+    }
+    if (status.commentsTruncated) return update({ state: "needs-you", detail: "The PR has at least 1,000 inline review comments; review its complete discussion before restarting follow-through" });
+    if (w.state === "fixing" || run.status !== "done") {
+      return update({ state: "needs-you", detail: `The run is ${run.status}; resume it, then watch again` });
+    }
+    const worktree = run.worktrees.find((x) => x.branch === w.branch);
+    if (!worktree) return update({ state: "needs-you", detail: "The branch's worktree is gone" });
+    const seen = new Set(w.seenComments ?? status.comments.filter((c) => Date.parse(c.createdAt) < w.startedAt).map((c) => c.id));
+    if (!w.seenComments) {
+      this.manager.log(run.id, `Watching ${w.pr}: line comments on the diff (review threads) aren't read yet; only PR comments and review summaries reach the agent`);
+    }
+    const fresh = status.comments.filter((c) => !seen.has(c.id));
+    const seenComments = [...seen, ...fresh.map((c) => c.id)];
+    const me = await githubUser(run.repo).catch(() => "");
+    const allowed = new Set([me, ...w.allow ?? []].filter(Boolean).map((login) => login.toLowerCase()));
+    const actionable = fresh.filter((c) => !c.body.includes(CODEFLOW_MARKER) && allowed.has(c.author.toLowerCase()));
+    for (const c of fresh) {
+      if (!c.body.includes(CODEFLOW_MARKER) && !actionable.includes(c)) {
+        this.manager.log(
+          run.id,
+          `Ignored a PR comment from @${c.author} (${c.association || "no association"}): only you${w.allow?.length ? ` and ${w.allow.map((a) => `@${a}`).join(", ")}` : ""} can direct agents on this watch`,
+          "warn"
+        );
+      }
+    }
+    const synced = (await git(["merge-base", "--is-ancestor", status.headRefOid, w.branch], run.repo)).code === 0;
+    if (actionable.length) {
+      if (!synced) return update({ seenComments, state: "needs-you", detail: "The PR has commits code-flow doesn't have" });
+      if (w.fixes >= w.maxFixes) return update({ seenComments, state: "needs-you", detail: `New comments after ${w.fixes} fixes; over to you` });
+      const who = [...new Set(actionable.map((c) => `@${c.author}`))].join(", ");
+      update({ seenComments, state: "fixing", fixes: w.fixes + 1, detail: `Addressing ${actionable.length} new comment${actionable.length === 1 ? "" : "s"} from ${who}` });
+      await this.manager.followUp(run.id, {
+        kind: "comments",
+        worktree: worktree.name,
+        agent: w.agent,
+        from: `${who} on the pull request`,
+        message: actionable.map((c) => {
+          const location = c.path ? `File: ${c.path}${c.line ? `:${c.line}` : ""}${c.side ? ` (${c.side.toLowerCase()} side)` : ""}${c.outdated ? " [outdated diff]" : ""}` : "";
+          return `@${c.author}:
+${safeFence([location, c.threadId ? `Thread: ${c.threadId}` : "", c.body.trim()].filter(Boolean).join("\n\n"))}`;
+        }).join("\n\n"),
+        push: w.remoteBranch,
+        watch: w.branch,
+        trust: unattendedTrust(run)
+      });
+      return;
+    }
+    const checks = await prChecks(run.repo, w.pr);
+    const failing = checks.filter((c) => c.bucket === "fail");
+    const counts = {
+      pass: checks.filter((c) => c.bucket === "pass" || c.bucket === "skipping").length,
+      fail: failing.length,
+      pending: checks.filter((c) => c.bucket === "pending").length
+    };
+    if (counts.pending) return update({ seenComments, checks: counts, state: "watching", detail: `CI is running (${counts.pending} pending)` });
+    if (!counts.fail) {
+      update({ seenComments, checks: counts, state: "green", detail: checks.length ? "All checks pass" : "No CI checks reported" });
+      return fresh.length ? void 0 : `${status.headRefOid} ${counts.pass}/${counts.fail}/${counts.pending} ${w.startedAt}`;
+    }
+    if (w.fixedHeads.includes(status.headRefOid)) {
+      return update({ seenComments, checks: counts, state: "needs-you", detail: "CI still fails on a commit code-flow already tried to fix" });
+    }
+    if (w.fixes >= w.maxFixes) return update({ seenComments, checks: counts, state: "needs-you", detail: `CI still fails after ${w.fixes} fixes; over to you` });
+    if (!synced) return update({ seenComments, checks: counts, state: "needs-you", detail: "The PR has commits code-flow doesn't have" });
+    const logs = await failedLogs(run.repo, checks, 8e3);
+    update({
+      seenComments,
+      checks: counts,
+      state: "fixing",
+      fixes: w.fixes + 1,
+      fixedHeads: [...w.fixedHeads, status.headRefOid],
+      detail: `Fixing ${failing.map((c) => c.name).join(", ")} (fix ${w.fixes + 1} of ${w.maxFixes})`
+    });
+    await this.manager.followUp(run.id, {
+      kind: "ci-fix",
+      worktree: worktree.name,
+      agent: w.agent,
+      message: `Failing checks:
+${failing.map((c) => `- ${c.name}${c.link ? ` (${c.link})` : ""}`).join("\n")}` + (logs ? `
+
+Logs of the failed jobs:
+${safeFence(logs)}` : "\n\n(No logs available; reproduce the failure locally.)"),
+      push: w.remoteBranch,
+      watch: w.branch,
+      trust: unattendedTrust(run)
+    });
+  }
+}
+function unattendedTrust(run) {
+  return run.trust === "trusted" || run.trust === "full" ? "standard" : run.trust;
+}
+export {
+  FAILURES_BEFORE_NEEDS_YOU,
+  PrWatcher,
+  unattendedTrust
+};

package/src/work-queue.js

@@ -0,0 +1,47 @@
+class WorkQueue {
+  constructor(concurrency = 4) {
+    this.concurrency = concurrency;
+  }
+  tails = /* @__PURE__ */ new Map();
+  ready = [];
+  active = 0;
+  pending = 0;
+  bytes = 0;
+  get stats() {
+    return { active: this.active, pending: this.pending, bytes: this.bytes, keys: this.tails.size };
+  }
+  run(key, operation, bytes = 0) {
+    this.pending++;
+    this.bytes += bytes;
+    const work = (this.tails.get(key) ?? Promise.resolve()).then(async () => {
+      await new Promise((resolve) => {
+        const grant = () => {
+          this.active++;
+          resolve();
+        };
+        if (this.active < this.concurrency) grant();
+        else this.ready.push(grant);
+      });
+      try {
+        return await operation();
+      } finally {
+        this.active--;
+        this.pending--;
+        this.bytes -= bytes;
+        this.ready.shift()?.();
+      }
+    });
+    const settled = work.then(() => void 0, () => void 0);
+    this.tails.set(key, settled);
+    void settled.then(() => {
+      if (this.tails.get(key) === settled) this.tails.delete(key);
+    });
+    return work;
+  }
+  async flush(key) {
+    await Promise.all(key === void 0 ? [...this.tails.values()] : [this.tails.get(key)]);
+  }
+}
+export {
+  WorkQueue
+};

package/src/workflow-control.js

@@ -0,0 +1,83 @@
+import { planProblem } from "./patterns/auto-team-model.js";
+class TeamPlanEditError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+}
+const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const boundedText = (value, max, empty = false) => typeof value === "string" && value.length <= max && !value.includes("\0") && (empty || !!value.trim());
+const identifiers = /^[a-z][a-z0-9-]{0,39}$/;
+const clamp = (value, fallback, min, max) => typeof value === "number" && Number.isFinite(value) ? Math.max(min, Math.min(max, Math.floor(value))) : fallback;
+function strings(value, count, maxLength, label) {
+  if (!Array.isArray(value) || value.length > count || value.some((item) => !boundedText(item, maxLength))) throw new TeamPlanEditError(`${label} must contain at most ${count} bounded, nonempty strings.`);
+  if (new Set(value).size !== value.length) throw new TeamPlanEditError(`${label} must not contain duplicates.`);
+  return [...value];
+}
+function editableTeamPlan(team) {
+  return { revision: team.revision, rationale: team.rationale, contracts: [...team.contracts], tasks: team.tasks.map(({ id, title, instructions, owner, kind, dependsOn, dependencyTypes, requirements, acceptance, paths }) => ({ id, title, instructions, owner, kind, dependsOn: [...dependsOn], ...dependencyTypes ? { dependencyTypes: { ...dependencyTypes } } : {}, requirements: [...requirements], acceptance: [...acceptance], paths: [...paths] })) };
+}
+function teamPlanPolicy(team, input) {
+  const coordinator = input.roles.coordinator?.[0];
+  if (!coordinator || !team.inventory) throw new TeamPlanEditError("The original provider inventory is unavailable; ask the coordinator for a revised plan instead.");
+  return { coordinator, pool: [...input.roles.pool ?? []], inventory: structuredClone(team.inventory), maxMembers: clamp(input.options.maxMembers, 4, 2, 6), maxTasks: clamp(input.options.maxTasks, 12, 1, 24), differentProviderReview: input.options.differentProviderReview === true };
+}
+function validateTeamPlanEdit(value, team, policy) {
+  if (team.status !== "awaiting_approval" || team.tasks.some((task) => task.status && task.status !== "pending" || (task.attempts ?? 0) > 0 || task.startedAt !== void 0 || task.finishedAt !== void 0 || task.head || task.artifacts?.length)) throw new TeamPlanEditError("This team has already started work. Edit a new pending plan instead.", 409);
+  if (!object(value) || Object.keys(value).some((key) => !["revision", "tasks", "contracts", "rationale"].includes(key))) throw new TeamPlanEditError("Only tasks, contracts and rationale may be edited. Members and requirements stay fixed.");
+  if (!Number.isSafeInteger(value.revision) || value.revision !== team.revision) throw new TeamPlanEditError("The plan changed while you were editing. Refresh the plan and merge your edits before saving.", 409);
+  if (!Array.isArray(value.tasks) || value.tasks.length < 1 || value.tasks.length > policy.maxTasks) throw new TeamPlanEditError(`Keep between 1 and ${policy.maxTasks} tasks.`);
+  const tasks = value.tasks.map((item, index) => {
+    if (!object(item) || Object.keys(item).some((key) => !["id", "title", "instructions", "owner", "kind", "dependsOn", "dependencyTypes", "requirements", "acceptance", "paths"].includes(key))) throw new TeamPlanEditError(`Task ${index + 1} contains unsupported or runtime fields.`);
+    if (typeof item.id !== "string" || !identifiers.test(item.id) || typeof item.owner !== "string" || !identifiers.test(item.owner) || !boundedText(item.title, 180) || !boundedText(item.instructions, 16e3) || !["implementation", "investigation"].includes(String(item.kind))) throw new TeamPlanEditError(`Task ${index + 1} needs a valid ID, owner, title, kind and instructions.`);
+    const dependsOn = strings(item.dependsOn, policy.maxTasks, 40, `${item.id} dependencies`);
+    let dependencyTypes;
+    if (item.dependencyTypes !== void 0) {
+      if (!object(item.dependencyTypes) || Object.keys(item.dependencyTypes).length > policy.maxTasks || Object.entries(item.dependencyTypes).some(([id, kind]) => !dependsOn.includes(id) || !["completion", "artifact", "knowledge"].includes(String(kind)))) throw new TeamPlanEditError(`${item.id} contains invalid dependency types.`);
+      dependencyTypes = { ...item.dependencyTypes };
+    }
+    return { id: item.id, title: item.title, instructions: item.instructions, owner: item.owner, kind: item.kind, dependsOn, ...dependencyTypes ? { dependencyTypes } : {}, requirements: strings(item.requirements, 48, 40, `${item.id} requirements`), acceptance: strings(item.acceptance, 16, 2e3, `${item.id} acceptance criteria`), paths: strings(item.paths, 64, 500, `${item.id} paths`), status: "pending", attempts: 0 };
+  });
+  if (!boundedText(value.rationale, 4e3, true)) throw new TeamPlanEditError("Rationale must be text of at most 4,000 characters.");
+  const plan = { requirements: structuredClone(team.requirements), members: structuredClone(team.members), tasks, contracts: strings(value.contracts, 24, 8e3, "Shared contracts"), rationale: value.rationale };
+  if (team.templateUses?.length) {
+    for (const original of team.tasks.filter((task) => team.templateUses.some((use) => task.id.startsWith(`${use.id}-`)))) {
+      const edited = tasks.find((task) => task.id === original.id);
+      if (!edited || edited.kind !== original.kind || !original.acceptance.every((item) => edited.acceptance.includes(item)) || !original.dependsOn.every((item) => edited.dependsOn.includes(item)) || !original.requirements.every((item) => edited.requirements.includes(item))) throw new TeamPlanEditError("Template tasks, dependencies and required checks must be preserved. Create a new template version to change its guarantees.");
+      if (edited.instructions !== original.instructions && !edited.instructions.startsWith(original.instructions + "\n")) throw new TeamPlanEditError("Template instructions can only be extended. Publish a new template version to replace them.");
+      if (edited.paths.some((path) => !original.paths.some((base) => base === "*" || path === base || path.startsWith(base + "/")))) throw new TeamPlanEditError("Template file ownership cannot be broadened");
+      if (original.dependsOn.some((id) => (edited.dependencyTypes?.[id] ?? "completion") !== (original.dependencyTypes?.[id] ?? "completion"))) throw new TeamPlanEditError("Preserve template dependency types");
+    }
+    if (!team.contracts.every((contract) => plan.contracts.includes(contract))) throw new TeamPlanEditError("Preserve template contracts");
+    plan.templateUses = structuredClone(team.templateUses);
+  }
+  const problem = planProblem(plan, policy);
+  if (problem) throw new TeamPlanEditError(problem);
+  return plan;
+}
+function summarizeTeamPlan(team) {
+  return `${team.rationale}
+
+Team:
+${team.members.map((member) => `- ${member.name} (${member.id}, ${member.role}) \xB7 ${member.provider}`).join("\n")}
+
+Requirements:
+${team.requirements.map((requirement) => `- ${requirement.id}: ${requirement.description}`).join("\n")}
+
+Tasks:
+${team.tasks.map((task) => `- ${task.id}: ${task.title} \u2192 ${task.owner}; depends on ${task.dependsOn.join(", ") || "nothing"}; paths ${task.paths.join(", ") || "read only"}
+  ${task.instructions}
+  Acceptance: ${task.acceptance.join("; ")}`).join("\n")}
+
+Shared contracts:
+${team.contracts.join("\n") || "None"}
+
+Limits: ${team.invocationLimit} calls; ${team.coordinationLimit} coordinator calls; ${team.maxWaves} task attempts/waves; ${team.maxRepairs} repairs.`;
+}
+export {
+  TeamPlanEditError,
+  editableTeamPlan,
+  summarizeTeamPlan,
+  teamPlanPolicy,
+  validateTeamPlanEdit
+};

package/src/workspace-api.js

@@ -0,0 +1,207 @@
+import { isAgentId } from "./adapters/index.js";
+import { open, readFile } from "node:fs/promises";
+import { join, resolve, sep } from "node:path";
+import { assertWorktree, repoRoot, resolveCommit, git, worktreeGit, WorktreeMismatchError } from "./git.js";
+import { readJson, HttpError } from "./http.js";
+import { inspectReadiness, inTemporaryWorktree } from "./readiness.js";
+import { applyCheckpoint, checkpoints, readEditableFile, saveEditableFile, searchCode, WorkspaceConflictError } from "./workspace.js";
+import { detectVerificationProfile, renderVerificationReport, runVerification, validateVerificationProfile } from "./verification.js";
+import { runCheck } from "./checks.js";
+import { redactExport } from "./privacy.js";
+import { CODEFLOW_HOME } from "./config.js";
+import { writeHealth } from "./store.js";
+import { mergeFileDraft, checkpointHunks, applyCheckpointHunks } from "./workspace-changes.js";
+import { verificationIntegrity, VerificationIntegrityError } from "./verification-integrity.js";
+import { inspectContext, ContextInspectionError } from "./context-inspection.js";
+import { applyCommitRevert, compareCheckpoint, previewCommitRevert } from "./checkpoint-review.js";
+import { searchSemanticSymbols, findCodeReferences } from "./code-intelligence.js";
+import { inspectArchitecture } from "./architecture.js";
+async function ownedCheckout(repo, tree) {
+  try {
+    return await assertWorktree(repo, tree);
+  } catch (error) {
+    if (error instanceof WorktreeMismatchError) throw new HttpError(409, error.message);
+    throw error;
+  }
+}
+async function diagnosticTail(path) {
+  const file = await open(path, "r").catch(() => void 0);
+  if (!file) return "";
+  try {
+    const info = await file.stat();
+    if (!info.isFile()) return "";
+    const bytes = Math.min(info.size, 32e3);
+    const buffer = Buffer.alloc(bytes);
+    const { bytesRead } = await file.read(buffer, 0, bytes, Math.max(0, info.size - bytes));
+    return buffer.subarray(0, bytesRead).toString("utf8");
+  } finally {
+    await file.close();
+  }
+}
+async function handleWorkspaceApi(req, url, parts, manager, signal) {
+  if (!["readiness", "verification", "workspace", "diagnostics", "v1"].includes(parts[1] ?? "")) return void 0;
+  const body = req.method === "POST" ? await readJson(req) : {};
+  const selected = body.repo ?? url.searchParams.get("repo");
+  const absolute = typeof selected === "string" && selected.startsWith("/") ? resolve(selected) : void 0;
+  const owned = absolute ? manager.list().flatMap((run) => run.worktrees.map((tree) => ({ run, tree }))).find(({ tree }) => absolute === resolve(tree.path) || absolute.startsWith(resolve(tree.path) + sep)) : void 0;
+  const repo = owned?.tree.path ?? (absolute ? await repoRoot(absolute).catch(() => {
+    throw new HttpError(400, "Choose an existing Git repository");
+  }) : void 0);
+  const requireRepo = () => {
+    if (!repo) throw new HttpError(400, "Choose a repository");
+    return repo;
+  };
+  const readRepo = () => owned ? worktreeGit(owned.run.repo, owned.tree.path) : Promise.resolve(requireRepo());
+  const writeRepo = () => owned ? ownedCheckout(owned.run.repo, owned.tree) : Promise.resolve(requireRepo());
+  const boundedCommand = (value) => {
+    if (value === void 0) return void 0;
+    if (typeof value !== "string" || value.length > 4e3 || value.includes("\0")) throw new HttpError(400, "Commands must be text under 4,000 characters");
+    return value;
+  };
+  if (parts[1] === "v1" && parts[2] === "capabilities" && req.method === "GET") return { status: 200, body: { version: 1, features: ["readiness", "verification", "file-editing", "code-search", "dependencies", "checkpoints", "diagnostics", "run-export", "cursor-history", "shared-projects", "ssh-projects", "ssh-workers", "coordinated-changes", "code-hosts", "github-review-threads", "filesystem-policies", "filtered-tasks", "provider-workflow-extensions", "team-collaboration"], authentication: "Bearer CODEFLOW_TOKEN", api: "/api", docs: "docs/api.md" } };
+  if (parts[1] === "readiness" && req.method === "POST") {
+    const boundedId = (value) => typeof value === "string" && /^[a-zA-Z0-9][a-zA-Z0-9_:/.-]{0,127}$/.test(value);
+    const provider = (value) => boundedId(value) && (value === "auto" || isAgentId(value));
+    const providerList = (value) => Array.isArray(value) && value.length <= 128 && value.every(provider);
+    if (body.pattern !== void 0 && !boundedId(body.pattern)) throw new HttpError(400, "Invalid workflow pattern");
+    if (body.providers !== void 0 && !providerList(body.providers)) throw new HttpError(400, "Invalid readiness providers");
+    if (body.roles !== void 0 && (!body.roles || typeof body.roles !== "object" || Array.isArray(body.roles) || Object.keys(body.roles).length > 64 || !Object.entries(body.roles).every(([role, value]) => boundedId(role) && (typeof value === "string" ? provider(value) : providerList(value))))) throw new HttpError(400, "Invalid readiness roles");
+    if (body.execute === true) manager.noteActivity();
+    return { status: 200, body: await inspectReadiness({ repo: owned?.run.repo ?? requireRepo(), baseRef: await resolveCommit(await readRepo(), typeof body.baseRef === "string" && body.baseRef ? body.baseRef : "HEAD"), setup: boundedCommand(body.setup), check: boundedCommand(body.check), pattern: body.pattern, roles: body.roles, providers: body.providers, execute: body.execute === true, signal }) };
+  }
+  if (parts[1] === "verification") {
+    if (req.method === "GET" && parts[2] === "profile") return { status: 200, body: await detectVerificationProfile(requireRepo(), url.searchParams.get("preset") || "standard") };
+    if (req.method === "POST" && !parts[2]) {
+      const selectedRepo = requireRepo();
+      const profile = body.profile ? validateVerificationProfile(body.profile) : await detectVerificationProfile(selectedRepo, body.preset ?? "standard");
+      const originalRepo = owned?.run.repo ?? selectedRepo;
+      const at = await readRepo();
+      const ref = await resolveCommit(at, typeof body.baseRef === "string" && body.baseRef ? body.baseRef : "HEAD");
+      const setup = boundedCommand(body.setup) ?? profile.setup;
+      const run = async (path, baseline2) => {
+        const integrity = await verificationIntegrity(await assertWorktree(originalRepo, { path }), signal);
+        const report = await runVerification(path, profile, { signal, repeats: body.repeats, baseline: baseline2, execute: async (check, options) => {
+          await integrity.assert(`before gate ${check.id}`);
+          await assertWorktree(originalRepo, { path });
+          const result = await runCheck(path, check.command, options);
+          await integrity.assert(`gate ${check.id}`);
+          return result;
+        } });
+        await integrity.assert("completion");
+        return report;
+      };
+      manager.noteActivity();
+      let baseline;
+      const prepare = async (path) => {
+        const integrity = await verificationIntegrity(await assertWorktree(originalRepo, { path }), signal);
+        if (setup) {
+          await assertWorktree(originalRepo, { path });
+          const result = await runCheck(path, setup, { timeoutMs: 12e4, signal });
+          await integrity.assert("setup");
+          if (!result.ok) throw new HttpError(422, `Verification setup failed: ${result.output.slice(-2e3)}`);
+        }
+      };
+      try {
+        if (typeof body.baseline === "string" && body.baseline) {
+          const base = await resolveCommit(at, body.baseline);
+          baseline = await inTemporaryWorktree(originalRepo, base, async (path) => {
+            await prepare(path);
+            const report2 = await run(path);
+            return Object.fromEntries(report2.checks.filter((check) => check.attempts.length).map((check) => [check.check.id, check.attempts[0]]));
+          }, signal);
+        }
+        const report = await inTemporaryWorktree(originalRepo, ref, async (path) => {
+          await prepare(path);
+          return run(path, baseline);
+        }, signal);
+        return { status: 200, body: redactExport({ ...report, repo: selectedRepo, commit: ref, markdown: renderVerificationReport(report) }) };
+      } catch (error) {
+        if (error instanceof VerificationIntegrityError || error instanceof WorktreeMismatchError) throw new HttpError(409, error.message);
+        throw error;
+      }
+    }
+  }
+  if (parts[1] === "workspace") {
+    const selectedRepo = requireRepo();
+    if (parts[2] === "compare-checkpoint" && req.method === "POST") {
+      if (typeof body.from !== "string" || typeof body.to !== "string") throw new HttpError(400, "Choose two commits to compare");
+      return { status: 200, body: await compareCheckpoint(await readRepo(), body, signal) };
+    }
+    if (["preview-revert", "apply-revert"].includes(parts[2] ?? "") && req.method === "POST") {
+      const run = typeof body.runId === "string" ? manager.get(body.runId) : void 0;
+      const tree = run?.worktrees.find((tree2) => tree2.path === selectedRepo);
+      if (!run || !tree) throw new HttpError(409, "Choose an owned run worktree before reverting a commit");
+      if (typeof body.commit !== "string" || typeof body.expectedHead !== "string") throw new HttpError(400, "Choose a commit and refresh the current HEAD");
+      try {
+        return { status: 200, body: await manager.withIdleRepository(selectedRepo, async () => {
+          const at = await ownedCheckout(run.repo, tree);
+          return parts[2] === "preview-revert" ? previewCommitRevert(at, body, signal, run.repo) : applyCommitRevert(at, body, signal, run.repo);
+        }, { kind: "checkpoint-revert", owner: run.id }) };
+      } catch (error) {
+        if (error instanceof WorkspaceConflictError) throw new HttpError(409, error.message);
+        throw error;
+      }
+    }
+    if (parts[2] === "merge-file" && req.method === "POST") return { status: 200, body: await mergeFileDraft(await readRepo(), body.path, body.base, body.draft) };
+    if (["checkpoint-hunks", "apply-hunks"].includes(parts[2] ?? "") && req.method === "POST") {
+      const run = typeof body.runId === "string" ? manager.get(body.runId) : void 0;
+      const tree = run?.worktrees.find((tree2) => tree2.path === selectedRepo);
+      if (!run || !tree || run.status === "running") throw new HttpError(409, "Choose an idle run worktree before applying checkpoint hunks");
+      try {
+        return { status: 200, body: await manager.withIdleRepository(selectedRepo, async () => {
+          const at = await ownedCheckout(run.repo, tree);
+          return parts[2] === "checkpoint-hunks" ? checkpointHunks(at, body) : applyCheckpointHunks(at, body);
+        }, { kind: "checkpoint-hunks", owner: run.id }) };
+      } catch (error) {
+        if (error instanceof WorkspaceConflictError) throw new HttpError(409, error.message);
+        throw error;
+      }
+    }
+    if (parts[2] === "file") {
+      const path = typeof body.path === "string" ? body.path : url.searchParams.get("path") ?? "";
+      if (req.method === "GET") return { status: 200, body: await readEditableFile(await readRepo(), path) };
+      if (req.method === "POST") {
+        const busy = manager.list().find((run) => run.status === "running" && (run.repo === selectedRepo || run.worktrees.some((tree) => tree.path === selectedRepo)));
+        if (busy) throw new HttpError(409, "Finish or stop the active run before editing its workspace");
+        try {
+          return { status: 200, body: await manager.withIdleRepository(selectedRepo, async () => saveEditableFile(await writeRepo(), path, body.text, body.expectedHash), { kind: "file-edit", owner: "workspace" }) };
+        } catch (error) {
+          if (error instanceof WorkspaceConflictError) throw new HttpError(409, error.message);
+          throw error;
+        }
+      }
+    }
+    if (parts[2] === "search" && req.method === "GET") return { status: 200, body: url.searchParams.get("mode") === "semantic" ? await searchSemanticSymbols(selectedRepo, url.searchParams.get("q") ?? "", signal) : await searchCode(await readRepo(), url.searchParams.get("q") ?? "", url.searchParams.get("mode") === "symbols" ? "symbols" : "text") };
+    if (parts[2] === "references" && req.method === "GET") return { status: 200, body: await findCodeReferences(selectedRepo, { path: url.searchParams.get("path") ?? "", line: Number(url.searchParams.get("line")), column: Number(url.searchParams.get("column")) }, signal) };
+    if (parts[2] === "dependencies" && req.method === "GET") return { status: 200, body: await inspectArchitecture(selectedRepo, signal) };
+    if (parts[2] === "checkpoints" && req.method === "GET") {
+      const at = await readRepo();
+      return { status: 200, body: { head: await resolveCommit(at), checkpoints: await checkpoints(at, url.searchParams.get("ref") || "HEAD") } };
+    }
+    if (parts[2] === "apply-checkpoint" && req.method === "POST") {
+      const run = typeof body.runId === "string" ? manager.get(body.runId) : void 0;
+      const tree = run?.worktrees.find((tree2) => tree2.path === selectedRepo);
+      if (!run || !tree || run.status === "running") throw new HttpError(409, "Choose an idle run worktree before applying checkpoint files");
+      if (!Array.isArray(body.paths) || body.paths.some((path) => typeof path !== "string")) throw new HttpError(400, "Choose repository paths");
+      return { status: 200, body: await manager.withIdleRepository(selectedRepo, async () => applyCheckpoint(await ownedCheckout(run.repo, tree), { source: String(body.source ?? ""), paths: body.paths, expectedHead: String(body.expectedHead ?? "") }), { kind: "checkpoint-files", owner: run.id }) };
+    }
+    if (parts[2] === "context" && req.method === "POST") {
+      try {
+        return { status: 200, body: await inspectContext({ repo: selectedRepo, baseRef: typeof body.baseRef === "string" ? body.baseRef : void 0, paths: body.paths, attachments: body.attachments, signal }) };
+      } catch (error) {
+        if (error instanceof ContextInspectionError) throw new HttpError(error.status, error.message);
+        throw error;
+      }
+    }
+  }
+  if (parts[1] === "diagnostics" && req.method === "GET") {
+    const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+    const log = await diagnosticTail(join(CODEFLOW_HOME, "server.log"));
+    const runs = manager.list();
+    return { status: 200, body: redactExport({ version: 1, application: packageJson.version, node: process.version, platform: process.platform, at: Date.now(), busy: manager.busy, activity: manager.inspectRepositoryActivity(), writes: writeHealth, runs: { total: runs.length, active: runs.filter((run) => run.status === "running").length, interrupted: runs.filter((run) => run.status === "interrupted").length }, recentErrors: log.slice(-32e3), capabilities: { workspace: true, verificationProfiles: true }, git: repo ? await git(["--version"], repo).then((result) => result.stdout.trim()) : void 0 }) };
+  }
+  throw new HttpError(404, "Unknown workspace operation");
+}
+export {
+  handleWorkspaceApi
+};

package/src/workspace-changes.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { git, resolveCommit, withRepoLock } from "./git.js";
+import { normalizeRepoPath } from "./repo-tree.js";
+import { readEditableFile, WorkspaceConflictError } from "./workspace.js";
+const digest = (text) => createHash("sha256").update(text).digest("hex");
+const MAX_TEXT = 512 * 1024;
+async function mergeFileDraft(repo, path, base, draft) {
+  if ([base, draft].some((value) => typeof value !== "string" || Buffer.byteLength(value) > MAX_TEXT || value.includes("\0"))) throw new Error("Merge drafts must be text under 512 KB");
+  const current = await readEditableFile(repo, path);
+  const folder = await mkdtemp(join(tmpdir(), "codeflow-file-merge-"));
+  try {
+    await Promise.all([["current", current.text], ["base", base], ["draft", draft]].map(([name, text]) => writeFile(join(folder, name), text, { mode: 384, flag: "wx" })));
+    const merged = await git(["merge-file", "--stdout", "--diff3", "-L", "Current file", "-L", "Loaded base", "-L", "Your draft", "current", "base", "draft"], folder, { timeoutMs: 1e4 });
+    if (merged.code < 0 || merged.code > 127 || merged.timedOut || merged.aborted || merged.stderr.trim()) throw new Error(merged.stderr.trim() || "Cannot merge the file drafts");
+    return { current, text: merged.stdout, conflicts: merged.code, clean: merged.code === 0 };
+  } finally {
+    await rm(folder, { recursive: true, force: true });
+  }
+}
+async function checkpointHunks(repo, input) {
+  const path = normalizeRepoPath(input.path);
+  if (!path || path.split("/").some((part) => part.toLowerCase() === ".git")) throw new Error("Choose a regular repository file outside .git");
+  await readEditableFile(repo, path);
+  const [head, source] = await Promise.all([resolveCommit(repo), resolveCommit(repo, input.source)]);
+  const modes = await Promise.all([head, source].map((ref) => git(["--literal-pathspecs", "ls-tree", "-z", ref, "--", path], repo)));
+  if (modes.some((result) => result.code || !/^100(?:644|755) blob /.test(result.stdout))) throw new Error("Hunks support existing regular text files. Apply added, deleted, renamed or binary files as complete files instead.");
+  const diff = await git(["--literal-pathspecs", "diff", "--no-ext-diff", "--no-textconv", "--no-color", "--unified=3", head, source, "--", path], repo);
+  if (diff.code) throw new Error(diff.stderr.trim() || "Cannot compare the checkpoint file");
+  if (diff.stdout.length > 2 * 1024 * 1024 || /^(?:Binary files |GIT binary patch)/m.test(diff.stdout)) throw new Error("The patch is binary or too large for selective hunks");
+  const first = diff.stdout.search(/^@@ /m);
+  if (first < 0) return { head, source, path, patchHeader: "", hunks: [] };
+  const patchHeader = diff.stdout.slice(0, first).replace(/^index .*\n/m, "");
+  const chunks = diff.stdout.slice(first).split(/(?=^@@ )/m).filter(Boolean);
+  if (chunks.length > 200) throw new Error("This file has too many hunks; apply the complete file instead");
+  return { head, source, path, patchHeader, hunks: chunks.map((patch) => ({ id: digest(`${head}\0${source}\0${path}\0${patch}`), header: patch.split("\n")[0], patch })) };
+}
+async function applyCheckpointHunks(repo, input) {
+  if (!Array.isArray(input.hunks) || input.hunks.length < 1 || input.hunks.length > 200 || input.hunks.some((id) => typeof id !== "string" || !/^[a-f0-9]{64}$/.test(id)) || new Set(input.hunks).size !== input.hunks.length) throw new Error("Choose 1\u2013200 distinct checkpoint hunks");
+  return withRepoLock(typeof repo === "string" ? repo : repo.path, async () => {
+    if (await resolveCommit(repo) !== input.expectedHead) throw new WorkspaceConflictError(await resolveCommit(repo));
+    const status = await git(["status", "--porcelain"], repo);
+    if (status.code || status.stdout.trim()) throw new Error("Commit or save existing changes before applying checkpoint hunks");
+    const preview = await checkpointHunks(repo, input);
+    const chosen = preview.hunks.filter((hunk) => input.hunks.includes(hunk.id));
+    if (chosen.length !== input.hunks.length) throw new Error("The checkpoint hunks changed. Refresh the comparison before applying");
+    const patch = preview.patchHeader + chosen.map((hunk) => hunk.patch).join("");
+    const checked = await git(["apply", "--check", "--whitespace=nowarn", "-"], repo, { input: patch });
+    if (checked.code) throw new Error(checked.stderr.trim() || "The selected hunks cannot be applied safely");
+    const applied = await git(["apply", "--whitespace=nowarn", "-"], repo, { input: patch });
+    if (applied.code) throw new Error(applied.stderr.trim() || "Cannot apply the selected hunks");
+    return { head: preview.head, source: preview.source, path: preview.path, hunks: input.hunks, staged: false };
+  });
+}
+export {
+  applyCheckpointHunks,
+  checkpointHunks,
+  mergeFileDraft
+};