@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.11

package/dist/chunk-CAN3EBE5.js

@@ -0,0 +1,1726 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  ManualStep,
+  changesDirOf,
+  external_exports,
+  require_dist,
+  toCanonicalYaml
+} from "./chunk-JMOLB347.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/adapters/dist/work-item-csv.js
+var ADO_COLUMNS = [
+  "ID",
+  "Work Item Type",
+  "Title 1",
+  "Title 2",
+  "Description",
+  "Acceptance Criteria",
+  "Tags",
+  "Area Path",
+  "Iteration Path"
+];
+var JIRA_COLUMNS = [
+  "Issue Id",
+  "Issue Type",
+  "Summary",
+  "Description",
+  "Acceptance Criteria",
+  "Parent",
+  "Labels"
+];
+var html = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var ul = (xs) => xs.length ? `<ul>${xs.map((x) => `<li>${html(x)}</li>`).join("")}</ul>` : "";
+var p = (s) => `<p>${html(s)}</p>`;
+var csvCell = (v) => /[",\r\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v;
+var csvRow = (cells) => cells.map(csvCell).join(",");
+var storyRef = (s) => `Change ${s.change}, repo ${s.repo}, flow ${s.flow}. The story in full: ${s.file}.`;
+var promptRef = (t) => `Prompt for Copilot or Claude Code: ${t.prompt}; run it with ${t.run}.`;
+function workItemRows(stories, o = {}) {
+  const rows = [];
+  let issue = 0;
+  for (const s of stories) {
+    const tags = [s.change, s.repo, ...o.tags ?? []];
+    const parent = ++issue;
+    if ((o.format ?? "ado") === "ado") {
+      const common = {
+        ID: "",
+        Tags: tags.join("; "),
+        "Area Path": o.areaPath ?? "",
+        "Iteration Path": o.iterationPath ?? ""
+      };
+      rows.push({
+        ...common,
+        "Work Item Type": "User Story",
+        "Title 1": s.title,
+        "Title 2": "",
+        Description: [p(s.statement), ...s.context ? [p(s.context)] : [], p(storyRef(s))].join(""),
+        "Acceptance Criteria": ul(s.criteria)
+      });
+      for (const t of s.tasks)
+        rows.push({
+          ...common,
+          "Work Item Type": "Task",
+          "Title 1": "",
+          "Title 2": `${t.label} ${t.title}`,
+          Description: [
+            ul(t.steps),
+            ...t.places.length ? [p(`Where: ${t.places.join(", ")}.`)] : [],
+            ...t.fields.length ? [p(`Fields: ${t.fields.join(", ")}.`)] : [],
+            p(promptRef(t))
+          ].join(""),
+          "Acceptance Criteria": ul(t.criteria)
+        });
+    } else {
+      const labels = tags.map((x) => x.replace(/\s+/g, "-")).join(" ");
+      rows.push({
+        "Issue Id": String(parent),
+        "Issue Type": "Story",
+        Summary: s.title,
+        Description: [s.statement, s.context, storyRef(s)].filter(Boolean).join("\n\n"),
+        "Acceptance Criteria": s.criteria.map((c) => `* ${c}`).join("\n"),
+        Parent: "",
+        Labels: labels
+      });
+      for (const t of s.tasks)
+        rows.push({
+          "Issue Id": String(++issue),
+          "Issue Type": "Sub-task",
+          Summary: `${t.label} ${t.title}`,
+          Description: [
+            t.steps.map((x) => `* ${x}`).join("\n"),
+            t.places.length ? `Where: ${t.places.join(", ")}.` : "",
+            t.fields.length ? `Fields: ${t.fields.join(", ")}.` : "",
+            promptRef(t)
+          ].filter(Boolean).join("\n\n"),
+          "Acceptance Criteria": t.criteria.map((c) => `* ${c}`).join("\n"),
+          Parent: String(parent),
+          Labels: labels
+        });
+    }
+  }
+  return rows;
+}
+function workItemsCsv(stories, o = {}) {
+  const columns = (o.format ?? "ado") === "ado" ? ADO_COLUMNS : JIRA_COLUMNS;
+  return [
+    csvRow([...columns]),
+    ...workItemRows(stories, o).map((r) => csvRow(columns.map((c) => r[c] ?? "")))
+  ].map((l) => `${l}\r
+`).join("");
+}
+
+// packages/adapters/dist/manual/steps.js
+var import_yaml = __toESM(require_dist(), 1);
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var LEADING = [
+  "schemaVersion",
+  "id",
+  "change",
+  "system",
+  "action",
+  "state",
+  "title",
+  "where",
+  "key",
+  "name",
+  "label",
+  "value",
+  "format"
+];
+function serializeStep(step) {
+  return toCanonicalYaml(ManualStep.parse(step), LEADING);
+}
+var slugify = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/, "") || "step";
+var shortHash = (s) => createHash("sha256").update(s, "utf8").digest("hex").slice(0, 8);
+var nowIso = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+function matches(s, f = {}) {
+  return (!f.change || s.change === f.change) && (!f.state || s.state === f.state) && (!f.system || s.system === f.system) && (!f.action || s.action === f.action);
+}
+var byCreated = (a, b) => a.createdAt === b.createdAt ? a.id < b.id ? -1 : 1 : a.createdAt < b.createdAt ? -1 : 1;
+function build(step, id) {
+  const { slug: _slug, createdAt, ...rest } = step;
+  return ManualStep.parse({
+    schemaVersion: 1,
+    ...rest,
+    id,
+    createdAt: createdAt ?? nowIso(),
+    state: "open",
+    runs: []
+  });
+}
+function uniqueId(slug, taken) {
+  const base = slugify(slug);
+  if (!taken.has(base))
+    return base;
+  for (let n = 2; ; n++)
+    if (!taken.has(`${base}-${n}`))
+      return `${base}-${n}`;
+}
+async function writeAtomic(path, text) {
+  await mkdir(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp`;
+  try {
+    await writeFile(tmp, text, "utf8");
+    await rename(tmp, path);
+  } catch (e) {
+    await rm(tmp, { force: true });
+    throw e;
+  }
+}
+var StepFileError = class extends Error {
+  path;
+  constructor(message, path) {
+    super(message);
+    this.path = path;
+    this.name = "StepFileError";
+  }
+};
+function fileStepStore(root) {
+  const dirFor = (change) => change ? join(changesDirOf(root), change, "steps") : join(root, "steps");
+  const pathOf = (s) => join(dirFor(s.change), `${s.id}.yaml`);
+  async function folders() {
+    const out = [join(root, "steps")];
+    try {
+      for (const d of await readdir(changesDirOf(root), { withFileTypes: true }))
+        if (d.isDirectory() && d.name !== "archive")
+          out.push(join(changesDirOf(root), d.name, "steps"));
+    } catch {
+    }
+    return out;
+  }
+  const cache = /* @__PURE__ */ new Map();
+  async function readAll() {
+    const out = [];
+    for (const dir of await folders()) {
+      let names;
+      try {
+        names = (await readdir(dir)).filter((n) => n.endsWith(".yaml")).sort();
+      } catch {
+        continue;
+      }
+      for (const n of names) {
+        const path = join(dir, n);
+        const st = await stat(path);
+        const hit = cache.get(path);
+        if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) {
+          out.push(structuredClone(hit.step));
+          continue;
+        }
+        let data;
+        try {
+          data = (0, import_yaml.parse)(await readFile(path, "utf8"));
+        } catch (e) {
+          throw new StepFileError(`${path}: invalid YAML: ${e.message}`, path);
+        }
+        const r = ManualStep.safeParse(data);
+        if (!r.success)
+          throw new StepFileError(`${path}: ${r.error.issues.map((i) => `${i.path.join(".") || "(file)"}: ${i.message}`).join("; ")}`, path);
+        cache.set(path, { mtimeMs: st.mtimeMs, size: st.size, step: r.data });
+        out.push(structuredClone(r.data));
+      }
+    }
+    return out.sort(byCreated);
+  }
+  return {
+    pathOf,
+    async create(step) {
+      const all = await readAll();
+      const found = all.find((s2) => s2.key === step.key);
+      if (found)
+        return found;
+      const s = build(step, uniqueId(step.slug, new Set(all.map((x) => x.id))));
+      await writeAtomic(pathOf(s), serializeStep(s));
+      cache.delete(pathOf(s));
+      return s;
+    },
+    async get(id) {
+      return (await readAll()).find((s) => s.id === id);
+    },
+    async byKey(key) {
+      return (await readAll()).find((s) => s.key === key);
+    },
+    async list(filter) {
+      return (await readAll()).filter((s) => matches(s, filter));
+    },
+    async save(step) {
+      const s = ManualStep.parse(step);
+      await writeAtomic(pathOf(s), serializeStep(s));
+      cache.delete(pathOf(s));
+      return s;
+    }
+  };
+}
+var HANDLE = /^@?[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+function checkValue(field, raw) {
+  const bad = (problem) => ({ ok: false, problem: `${field.label}: ${problem}` });
+  if (field.format === "handles") {
+    const list = Array.isArray(raw) ? raw.map(String) : String(raw ?? "").split(/[\s,;]+/).filter(Boolean);
+    const wrong = list.filter((h) => !HANDLE.test(h));
+    if (wrong.length)
+      return bad(`${wrong.join(", ")} isn't a handle such as pat`);
+    return { ok: true, value: list.map((h) => h.replace(/^@/, "")) };
+  }
+  if (typeof raw === "boolean" && field.format === "yes-no")
+    return { ok: true, value: raw };
+  if (typeof raw === "number" && (field.format === "number" || field.format === "integer")) {
+    if (field.format === "integer" && !Number.isInteger(raw))
+      return bad("a whole number");
+    return { ok: true, value: raw };
+  }
+  const s = String(raw ?? "").trim();
+  if (!s)
+    return bad("empty");
+  switch (field.format) {
+    case "text":
+      return { ok: true, value: s };
+    case "url":
+      try {
+        const u = new URL(s);
+        if (u.protocol !== "https:" && u.protocol !== "http:")
+          return bad("an http(s) link");
+        return { ok: true, value: s };
+      } catch {
+        return bad(`${s} isn't a link`);
+      }
+    case "number":
+    case "integer": {
+      const n = Number(s);
+      if (!Number.isFinite(n))
+        return bad(`${s} isn't a number`);
+      if (field.format === "integer" && !Number.isInteger(n))
+        return bad(`${s} isn't a whole number`);
+      return { ok: true, value: n };
+    }
+    case "date":
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(s) || Number.isNaN(Date.parse(s)))
+        return bad(`${s} isn't a date such as 2026-10-21`);
+      return { ok: true, value: s };
+    case "yes-no": {
+      const k = s.toLowerCase();
+      if (["yes", "y", "true"].includes(k))
+        return { ok: true, value: true };
+      if (["no", "n", "false"].includes(k))
+        return { ok: true, value: false };
+      return bad("yes or no");
+    }
+    case "pattern":
+      return new RegExp(`^(?:${field.pattern})$`).test(s) ? { ok: true, value: s } : bad(`${s} doesn't look right (expected ${field.help ?? field.pattern})`);
+    case "choice":
+      return field.choices?.includes(s) ? { ok: true, value: s } : bad(`one of ${field.choices?.join(", ")}`);
+  }
+}
+function checkResult(step, values) {
+  const out = {};
+  const problems = [];
+  const known = new Set(step.result.map((f) => f.name));
+  for (const k of Object.keys(values))
+    if (!known.has(k))
+      problems.push(`${k} isn't asked for here${known.size ? ` (record ${[...known].join(", ")})` : ""}`);
+  for (const f of step.result) {
+    const raw = values[f.name];
+    if (raw === void 0 || raw === "") {
+      if (f.required)
+        problems.push(`${f.label}: required`);
+      continue;
+    }
+    const r = checkValue(f, raw);
+    if (r.ok)
+      out[f.name] = r.value;
+    else
+      problems.push(r.problem);
+  }
+  return { values: out, problems };
+}
+var StepError = class extends Error {
+  code;
+  problems;
+  constructor(code, message, problems = []) {
+    super(message);
+    this.code = code;
+    this.problems = problems;
+    this.name = "StepError";
+  }
+};
+async function recordStep(store, id, o) {
+  const step = await store.get(id);
+  if (!step)
+    throw new StepError("not-found", `There is no step ${id}.`);
+  if (step.state !== "open")
+    throw new StepError("refused", `Step ${id} is already ${step.state}.`);
+  if (o.skip) {
+    if (!o.note?.trim())
+      throw new StepError("invalid", `Say why step ${id} is skipped.`);
+    return store.save({
+      ...step,
+      state: "skipped",
+      recorded: {
+        at: o.at ?? nowIso(),
+        by: o.by.replace(/^@/, ""),
+        values: {},
+        via: "person",
+        evidence: [],
+        note: o.note
+      }
+    });
+  }
+  for (const d of step.dependsOn) {
+    const dep = await store.get(d);
+    if (dep && dep.state === "open")
+      throw new StepError("refused", `Do step ${d} first: step ${id} depends on it.`);
+  }
+  const r = checkResult(step, o.values ?? {});
+  if (r.problems.length)
+    throw new StepError("invalid", `The result for step ${id} isn't valid.`, r.problems);
+  return store.save({
+    ...step,
+    state: "done",
+    recorded: {
+      at: o.at ?? nowIso(),
+      by: o.by.replace(/^@/, ""),
+      values: r.values,
+      via: o.via ?? "person",
+      ...o.executor ? { executor: o.executor } : {},
+      evidence: o.evidence ?? [],
+      ...o.note ? { note: o.note } : {}
+    }
+  });
+}
+var stepApproval = (a) => ({
+  by: a.by.replace(/^@/, ""),
+  at: a.at,
+  ref: a.ref
+});
+var csvCell2 = (s) => /[",\n\r]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+var csvRow2 = (cells) => cells.map(csvCell2).join(",");
+var WORK_ITEM_COLUMNS = [
+  ["Work Item Type", "Work item type"],
+  ["Title", "Title"],
+  ["Description", "Description"],
+  ["Acceptance Criteria", "Acceptance criteria"],
+  ["Parent", "Parent"],
+  ["Tags", "Tags"],
+  ["Assigned To", "Assigned to"]
+];
+function exportStep(step, format) {
+  const field = (n) => step.fields.find((f) => f.name.toLowerCase() === n.toLowerCase())?.value ?? "";
+  if (format === "csv")
+    return {
+      format: "csv",
+      fileName: `${step.id}.csv`,
+      text: [csvRow2(["Field", "Value"]), ...step.fields.map((f) => csvRow2([f.name, f.value]))].join("\n") + "\n"
+    };
+  if (format === "import" && step.system === "work-tracker" && step.action === "create-work-item")
+    return {
+      format: "work-item-csv",
+      fileName: `${step.id}.csv`,
+      text: [
+        csvRow2(WORK_ITEM_COLUMNS.map(([c]) => c)),
+        csvRow2(WORK_ITEM_COLUMNS.map(([, f]) => field(f)))
+      ].join("\n") + "\n"
+    };
+  if (format === "import" && step.system === "service-desk" && step.action === "submit-request")
+    return {
+      format: "request-json",
+      fileName: `${step.id}.json`,
+      text: JSON.stringify({
+        requestType: field("Request type"),
+        fields: Object.fromEntries(step.fields.filter((f) => f.name !== "Request type").map((f) => [f.name, f.value]))
+      }, null, 2) + "\n"
+    };
+  const lines = [
+    `Step ${step.id}: ${step.title}`,
+    `Where: ${step.where}`,
+    ...step.reason ? [`Why it is manual: ${step.reason}`] : [],
+    ...step.dependsOn.length ? [`Do first: ${step.dependsOn.join(", ")}`] : [],
+    "",
+    ...step.instructions.length ? ["Steps:", ...step.instructions.map((s, i) => `${i + 1}. ${s}`), ""] : [],
+    ...step.fields.length ? ["Fields:", ...step.fields.map((f) => `${f.name}: ${f.value}`), ""] : [],
+    ...step.result.length ? [
+      "Record back:",
+      ...step.result.map((f) => `- ${f.label}${f.required ? "" : " (optional)"}: atticus todo done ${step.id} --result ${f.name}=\u2026`)
+    ] : [`When done: atticus todo done ${step.id}`]
+  ];
+  return {
+    format: "text",
+    fileName: `${step.id}.txt`,
+    text: lines.join("\n").replace(/\n+$/, "") + "\n"
+  };
+}
+
+// packages/adapters/dist/common.js
+var Approval = external_exports.strictObject({
+  /** The person who approved: a handle from the Git host or directory. */
+  by: external_exports.string().min(1),
+  at: external_exports.iso.datetime({ offset: true }),
+  scope: external_exports.enum(["once", "standing"]).default("once"),
+  /** What was approved, e.g. a finding, hand-off PR or artifact path. */
+  ref: external_exports.string().min(1)
+});
+var AdapterError = class extends Error {
+  adapter;
+  code;
+  retryable;
+  constructor(adapter, code, message, retryable = code === "rate-limited" || code === "unavailable") {
+    super(`${adapter}: ${message}`);
+    this.adapter = adapter;
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "AdapterError";
+  }
+};
+function requireApproval(adapter, approval, opts = {}) {
+  const r = Approval.safeParse(approval);
+  if (!r.success) {
+    throw new AdapterError(adapter, "not-approved", "this write needs a person's approval (by, at, ref)");
+  }
+  if (r.data.scope === "standing" && !opts.allowStanding) {
+    throw new AdapterError(adapter, "not-approved", "a standing approval can't cover this write; it needs approval each time");
+  }
+  return r.data;
+}
+var MockBase = class {
+  name;
+  journal = [];
+  failures = [];
+  constructor(name) {
+    this.name = name;
+  }
+  failNext(code, method) {
+    this.failures.push(method === void 0 ? { code } : { code, method });
+  }
+  /** Record a call and raise an injected failure if one is due. */
+  call(method, args, approval) {
+    const i = this.failures.findIndex((f) => f.method === void 0 || f.method === method);
+    if (i !== -1) {
+      const [f] = this.failures.splice(i, 1);
+      throw new AdapterError(this.name, f.code, `injected ${f.code} on ${method}`);
+    }
+    this.journal.push(approval ? { adapter: this.name, method, args, approval } : { adapter: this.name, method, args });
+  }
+  notFound(what) {
+    throw new AdapterError(this.name, "not-found", `${what} not found`);
+  }
+};
+
+// packages/adapters/dist/git-host.js
+function mergeBlockers(pr) {
+  const out = [];
+  if (pr.state === "merged" || pr.state === "closed")
+    out.push(`the PR is ${pr.state}`);
+  if (pr.state === "draft")
+    out.push("the PR is a draft");
+  const latest = /* @__PURE__ */ new Map();
+  for (const r of pr.reviews)
+    if (r.state !== "commented")
+      latest.set(r.by, r.state);
+  if ([...latest.values()].includes("changes-requested"))
+    out.push("changes are requested");
+  const missing = pr.requiredReviewers.filter((r) => latest.get(r) !== "approved");
+  if (pr.requiredReviewers.length > 0 && missing.length === pr.requiredReviewers.length) {
+    out.push(`needs approval from ${pr.requiredReviewers.join(" or ")}`);
+  }
+  if (pr.requiredReviewers.length === 0 && ![...latest.values()].includes("approved"))
+    out.push("needs at least one approval");
+  const failing = pr.checks.filter((c) => c.status !== "passed").map((c) => `${c.name} ${c.status}`);
+  if (failing.length > 0)
+    out.push(`checks not passing: ${failing.join(", ")}`);
+  return out;
+}
+var MockGitHost = class extends MockBase {
+  repos = /* @__PURE__ */ new Map();
+  prs = /* @__PURE__ */ new Map();
+  numbers = /* @__PURE__ */ new Map();
+  constructor(repos = []) {
+    super("git-host");
+    for (const r of repos) {
+      const defaultBranch = r.defaultBranch ?? "main";
+      this.repos.set(r.repo, {
+        repo: r.repo,
+        defaultBranch,
+        protectedBranches: r.protectedBranches ?? [defaultBranch]
+      });
+    }
+  }
+  key = (repo, n) => `${repo}#${n}`;
+  async getRepo(repo) {
+    this.call("getRepo", [repo]);
+    return { ...this.repos.get(repo) ?? this.notFound(`repo ${repo}`) };
+  }
+  async getPullRequest(repo, number) {
+    this.call("getPullRequest", [repo, number]);
+    return structuredClone(this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`));
+  }
+  async listPullRequests(repo, q) {
+    this.call("listPullRequests", [repo, q]);
+    return [...this.prs.values()].filter((p2) => p2.repo === repo && (!q.head || p2.head === q.head) && (!q.state || p2.state === q.state)).map((p2) => structuredClone(p2));
+  }
+  async createPullRequest(input, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("createPullRequest", [input], a);
+    const info = this.repos.get(input.repo) ?? this.notFound(`repo ${input.repo}`);
+    if (info.protectedBranches.includes(input.head)) {
+      throw new AdapterError(this.name, "invalid", `${input.head} is protected and can't be a PR's source branch`);
+    }
+    if ([...this.prs.values()].some((p2) => p2.repo === input.repo && p2.head === input.head && (p2.state === "open" || p2.state === "draft"))) {
+      throw new AdapterError(this.name, "conflict", `an open PR from ${input.head} already exists`);
+    }
+    const n = (this.numbers.get(input.repo) ?? 0) + 1;
+    this.numbers.set(input.repo, n);
+    const pr = {
+      repo: input.repo,
+      number: n,
+      url: `https://git.example.com/${input.repo}/pull/${n}`,
+      title: input.title,
+      body: input.body,
+      head: input.head,
+      base: input.base,
+      state: input.draft ? "draft" : "open",
+      reviews: [],
+      checks: [],
+      requiredReviewers: []
+    };
+    this.prs.set(this.key(input.repo, n), pr);
+    return structuredClone(pr);
+  }
+  async comment(repo, number, body, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("comment", [repo, number, body], a);
+    if (!this.prs.has(this.key(repo, number)))
+      this.notFound(`PR ${repo}#${number}`);
+  }
+  async merge(repo, number, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("merge", [repo, number], a);
+    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
+    const blockers = mergeBlockers(pr);
+    if (blockers.length > 0)
+      throw new AdapterError(this.name, "conflict", `can't merge: ${blockers.join("; ")}`);
+    pr.state = "merged";
+    return structuredClone(pr);
+  }
+  async closePullRequest(repo, number, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("closePullRequest", [repo, number], a);
+    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
+    if (pr.state === "merged")
+      throw new AdapterError(this.name, "conflict", `PR ${number} is merged and can't be closed`);
+    pr.state = "closed";
+    return structuredClone(pr);
+  }
+  /** Test helpers: what reviewers and CI would do on the host. */
+  review(repo, number, by, state) {
+    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).reviews.push({
+      by,
+      state
+    });
+  }
+  setChecks(repo, number, checks) {
+    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).checks = checks;
+  }
+  requireReviewers(repo, number, reviewers) {
+    (this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`)).requiredReviewers = reviewers;
+  }
+  markReady(repo, number) {
+    const pr = this.prs.get(this.key(repo, number)) ?? this.notFound(`PR ${repo}#${number}`);
+    if (pr.state === "draft")
+      pr.state = "open";
+  }
+};
+
+// packages/adapters/dist/read-only.js
+var MockWiki = class extends MockBase {
+  pages = /* @__PURE__ */ new Map();
+  constructor(seed = []) {
+    super("wiki");
+    for (const p2 of seed)
+      this.pages.set(p2.id, { ...p2 });
+  }
+  head = ({ body: _b, ...rest }) => rest;
+  async listPages(space) {
+    this.call("listPages", [space]);
+    return [...this.pages.values()].filter((p2) => p2.space === space).map(this.head);
+  }
+  async getPage(id) {
+    this.call("getPage", [id]);
+    return { ...this.pages.get(id) ?? this.notFound(`page ${id}`) };
+  }
+  async search(text) {
+    this.call("search", [text]);
+    const t = text.toLowerCase();
+    return [...this.pages.values()].filter((p2) => p2.title.toLowerCase().includes(t) || p2.body.toLowerCase().includes(t)).map(this.head);
+  }
+};
+var MockDesignTool = class extends MockBase {
+  files = /* @__PURE__ */ new Map();
+  constructor(seed = []) {
+    super("design-tool");
+    for (const f of seed)
+      this.files.set(f.key, structuredClone(f));
+  }
+  async getFile(key) {
+    this.call("getFile", [key]);
+    return structuredClone(this.files.get(key) ?? this.notFound(`design file ${key}`));
+  }
+  async renderFrame(key, frameId) {
+    this.call("renderFrame", [key, frameId]);
+    const file = this.files.get(key) ?? this.notFound(`design file ${key}`);
+    if (!file.pages.some((p2) => p2.frames.some((f) => f.id === frameId)))
+      this.notFound(`frame ${frameId}`);
+    return new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+  }
+};
+var MockNotifier = class extends MockBase {
+  channels;
+  sent = [];
+  constructor(channels = []) {
+    super("notify");
+    this.channels = channels;
+  }
+  async send(n, approval) {
+    const a = requireApproval(this.name, approval, { allowStanding: true });
+    this.call("send", [n], a);
+    if (this.channels.length > 0 && !this.channels.includes(n.channel)) {
+      throw new AdapterError(this.name, "invalid", `unknown channel ${n.channel}`);
+    }
+    const id = `msg-${this.sent.length + 1}`;
+    this.sent.push({ ...n, id });
+    return { id };
+  }
+};
+
+// packages/adapters/dist/service-desk.js
+var MockServiceDesk = class _MockServiceDesk extends MockBase {
+  requests = /* @__PURE__ */ new Map();
+  next = 1;
+  constructor(seed = []) {
+    super("service-desk");
+    for (const r of seed)
+      this.requests.set(r.id, { ...r });
+    this.next = seed.length + 1;
+  }
+  /** Load the shape the fixture's closed-requests export uses. */
+  static fromExport(rows) {
+    return new _MockServiceDesk(rows.map((r) => ({
+      id: r.number,
+      type: r.type,
+      state: r.closed ? "done" : "submitted",
+      fields: r.fields,
+      ...r.approvalGroup ? { approvalGroup: r.approvalGroup } : {},
+      ...r.opened ? { openedAt: r.opened } : {},
+      ...r.closed ? { closedAt: r.closed } : {},
+      url: `https://desk.example.com/requests/${r.number}`
+    })));
+  }
+  async getRequest(id) {
+    this.call("getRequest", [id]);
+    return { ...this.requests.get(id) ?? this.notFound(`request ${id}`) };
+  }
+  async listRequests(q) {
+    this.call("listRequests", [q]);
+    return [...this.requests.values()].filter((r) => (!q.changeId || r.changeId === q.changeId) && (!q.state || r.state === q.state) && (!q.type || r.type === q.type)).map((r) => ({ ...r }));
+  }
+  async submitRequest(draft, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("submitRequest", [draft], a);
+    const empty = Object.entries(draft.fields).filter(([, v]) => v === "").map(([k]) => k);
+    if (empty.length > 0)
+      throw new AdapterError(this.name, "invalid", `required fields are empty: ${empty.join(", ")}`);
+    const id = `SR-${String(this.next++).padStart(4, "0")}`;
+    const r = {
+      id,
+      type: draft.type,
+      state: "submitted",
+      fields: { ...draft.fields },
+      changeId: draft.changeId,
+      openedAt: a.at.slice(0, 10),
+      url: `https://desk.example.com/requests/${id}`
+    };
+    this.requests.set(id, r);
+    return { ...r };
+  }
+  /** Test helper: move a request along as the service desk would. */
+  setState(id, state, closedAt) {
+    const r = this.requests.get(id) ?? this.notFound(`request ${id}`);
+    r.state = state;
+    if (closedAt)
+      r.closedAt = closedAt;
+  }
+};
+
+// packages/adapters/dist/work-tracker.js
+var MockWorkTracker = class _MockWorkTracker extends MockBase {
+  items = /* @__PURE__ */ new Map();
+  links = [];
+  next = 1e3;
+  constructor(seed = []) {
+    super("work-tracker");
+    for (const i of seed)
+      this.items.set(i.id, { ...i });
+  }
+  /** Load the shape the fixture's ticket export uses. */
+  static fromExport(rows) {
+    const type = (t) => {
+      const k = t.toLowerCase();
+      if (k.includes("story"))
+        return "story";
+      if (k.includes("epic"))
+        return "epic";
+      if (k.includes("feature"))
+        return "feature";
+      if (k.includes("bug"))
+        return "bug";
+      return "task";
+    };
+    return new _MockWorkTracker(rows.map((r) => ({
+      id: String(r.id),
+      type: type(r.type),
+      title: r.title,
+      description: r.description ?? "",
+      acceptanceCriteria: r.acceptanceCriteria ?? "",
+      state: r.state ?? "New",
+      tags: [],
+      url: `https://work.example.com/items/${r.id}`
+    })));
+  }
+  async getItem(id) {
+    this.call("getItem", [id]);
+    return { ...this.items.get(id) ?? this.notFound(`work item ${id}`) };
+  }
+  async query(q) {
+    this.call("query", [q]);
+    const text = q.text?.toLowerCase();
+    return [...this.items.values()].filter((i) => (!q.type || i.type === q.type) && (!q.parent || i.parent === q.parent) && (!q.state || i.state === q.state) && (!q.tag || i.tags.includes(q.tag)) && (!text || i.title.toLowerCase().includes(text) || i.description.toLowerCase().includes(text))).map((i) => ({ ...i }));
+  }
+  async createItem(input, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("createItem", [input], a);
+    if (input.parent && !this.items.has(input.parent))
+      this.notFound(`parent ${input.parent}`);
+    const id = String(this.next++);
+    const item = {
+      id,
+      type: input.type,
+      title: input.title,
+      description: input.description ?? "",
+      acceptanceCriteria: input.acceptanceCriteria ?? "",
+      state: "New",
+      ...input.parent ? { parent: input.parent } : {},
+      ...input.assignee ? { assignee: input.assignee } : {},
+      tags: input.tags ?? [],
+      url: `https://work.example.com/items/${id}`
+    };
+    this.items.set(id, item);
+    return { ...item };
+  }
+  async updateItem(id, patch, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("updateItem", [id, patch], a);
+    const item = this.items.get(id) ?? this.notFound(`work item ${id}`);
+    const updated = {
+      ...item,
+      ...Object.fromEntries(Object.entries(patch).filter(([, v]) => v !== void 0))
+    };
+    this.items.set(id, updated);
+    return { ...updated };
+  }
+  async link(from, to, kind, approval) {
+    const a = requireApproval(this.name, approval);
+    this.call("link", [from, to, kind], a);
+    if (!this.items.has(from))
+      this.notFound(`work item ${from}`);
+    if (!this.items.has(to))
+      this.notFound(`work item ${to}`);
+    this.links.push({ from, to, kind });
+    if (kind === "parent")
+      this.items.get(from).parent = to;
+  }
+};
+
+// packages/adapters/dist/manual/base.js
+var nowIso2 = () => (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+var PROVISIONAL = "manual:";
+var provisionalId = (stepId) => `${PROVISIONAL}${stepId}`;
+var stepOfProvisional = (id) => id.startsWith(PROVISIONAL) ? id.slice(PROVISIONAL.length) : void 0;
+var ManualBase = class {
+  name;
+  system;
+  opts;
+  /** Set by the fallback wrapper while it hands one call to this adapter. */
+  reason;
+  journal = [];
+  constructor(name, system, opts) {
+    this.name = name;
+    this.system = system;
+    this.opts = opts;
+  }
+  now() {
+    return this.opts.now?.() ?? nowIso2();
+  }
+  setting(key) {
+    const v = this.opts.settings?.[key];
+    return typeof v === "string" ? v : void 0;
+  }
+  settingList(key) {
+    const v = this.opts.settings?.[key];
+    return Array.isArray(v) ? v : typeof v === "string" ? [v] : void 0;
+  }
+  approve(approval, o = {}) {
+    return requireApproval(this.name, approval, o);
+  }
+  /** The procedure (and step) for a kind of write, if the org pack has one. */
+  procedureFor(kind, o = {}) {
+    for (const p2 of this.opts.procedures ?? []) {
+      if (p2.status === "retired")
+        continue;
+      if (o.template && p2.template !== o.template)
+        continue;
+      if (!o.template && p2.system !== this.system)
+        continue;
+      const s = p2.steps.find((x) => x.kind === kind);
+      if (s)
+        return { procedure: p2.id, procedureStep: s.id };
+    }
+    return void 0;
+  }
+  async step(method, s, approval) {
+    const created = await this.opts.store.create({
+      ...s,
+      system: this.system,
+      createdBy: (s.createdBy ?? approval?.by ?? "atticus").replace(/^@/, ""),
+      createdAt: this.now(),
+      ...approval ? { approval: stepApproval(approval) } : {},
+      ...s.change ?? this.opts.change ? { change: s.change ?? this.opts.change } : {},
+      ...this.reason ? { reason: this.reason } : {}
+    });
+    this.journal.push({ method, step: created.id });
+    return created;
+  }
+  notFound(what, hint) {
+    throw new AdapterError(this.name, "not-found", `${what} not found: ${hint}`);
+  }
+};
+
+// packages/adapters/dist/manual/git-host.js
+function changeOfBranch(branch) {
+  const m = /^(?:handoff|task|change)\/([a-z0-9][a-z0-9._-]*)(?:\/|$)/.exec(branch);
+  return m?.[1];
+}
+var ManualGitHost = class extends ManualBase {
+  constructor(opts) {
+    super("git-host", "git-host", opts);
+  }
+  async getRepo(repo) {
+    this.journal.push({ method: "getRepo" });
+    const defaultBranch = this.setting("defaultBranch") ?? "main";
+    return {
+      repo,
+      defaultBranch,
+      protectedBranches: this.settingList("protectedBranches") ?? [defaultBranch]
+    };
+  }
+  async prSteps(repo) {
+    return (await this.opts.store.list({ system: "git-host", action: "open-pull-request" })).filter((s) => !repo || s.inputs.repo === repo);
+  }
+  async related(repo, number, action) {
+    return (await this.opts.store.list({ system: "git-host", action })).filter((s) => s.inputs.repo === repo && s.inputs.number === number);
+  }
+  async toPr(open) {
+    const repo = String(open.inputs.repo);
+    const number = Number(open.inputs.number);
+    const rec = open.state === "done" ? open.recorded?.values : void 0;
+    const merged = (await this.related(repo, number, "merge-pull-request")).some((s) => s.state === "done");
+    const reports = (await this.related(repo, number, "report-pull-request")).filter((s) => s.state === "done").sort((a, b) => a.recorded.at < b.recorded.at ? -1 : 1);
+    const last = reports.at(-1)?.recorded?.values;
+    const list = (v) => Array.isArray(v) ? v.map(String) : [];
+    const reviews = [
+      ...list(last?.approvers).map((by) => ({ by, state: "approved" })),
+      ...list(last?.changesRequestedBy).map((by) => ({ by, state: "changes-requested" }))
+    ];
+    const closed = (await this.related(repo, number, "close-pull-request")).some((s) => s.state === "done");
+    let state = open.state === "done" ? open.inputs.draft ? "draft" : "open" : "draft";
+    if (open.state === "skipped" || closed)
+      state = "closed";
+    if (merged)
+      state = "merged";
+    return {
+      repo,
+      number,
+      url: typeof rec?.url === "string" ? rec.url : `manual://git-host/${repo}/pull/${number}`,
+      title: String(open.inputs.title ?? ""),
+      body: open.fields.find((f) => f.name === "Description")?.value ?? "",
+      head: String(open.inputs.head),
+      base: String(open.inputs.base),
+      state,
+      reviews,
+      checks: last?.checksPassing === void 0 ? [] : [{ name: "reported by a person", status: last.checksPassing ? "passed" : "failed" }],
+      requiredReviewers: []
+    };
+  }
+  async find(repo, number) {
+    const s = (await this.prSteps(repo)).find((x) => x.inputs.number === number);
+    return s ?? this.notFound(`PR ${repo}#${number}`, "no manual step opened it");
+  }
+  async getPullRequest(repo, number) {
+    this.journal.push({ method: "getPullRequest" });
+    return this.toPr(await this.find(repo, number));
+  }
+  async listPullRequests(repo, q) {
+    this.journal.push({ method: "listPullRequests" });
+    const out = [];
+    for (const s of await this.prSteps(repo)) {
+      const pr = await this.toPr(s);
+      if ((!q.head || pr.head === q.head) && (!q.state || pr.state === q.state))
+        out.push(pr);
+    }
+    return out;
+  }
+  /** A report step for the PR's reviews and checks, unless one is still open. */
+  async askForReviews(open, change) {
+    const repo = String(open.inputs.repo);
+    const number = Number(open.inputs.number);
+    const reports = await this.related(repo, number, "report-pull-request");
+    if (reports.some((s) => s.state === "open"))
+      return;
+    await this.step("report", {
+      slug: `report-pr-${number}`,
+      action: "report-pull-request",
+      key: `git-host|report|${repo}|${number}|${reports.length}`,
+      title: `Record the reviews and checks on PR ${number} (${open.inputs.title})`,
+      where: `Git host: ${repo}, the pull request opened for step ${open.id}`,
+      ...change ? { change } : {},
+      inputs: { repo, number },
+      fields: [
+        { name: "Repository", value: repo },
+        { name: "From branch", value: String(open.inputs.head) }
+      ],
+      instructions: [
+        "Once reviewers have acted, record who approved, who asked for changes and whether the checks pass.",
+        "Name people by their handle on the Git host. Only what is recorded here counts for approval."
+      ],
+      result: [
+        { name: "approvers", label: "Approved by", format: "handles", required: false },
+        {
+          name: "changesRequestedBy",
+          label: "Changes requested by",
+          format: "handles",
+          required: false
+        },
+        { name: "checksPassing", label: "All checks pass", format: "yes-no", required: true }
+      ],
+      dependsOn: [open.id]
+    });
+  }
+  async createPullRequest(input, approval) {
+    const a = this.approve(approval);
+    const info = await this.getRepo(input.repo);
+    if (info.protectedBranches.includes(input.head))
+      throw new AdapterError(this.name, "invalid", `${input.head} is protected and can't be a PR's source branch`);
+    const existing = await this.prSteps(input.repo);
+    for (const s of existing) {
+      if (s.inputs.head !== input.head)
+        continue;
+      const pr = await this.toPr(s);
+      if (pr.state === "open" || pr.state === "draft")
+        throw new AdapterError(this.name, "conflict", `an open PR from ${input.head} already exists`);
+    }
+    const number = existing.reduce((n, s) => Math.max(n, Number(s.inputs.number)), 0) + 1;
+    const change = this.opts.change ?? changeOfBranch(input.head);
+    const proc = this.procedureFor("open-pull-request");
+    const open = await this.step("createPullRequest", {
+      slug: `open-pr-${input.head}`,
+      action: "open-pull-request",
+      key: `git-host|pr|${input.repo}|${input.head}|${number}`,
+      title: `Open a pull request from ${input.head} into ${input.base}`,
+      where: `Git host: ${input.repo}, new pull request`,
+      ...change ? { change } : {},
+      ...proc ?? {},
+      inputs: {
+        repo: input.repo,
+        number,
+        head: input.head,
+        base: input.base,
+        title: input.title,
+        ...input.draft ? { draft: true } : {}
+      },
+      fields: [
+        { name: "Repository", value: input.repo },
+        { name: "From branch", value: input.head },
+        { name: "Into branch", value: input.base },
+        { name: "Title", value: input.title },
+        { name: "Description", value: input.body },
+        ...input.draft ? [{ name: "Draft", value: "yes" }] : []
+      ],
+      instructions: [
+        `Make sure ${input.head} is on the Git host (Atticus pushes it when it can reach the remote; otherwise push it yourself).`,
+        `Open a pull request from ${input.head} into ${input.base} with the title and description below.`,
+        "Record the pull request's link and number here."
+      ],
+      result: [
+        { name: "url", label: "Pull request link", format: "url", required: true },
+        { name: "number", label: "Pull request number", format: "integer", required: true }
+      ]
+    }, a);
+    await this.askForReviews(open, change);
+    return this.toPr(open);
+  }
+  async comment(repo, number, body, approval) {
+    const a = this.approve(approval);
+    const open = await this.find(repo, number);
+    const change = open.change;
+    await this.step("comment", {
+      slug: `comment-pr-${number}`,
+      action: "comment-pull-request",
+      key: `git-host|comment|${repo}|${number}|${shortHash(body)}`,
+      title: `Post a comment on PR ${number} (${open.inputs.title})`,
+      where: `Git host: ${repo}, the pull request opened for step ${open.id}`,
+      ...change ? { change } : {},
+      inputs: { repo, number },
+      fields: [{ name: "Comment", value: body }],
+      instructions: ["Post the comment below on the pull request."],
+      dependsOn: [open.id]
+    }, a);
+    if ((await this.toPr(open)).state !== "merged")
+      await this.askForReviews(open, change);
+  }
+  /**
+   * Closing is a step for a person (once per PR); the PR reads closed when they have done
+   * it, so until then it is returned as it is.
+   */
+  async closePullRequest(repo, number, approval) {
+    const a = this.approve(approval);
+    const open = await this.find(repo, number);
+    const pr = await this.toPr(open);
+    if (pr.state === "merged")
+      throw new AdapterError(this.name, "conflict", `PR ${number} is merged and can't be closed`);
+    if (pr.state === "closed")
+      return pr;
+    await this.step("closePullRequest", {
+      slug: `close-pr-${number}`,
+      action: "close-pull-request",
+      key: `git-host|close|${repo}|${number}`,
+      title: `Close PR ${number} (${open.inputs.title}) without merging`,
+      where: `Git host: ${repo}, ${pr.url}`,
+      ...open.change ? { change: open.change } : {},
+      inputs: { repo, number },
+      fields: [{ name: "Pull request", value: pr.url }],
+      instructions: [
+        "The change went back to the product owner: close the pull request on the Git host without merging it, then mark this step done."
+      ],
+      dependsOn: [open.id]
+    }, a);
+    return this.toPr(open);
+  }
+  async merge(repo, number, approval) {
+    const a = this.approve(approval);
+    const open = await this.find(repo, number);
+    const pr = await this.toPr(open);
+    if (pr.state === "merged")
+      return pr;
+    const blockers = mergeBlockers(pr);
+    if (blockers.length > 0)
+      throw new AdapterError(this.name, "conflict", `can't merge: ${blockers.join("; ")}`);
+    const step = await this.step("merge", {
+      slug: `merge-pr-${number}`,
+      action: "merge-pull-request",
+      key: `git-host|merge|${repo}|${number}`,
+      title: `Merge PR ${number} (${open.inputs.title}) on the Git host`,
+      where: `Git host: ${repo}, ${pr.url}`,
+      ...open.change ? { change: open.change } : {},
+      inputs: { repo, number },
+      fields: [
+        { name: "Pull request", value: pr.url },
+        {
+          name: "Approved by",
+          value: pr.reviews.filter((r) => r.state === "approved").map((r) => r.by).join(", ")
+        }
+      ],
+      instructions: [
+        "Atticus checked the recorded approvals and checks: the pull request may merge.",
+        "Merge it on the Git host, then mark this step done."
+      ],
+      result: [{ name: "mergedBy", label: "Merged by", format: "handles", required: false }],
+      dependsOn: [open.id]
+    }, a);
+    throw new AdapterError(this.name, "unavailable", `a person merges PR ${number} on the Git host: do step ${step.id} (atticus todo), then sync again`, false);
+  }
+};
+
+// packages/adapters/dist/manual/read-only.js
+import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { isAbsolute, join as join2, relative, sep } from "node:path";
+function folder(opts, value, fallback) {
+  const v = value ?? fallback;
+  return isAbsolute(v) ? v : join2(opts.root ?? ".", v);
+}
+var ManualWiki = class extends ManualBase {
+  constructor(opts) {
+    super("wiki", "wiki", opts);
+  }
+  dir() {
+    return folder(this.opts, this.setting("exportDir"), "inputs/wiki");
+  }
+  async pages() {
+    const root = this.dir();
+    const out = [];
+    const walk = async (d) => {
+      let entries;
+      try {
+        entries = await readdir2(d, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const e of entries.sort((a, b) => a.name < b.name ? -1 : 1)) {
+        if (e.name.startsWith("."))
+          continue;
+        const full = join2(d, e.name);
+        if (e.isDirectory())
+          await walk(full);
+        else if (/\.(md|markdown)$/i.test(e.name)) {
+          const id = relative(root, full).split(sep).join("/");
+          const body = await readFile2(full, "utf8");
+          const title = /^#\s+(.+)$/m.exec(body)?.[1]?.trim() ?? e.name.replace(/\.(md|markdown)$/i, "");
+          out.push({
+            id,
+            space: id.includes("/") ? id.split("/")[0] : "default",
+            title,
+            body,
+            version: 1,
+            updatedAt: (await stat2(full)).mtime.toISOString(),
+            url: `file:${id}`
+          });
+        }
+      }
+    };
+    await walk(root);
+    return out;
+  }
+  async listPages(space) {
+    this.journal.push({ method: "listPages" });
+    return (await this.pages()).filter((p2) => p2.space === space).map(({ body: _b, ...h }) => h);
+  }
+  async getPage(id) {
+    this.journal.push({ method: "getPage" });
+    return (await this.pages()).find((p2) => p2.id === id) ?? this.notFound(`page ${id}`, `export the page into ${this.dir()}`);
+  }
+  async search(text) {
+    this.journal.push({ method: "search" });
+    const t = text.toLowerCase();
+    return (await this.pages()).filter((p2) => p2.title.toLowerCase().includes(t) || p2.body.toLowerCase().includes(t)).map(({ body: _b, ...h }) => h);
+  }
+};
+var ManualDesignTool = class extends ManualBase {
+  constructor(opts) {
+    super("design-tool", "design", opts);
+  }
+  dir() {
+    return folder(this.opts, this.setting("exportDir"), "inputs/design");
+  }
+  async getFile(key) {
+    this.journal.push({ method: "getFile" });
+    try {
+      return JSON.parse(await readFile2(join2(this.dir(), `${key}.json`), "utf8"));
+    } catch {
+      return this.notFound(`design file ${key}`, `export it as ${key}.json into ${this.dir()}`);
+    }
+  }
+  async renderFrame(key, frameId) {
+    this.journal.push({ method: "renderFrame" });
+    try {
+      return new Uint8Array(await readFile2(join2(this.dir(), key, `${frameId}.png`)));
+    } catch {
+      return this.notFound(`frame ${frameId}`, `export it as ${key}/${frameId}.png into ${this.dir()}`);
+    }
+  }
+};
+var ManualNotifier = class extends ManualBase {
+  constructor(opts) {
+    super("notify", "notify", opts);
+  }
+  async send(n, approval) {
+    const a = this.approve(approval, { allowStanding: true });
+    const step = await this.step("send", {
+      slug: `message-${n.channel}`,
+      action: "send-notification",
+      key: `notify|${n.channel}|${shortHash(`${n.title}
+${n.body}
+${n.link ?? ""}`)}`,
+      title: `Send "${n.title}" to ${n.channel}`,
+      where: `Messages: ${n.channel}`,
+      inputs: { channel: n.channel },
+      fields: [
+        { name: "Channel", value: n.channel },
+        { name: "Title", value: n.title },
+        { name: "Message", value: n.body },
+        ...n.link ? [{ name: "Link", value: n.link }] : [],
+        ...n.mentions?.length ? [{ name: "Mention", value: n.mentions.join(", ") }] : []
+      ],
+      instructions: ["Send the message below to the channel, mentioning the people named."]
+    }, a);
+    return { id: provisionalId(step.id) };
+  }
+};
+
+// packages/adapters/dist/manual/service-desk.js
+var STATES = ["draft", "submitted", "in-progress", "done", "rejected"];
+var FINAL = /* @__PURE__ */ new Set(["done", "rejected"]);
+var fieldKey = (name) => name.toLowerCase().replace(/[^a-z0-9]+(.)?/g, (_m, c) => c ? c.toUpperCase() : "").replace(/^[^a-z]+/, "");
+var ManualServiceDesk = class extends ManualBase {
+  exports;
+  constructor(opts, exports = async () => []) {
+    super("service-desk", "service-desk", opts);
+    this.exports = exports;
+  }
+  numberPattern() {
+    return this.setting("numberPattern") ?? "[A-Z]{2,10}-?\\d{3,}";
+  }
+  /** The request number once its step is recorded, else the id as given. */
+  async resolveId(id) {
+    const stepId = stepOfProvisional(id);
+    if (!stepId)
+      return id;
+    const s = await this.opts.store.get(stepId);
+    const real = s?.state === "done" ? s.recorded?.values.requestNumber : void 0;
+    return typeof real === "string" ? real : id;
+  }
+  async stateAnswers(number) {
+    return (await this.opts.store.list({ system: "service-desk", action: "report-request-state" })).filter((s) => s.inputs.request === number && s.state === "done").sort((a, b) => a.recorded.at < b.recorded.at ? -1 : 1);
+  }
+  async fromStep(step) {
+    const rec = step.state === "done" ? step.recorded?.values : void 0;
+    const number = typeof rec?.requestNumber === "string" ? rec.requestNumber : void 0;
+    const fields = Object.fromEntries(step.fields.filter((f) => f.name !== "Request type").map((f) => [f.name, f.value]));
+    let state = number ? "submitted" : "draft";
+    let closedAt;
+    if (number) {
+      const last = (await this.stateAnswers(number)).at(-1);
+      const s = last?.recorded?.values.state;
+      if (typeof s === "string" && STATES.includes(s))
+        state = s;
+      const c = last?.recorded?.values.closedAt;
+      if (typeof c === "string")
+        closedAt = c;
+    }
+    return {
+      id: number ?? provisionalId(step.id),
+      type: String(step.inputs.requestType ?? ""),
+      state,
+      fields,
+      ...step.change ? { changeId: step.change } : {},
+      ...step.recorded?.at && number ? { openedAt: step.recorded.at.slice(0, 10) } : {},
+      ...closedAt ? { closedAt } : {},
+      url: typeof rec?.url === "string" ? rec.url : ""
+    };
+  }
+  async submitted() {
+    const steps = await this.opts.store.list({ system: "service-desk", action: "submit-request" });
+    return Promise.all(steps.map((s) => this.fromStep(s)));
+  }
+  /** Ask a person where an unfinished request is; one open question per request at a time. */
+  async ask(r) {
+    const answered = (await this.stateAnswers(r.id)).length;
+    await this.step("getRequest", {
+      slug: `state-${r.id}`,
+      action: "report-request-state",
+      key: `service-desk|state|${r.id}|${answered}`,
+      title: `Report where request ${r.id} is in the service desk`,
+      where: `Service desk: request ${r.id}`,
+      ...r.changeId ? { change: r.changeId } : {},
+      inputs: { request: r.id },
+      fields: [
+        { name: "Request", value: r.id },
+        { name: "Request type", value: r.type }
+      ],
+      instructions: [
+        "Open the request and record its state; give the closing date once it is done or rejected."
+      ],
+      result: [
+        { name: "state", label: "State", format: "choice", choices: STATES, required: true },
+        { name: "closedAt", label: "Closed on", format: "date", required: false }
+      ]
+    });
+  }
+  async getRequest(id) {
+    this.journal.push({ method: "getRequest" });
+    const stepId = stepOfProvisional(id);
+    const mine = stepId ? await this.opts.store.get(stepId).then((s) => s ? this.fromStep(s) : void 0) : (await this.submitted()).find((r) => r.id === id);
+    if (mine) {
+      if (mine.state !== "draft" && !FINAL.has(mine.state))
+        await this.ask(mine);
+      return mine;
+    }
+    const exported = (await this.exports()).find((r) => r.id === id);
+    return exported ?? this.notFound(`request ${id}`, "export the requests from the service desk into inputs/ so Atticus can read them");
+  }
+  async listRequests(q) {
+    this.journal.push({ method: "listRequests" });
+    const mine = await this.submitted();
+    const ids = new Set(mine.map((r) => r.id));
+    return [...mine, ...(await this.exports()).filter((r) => !ids.has(r.id))].filter((r) => (!q.changeId || r.changeId === q.changeId) && (!q.state || r.state === q.state) && (!q.type || r.type === q.type));
+  }
+  async submitRequest(draft, approval) {
+    const a = this.approve(approval);
+    const empty = Object.entries(draft.fields).filter(([, v]) => v === "").map(([k]) => k);
+    if (empty.length > 0)
+      throw new AdapterError(this.name, "invalid", `required fields are empty: ${empty.join(", ")}`);
+    const proc = this.procedureFor("submit-request", { template: draft.templateId });
+    const step = await this.step("submitRequest", {
+      slug: `request-${draft.templateId}`,
+      action: "submit-request",
+      key: `service-desk|${draft.changeId}|${draft.templateId}|${shortHash(JSON.stringify(draft.fields))}`,
+      title: `Raise a "${draft.type}" request in the service desk`,
+      where: `Service desk: "${draft.type}" request`,
+      change: draft.changeId,
+      ...proc ?? {},
+      inputs: {
+        template: draft.templateId,
+        requestType: draft.type,
+        ...Object.fromEntries(Object.entries(draft.fields).map(([k, v]) => [fieldKey(k), v]))
+      },
+      fields: [
+        { name: "Request type", value: draft.type },
+        ...Object.entries(draft.fields).map(([name, v]) => ({ name, value: String(v) }))
+      ],
+      instructions: [
+        `Open a new "${draft.type}" request and copy the fields below.`,
+        "Submit it and record the request number here."
+      ],
+      result: [
+        {
+          name: "requestNumber",
+          label: "Request number",
+          format: "pattern",
+          pattern: this.numberPattern(),
+          help: "the number the service desk gave the request, such as SR-0042",
+          required: true
+        },
+        { name: "url", label: "Link to the request", format: "url", required: false }
+      ]
+    }, a);
+    return this.fromStep(step);
+  }
+};
+
+// packages/adapters/dist/manual/work-tracker.js
+var TYPE_NAME = {
+  epic: "Epic",
+  feature: "Feature",
+  story: "User Story",
+  task: "Task",
+  bug: "Bug"
+};
+var ManualWorkTracker = class extends ManualBase {
+  exports;
+  constructor(opts, exports = async () => []) {
+    super("work-tracker", "work-tracker", opts);
+    this.exports = exports;
+  }
+  idPattern() {
+    return this.setting("idPattern") ?? "[A-Za-z]*-?\\d+";
+  }
+  /** The real id once its step is recorded, else the id as given. */
+  async resolveId(id) {
+    const stepId = stepOfProvisional(id);
+    if (!stepId)
+      return id;
+    const s = await this.opts.store.get(stepId);
+    const real = s?.state === "done" ? s.recorded?.values.id : void 0;
+    return typeof real === "string" ? real : id;
+  }
+  parentField(parent, deps) {
+    if (!parent)
+      return "";
+    const stepId = stepOfProvisional(parent);
+    if (!stepId)
+      return parent;
+    deps.push(stepId);
+    return `the id you record for step ${stepId}`;
+  }
+  itemFrom(step) {
+    const f = (n) => step.fields.find((x) => x.name === n)?.value ?? "";
+    const rec = step.state === "done" ? step.recorded?.values : void 0;
+    const type = Object.entries(TYPE_NAME).find(([, v]) => v === f("Work item type"))?.[0] ?? "task";
+    const parent = step.inputs.parent ?? void 0;
+    return {
+      id: typeof rec?.id === "string" ? rec.id : provisionalId(step.id),
+      type,
+      title: f("Title"),
+      description: f("Description"),
+      acceptanceCriteria: f("Acceptance criteria"),
+      state: rec ? "New" : "Not created yet",
+      ...parent ? { parent } : {},
+      ...f("Assigned to") ? { assignee: f("Assigned to") } : {},
+      tags: f("Tags").split(";").map((t) => t.trim()).filter(Boolean),
+      url: typeof rec?.url === "string" ? rec.url : ""
+    };
+  }
+  async known() {
+    const created = await this.opts.store.list({
+      system: "work-tracker",
+      action: "create-work-item"
+    });
+    const fromSteps = created.map((s) => this.itemFrom(s));
+    const exported = await this.exports();
+    const ids = new Set(fromSteps.map((i) => i.id));
+    return [...fromSteps, ...exported.filter((i) => !ids.has(i.id))];
+  }
+  async getItem(id) {
+    this.journal.push({ method: "getItem" });
+    const real = await this.resolveId(id);
+    const item = (await this.known()).find((i) => i.id === real || i.id === id);
+    return item ?? this.notFound(`work item ${id}`, "export the work items from the tracker into inputs/ (CSV or JSON) so Atticus can read them");
+  }
+  async query(q) {
+    this.journal.push({ method: "query" });
+    const text = q.text?.toLowerCase();
+    return (await this.known()).filter((i) => (!q.type || i.type === q.type) && (!q.parent || i.parent === q.parent) && (!q.state || i.state === q.state) && (!q.tag || i.tags.includes(q.tag)) && (!text || i.title.toLowerCase().includes(text) || i.description.toLowerCase().includes(text)));
+  }
+  async createItem(input, approval) {
+    const a = this.approve(approval);
+    const deps = [];
+    const parent = input.parent ? await this.resolveId(input.parent) : void 0;
+    const keyTag = input.tags?.find((t) => t.startsWith("atticus:"));
+    const proc = this.procedureFor("create-work-item");
+    const step = await this.step("createItem", {
+      slug: `create-${input.type}-${input.title}`,
+      action: "create-work-item",
+      key: `work-tracker|create|${keyTag ?? `${input.type}|${input.title}`}`,
+      title: `Create the ${TYPE_NAME[input.type].toLowerCase()} "${input.title}" in the work tracker`,
+      where: `Work tracker${this.setting("project") ? `, project ${this.setting("project")}` : ""}: new ${TYPE_NAME[input.type]}`,
+      ...proc ?? {},
+      inputs: {
+        type: input.type,
+        title: input.title,
+        ...parent ? { parent } : {}
+      },
+      fields: [
+        { name: "Work item type", value: TYPE_NAME[input.type] },
+        { name: "Title", value: input.title },
+        { name: "Description", value: input.description ?? "" },
+        { name: "Acceptance criteria", value: input.acceptanceCriteria ?? "" },
+        { name: "Parent", value: this.parentField(parent, deps) },
+        { name: "Tags", value: (input.tags ?? []).join("; ") },
+        { name: "Assigned to", value: input.assignee ?? "" }
+      ].filter((f) => f.value !== "" || ["Title", "Work item type"].includes(f.name)),
+      instructions: [
+        `Create a new ${TYPE_NAME[input.type]} with the fields below (or import the CSV export).`,
+        ...deps.length ? [`Set its parent to the id recorded for step ${deps[0]}.`] : [],
+        "Record the new item's id (and its link) here."
+      ],
+      result: [
+        {
+          name: "id",
+          label: "Work item id",
+          format: "pattern",
+          pattern: this.idPattern(),
+          help: "the id the tracker gave the new item, such as 4711",
+          required: true
+        },
+        { name: "url", label: "Link to the item", format: "url", required: false }
+      ],
+      dependsOn: deps
+    }, a);
+    return this.itemFrom(step);
+  }
+  async updateItem(id, patch, approval) {
+    const a = this.approve(approval);
+    const real = await this.resolveId(id);
+    const deps = [];
+    const target = stepOfProvisional(real);
+    if (target)
+      deps.push(target);
+    const changes = Object.entries(patch).filter(([, v]) => v !== void 0);
+    const label = {
+      type: "Work item type",
+      title: "Title",
+      description: "Description",
+      acceptanceCriteria: "Acceptance criteria",
+      parent: "Parent",
+      assignee: "Assigned to",
+      tags: "Tags",
+      state: "State"
+    };
+    await this.step("updateItem", {
+      slug: `update-${real}`,
+      action: "update-work-item",
+      key: `work-tracker|update|${real}|${shortHash(JSON.stringify(changes))}`,
+      title: `Update work item ${target ? `from step ${target}` : real} in the work tracker`,
+      where: `Work tracker: item ${target ? `recorded for step ${target}` : real}`,
+      inputs: { id: real, ...Object.fromEntries(changes) },
+      fields: changes.map(([k, v]) => ({
+        name: label[k] ?? k,
+        value: Array.isArray(v) ? v.join("; ") : k === "parent" ? this.parentField(String(v), deps) : String(v)
+      })),
+      instructions: ["Open the item and set the fields below to these values."],
+      dependsOn: [...new Set(deps)]
+    }, a);
+    const base = await this.getItem(real).catch(() => void 0);
+    return {
+      ...base ?? {
+        id: real,
+        type: patch.type ?? "task",
+        title: patch.title ?? "",
+        description: "",
+        acceptanceCriteria: "",
+        state: "New",
+        tags: [],
+        url: ""
+      },
+      ...Object.fromEntries(changes)
+    };
+  }
+  async link(from, to, kind, approval) {
+    const a = this.approve(approval);
+    const deps = [];
+    const show = async (id) => {
+      const real = await this.resolveId(id);
+      return this.parentField(real, deps) || real;
+    };
+    const f = await show(from);
+    const t = await show(to);
+    await this.step("link", {
+      slug: `link-${kind}`,
+      action: "link-work-items",
+      key: `work-tracker|link|${from}|${to}|${kind}`,
+      title: `Link two work items (${kind}) in the work tracker`,
+      where: "Work tracker: the item's links",
+      inputs: { from, to, kind },
+      fields: [
+        { name: "From item", value: f },
+        { name: "To item", value: t },
+        {
+          name: "Link type",
+          value: kind === "parent" ? "Parent" : kind === "blocks" ? "Blocks" : "Related"
+        }
+      ],
+      instructions: ["Open the first item and add the link to the second."],
+      dependsOn: [...new Set(deps)]
+    }, a);
+  }
+};
+
+// packages/adapters/dist/manual/fallback.js
+function manualAdapter(kind, ctx, settings = {}) {
+  const opts = {
+    store: ctx.store,
+    settings,
+    ...ctx.root ? { root: ctx.root } : {},
+    ...ctx.change ? { change: ctx.change } : {},
+    ...ctx.procedures ? { procedures: ctx.procedures } : {},
+    ...ctx.now ? { now: ctx.now } : {}
+  };
+  switch (kind) {
+    case "workTracker":
+      return new ManualWorkTracker(opts, ctx.readers?.workItems);
+    case "serviceDesk":
+      return new ManualServiceDesk(opts, ctx.readers?.requests);
+    case "gitHost":
+      return new ManualGitHost(opts);
+    case "wiki":
+      return new ManualWiki(opts);
+    case "notify":
+      return new ManualNotifier(opts);
+    case "design":
+      return new ManualDesignTool(opts);
+  }
+}
+var FALLBACK_CODES = /* @__PURE__ */ new Set(["unavailable", "unauthorized"]);
+function withManualFallback(kind, live, manual, onFallback) {
+  return new Proxy(live, {
+    get(target, prop, receiver) {
+      const v = Reflect.get(target, prop, receiver);
+      if (typeof v !== "function")
+        return v;
+      return async (...args) => {
+        try {
+          return await v.apply(target, args);
+        } catch (e) {
+          if (!(e instanceof AdapterError) || !FALLBACK_CODES.has(e.code))
+            throw e;
+          const m = manual[prop];
+          if (typeof m !== "function")
+            throw e;
+          const reason = `the ${kind} adapter failed (${e.code}): ${e.message}`;
+          onFallback?.({ kind, method: String(prop), code: e.code, message: e.message });
+          manual.reason = reason;
+          try {
+            return await m.apply(manual, args);
+          } finally {
+            manual.reason = void 0;
+          }
+        }
+      };
+    }
+  });
+}
+
+// packages/adapters/dist/registry.js
+var MOCKS = {
+  workTracker: { mock: () => new MockWorkTracker() },
+  serviceDesk: { mock: () => new MockServiceDesk() },
+  gitHost: { mock: () => new MockGitHost() },
+  wiki: { mock: () => new MockWiki() },
+  notify: { mock: () => new MockNotifier() },
+  design: { mock: () => new MockDesignTool() }
+};
+function createAdapters(runtime, factories = {}, manual) {
+  const out = {};
+  const kinds = ["workTracker", "serviceDesk", "gitHost", "wiki", "notify", "design"];
+  for (const kind of kinds) {
+    const cfg = runtime.adapters[kind];
+    if (!cfg)
+      continue;
+    if (cfg.type === "manual") {
+      if (!manual)
+        throw new AdapterError(kind, "invalid", "a manual adapter writes steps into the metarepo; build adapters with the metarepo's step store");
+      out[kind] = manualAdapter(kind, manual, cfg.settings);
+      continue;
+    }
+    const make = factories[kind]?.[cfg.type] ?? MOCKS[kind][cfg.type];
+    if (!make) {
+      throw new AdapterError(kind, "invalid", `no ${cfg.type} adapter is installed; add its plugin or set type: mock for tests`);
+    }
+    if (!manual || manual.fallback === false) {
+      out[kind] = make(cfg.settings);
+      continue;
+    }
+    const fallback = manualAdapter(kind, manual, cfg.settings);
+    let live;
+    try {
+      live = make(cfg.settings);
+    } catch (e) {
+      if (!(e instanceof AdapterError) || !FALLBACK_CODES.has(e.code))
+        throw e;
+      manual.onFallback?.({ kind, method: "connect", code: e.code, message: e.message });
+      fallback.reason = `the ${kind} adapter couldn't start (${e.code}): ${e.message}`;
+      out[kind] = fallback;
+      continue;
+    }
+    out[kind] = withManualFallback(kind, live, fallback, manual.onFallback);
+  }
+  return out;
+}
+
+export {
+  AdapterError,
+  requireApproval,
+  workItemsCsv,
+  mergeBlockers,
+  fileStepStore,
+  checkResult,
+  StepError,
+  recordStep,
+  exportStep,
+  stepOfProvisional,
+  ManualNotifier,
+  manualAdapter,
+  createAdapters
+};