@kitman-sh/cli 0.10.52 → 0.10.54

package/dist/chunk-vyv0p5eq.js

@@ -1,3183 +0,0 @@
-// @bun
-import {
-  isString2,
-  forEach,
-  succeed6,
-  void_3,
-  gen,
-  map8,
-  as,
-  catchTag,
-  catchTags,
-  catchIf,
-  tapError2,
-  ignore,
-  optionalKey,
-  optional,
-  Literal,
-  String4,
-  Boolean2,
-  Struct,
-  Record,
-  ArraySchema,
-  NonEmptyArray,
-  Literals,
-  isPattern,
-  Finite,
-  isGreaterThanOrEqualTo,
-  isLessThanOrEqualTo,
-  Int,
-  isMaxLength,
-  TaggedError2,
-  Json
-} from "./chunk-mbctzx7e.js";
-import"./chunk-arvwar2c.js";
-import {
-  CheckName,
-  MeasurePlan
-} from "./chunk-wh1pa2aa.js";
-import {
-  LoopOutcome,
-  defineLoop,
-  failsOn,
-  evidenceGate,
-  ChildFailed,
-  agentWork,
-  agentWorkOnce,
-  ask,
-  call,
-  waitFor,
-  verify,
-  PlanTickets,
-  planWaves,
-  ChangeRequestResult,
-  RunFile,
-  CreateTasksResult,
-  ApproveChangeRequestResult,
-  TranscriptPoint,
-  changeRequest,
-  writeBack,
-  artifact,
-  note,
-  comment,
-  createTasks,
-  alertTask,
-  integrationBranch,
-  mergeChangeRequest,
-  approveChangeRequest,
-  closeChangeRequest,
-  pipelineMoved,
-  rerunPipeline,
-  reportPipeline,
-  release2,
-  transcripts,
-  propose,
-  projectActivity,
-  pipelineStatus,
-  reviewThreads,
-  openChangeRequests,
-  ownChangeRequests,
-  draftUpdate,
-  claim,
-  measure,
-  Finding,
-  MergedFinding,
-  Rebuttal,
-  RebuttalVerdict,
-  ScopeJudgement,
-  isBlocking,
-  mergeFindings,
-  settleRound,
-  rallyStop,
-  syncBase,
-  Continuing,
-  continuingBrief
-} from "./chunk-txwt6r25.js";
-import"./chunk-pp1p3g6e.js";
-import"./chunk-1mc9vgcr.js";
-import"./chunk-z821b2gp.js";
-
-// packages/loops/src/change-request-body.ts
-var scopeFindings = (scope) => (scope?.unmet ?? []).map((item) => ({
-  id: `scope: ${item}`,
-  severity: "blocker",
-  file: "",
-  line: 0,
-  detail: "The reviewer found this part of the Task not done.",
-  seats: ["code-review"]
-}));
-var brokenChecks = (head) => head.unchanged === true ? [] : head.checks.filter((check) => check.status === "failed" && !check.preExisting);
-var isCheckFinding = (id) => id.startsWith("check: ");
-var checkFindings = (head) => brokenChecks(head).map((check) => ({
-  id: `check: ${check.name}`,
-  severity: "blocker",
-  file: "",
-  line: 0,
-  detail: [
-    `\`${check.command}\` fails on the head and passes on the base.`,
-    ...check.outputTail === undefined ? [] : ["It printed:", "```", check.outputTail, "```"]
-  ].join(`
-`),
-  seats: ["verify"]
-}));
-var unsettledItems = (settled, decision) => decision.unsettled.filter((id) => !isCheckFinding(id)).map((id) => {
-  const standing = settled.standing.find((entry) => entry.finding.id === id);
-  if (standing !== undefined)
-    return `Dispute stands on ${id}: ${standing.finding.detail} (rebutted: ${standing.rebuttal.reason})`;
-  return `Unresolved ${settled.open.find((finding) => finding.id === id)?.severity ?? "blocker"} at ${id}: ${settled.open.find((finding) => finding.id === id)?.detail ?? ""}`;
-});
-var evidenceTable = (head) => [
-  `Collected by a Runner for revision \`${head.revision}\`, tree \`${head.tree}\`; it holds for any revision with this tree.`,
-  "",
-  "| Check | Command | Result |",
-  "| --- | --- | --- |",
-  ...head.checks.map((entry) => `| ${entry.name}${entry.suggested === true ? " (suggested by the agent)" : ""} | \`${entry.command}\` | ${entry.status}${entry.status === "failed" && (entry.preExisting || head.unchanged === true) ? " (also fails on the base branch)" : ""} |`),
-  ...head.checks.some((entry) => entry.suggested === true) ? [
-    "",
-    "The repository has no approved verifications, so these are the agent's suggestions; check them, and approve the ones to keep with `kitman verify add`."
-  ] : []
-].join(`
-`);
-var changeRequestBody = (build) => [
-  build.summary,
-  "## Evidence",
-  evidenceTable(build.head),
-  ...build.criteria === undefined || build.criteria.length === 0 ? [] : ["## Acceptance criteria", ...build.criteria.map((answer) => `- ${answer}`)],
-  "## Claims",
-  "What the agent says and Kitman has not checked.",
-  ...build.claims.length === 0 ? ["None."] : build.claims.map((claim) => `- ${claim}`),
-  "## Unsettled",
-  ...build.unsettled.length === 0 ? ["Nothing is unsettled."] : build.unsettled.map((item) => `- ${item}`),
-  ...build.later === undefined || build.later.length === 0 ? [] : ["## Left for later", ...build.later.map((item) => `- ${item}`)],
-  "## Review",
-  `${build.rounds} review round${build.rounds === 1 ? "" : "s"}; the rally stopped: ${build.stopped.replaceAll("_", " ")}.`
-].join(`
-
-`);
-
-// packages/loops/src/review.ts
-var buildLoop = () => ({ id: "build", input: BuildInput, output: BuildOutput });
-var seats = {
-  "code-review": {
-    skill: "code-review",
-    focus: "Review along two axes: Standards (does the change follow the repository's documented conventions?) and Spec (does it do what was asked?)."
-  },
-  quality: {
-    skill: "code-review-and-quality",
-    focus: "Review across correctness, readability, architecture, security and performance."
-  }
-};
-var seatNames = ["code-review", "quality"];
-var scopeSeat = "code-review";
-var choices = ["Post to the ChangeRequest", "Fix here", "Build from it", "Done"];
-var Input = Struct({
-  changeRequestId: optional(String4),
-  base: optional(String4),
-  head: optional(String4),
-  files: optional(ArraySchema(String4)),
-  since: optional(String4),
-  rebuttals: optional(ArraySchema(Rebuttal)),
-  outcome: optional(LoopOutcome),
-  claims: optional(ArraySchema(String4)),
-  earlier: optional(ArraySchema(MergedFinding)),
-  failing: optional(ArraySchema(String4)),
-  next: optional(Literals(choices))
-});
-var FollowUpStatus = Literals(["fixed", "changed", "still_there"]);
-var FollowUp = Struct({ id: String4, status: FollowUpStatus });
-var SeatOutput = Struct({
-  summary: String4,
-  findings: ArraySchema(Finding),
-  verdicts: optional(ArraySchema(RebuttalVerdict)),
-  scope: optional(ScopeJudgement),
-  followUps: optional(ArraySchema(FollowUp))
-});
-var Output = Struct({
-  summary: String4,
-  findings: ArraySchema(MergedFinding),
-  followUps: ArraySchema(FollowUp),
-  verdicts: ArraySchema(RebuttalVerdict),
-  blocking: Boolean2,
-  artifactId: String4,
-  scope: optional(ScopeJudgement),
-  approval: optional(Struct({ head: String4, approved: Boolean2, reason: optional(String4) })),
-  next: optional(Struct({ choice: Literals(choices), detail: optional(String4) }))
-});
-
-class ReviewTargetMissing extends TaggedError2()("ReviewTargetMissing", {
-  message: String4
-}) {
-}
-var targetOf = (input, head) => {
-  if (input.changeRequestId !== undefined)
-    return `ChangeRequest ${input.changeRequestId} at revision ${head}. Read it with \`kitman.changeRequests.get("${input.changeRequestId}")\` through Kitman's MCP, fetch its source branch, and review the diff of revision ${head} against its target branch, even if the branch has moved since. If the Runner cannot fetch that revision (a fork, say), report exactly that as your only finding, a blocker, and stop.`;
-  if (input.base !== undefined && input.head !== undefined)
-    return input.files === undefined ? `the change \`git diff ${input.base}...${input.head}\` in your checkout.` : [
-      `only these files of the change \`git diff ${input.base}...${input.head}\` in your checkout; the rest of it was reviewed and approved before:`,
-      ...input.files.map((file) => `- ${file}`),
-      ...input.since === undefined ? [] : [`Also review all of \`git diff ${input.since}..${input.head}\`, whichever files it touches.`]
-    ].join(`
-`);
-  return;
-};
-var scopePrompt = (input) => [
-  "If your brief has a Task, judge its scope and give it as `scope`: does the change do what the Task's description and each of its Acceptance Criteria ask? Set `met` to true only if it does all of it, and list in `unmet` one line for each criterion or part of the description that is not done. If your brief has no Task, leave `scope` out.",
-  ...input.outcome === undefined ? [] : [`The Outcome to prove is ${input.outcome}.`],
-  ...input.claims === undefined || input.claims.length === 0 ? [] : [
-    "The implementer claims it built these. Check them against the code rather than taking them on trust:",
-    ...input.claims.map((claim) => `- ${claim}`)
-  ]
-].join(`
-
-`);
-var earlierPrompt = (earlier) => [
-  "An earlier review found these. Give each as a `followUps` entry with its id: fixed, changed (the code moved but the problem stands) or still_there. Do not report them again as findings; review only what changed since, for new problems.",
-  ...earlier.map((finding) => `- ${finding.id} (${finding.severity}): ${finding.detail}`)
-].join(`
-`);
-var promptFor = (seat, target, input) => [
-  `You are one of two reviewers. Follow your \`${seats[seat].skill}\` skill; if you do not have it: ${seats[seat].focus}`,
-  `Review ${target}`,
-  "Give `summary`: one sentence on whether it can merge and what matters most.",
-  "Report each problem as a finding: severity blocker (must not ship), major (fix before merge) or minor (optional); the file path from the repository root; the line; and the detail. When it is one instance of a class of bug, name every other instance in the diff in its detail. Report nothing you have not checked in the code.",
-  "If the diff is too big to review in one go, review it directory by directory and say so in a finding on the first file you skipped.",
-  ...seat === scopeSeat && input.files === undefined ? [scopePrompt(input)] : [],
-  ...input.earlier === undefined || input.earlier.length === 0 ? [] : [earlierPrompt(input.earlier)],
-  ...input.failing === undefined || input.failing.length === 0 ? [] : [
-    `These checks fail on this head and pass on the base: ${input.failing.join(", ")}. The implementer has their output, so do not report them as findings, and do not say it can merge while they fail.`
-  ],
-  ...input.rebuttals === undefined || input.rebuttals.length === 0 ? [] : [
-    "The implementer disputes these findings. For each, give a verdict: accepted if the rebuttal is right and the finding should be dropped.",
-    ...input.rebuttals.map((rebuttal) => `- ${rebuttal.findingId}: ${rebuttal.reason}`)
-  ]
-].join(`
-
-`);
-var rank = { still_there: 0, changed: 1, fixed: 2 };
-var followUpsOf = (earlier, answers) => earlier.map((finding) => {
-  const statuses = answers.flatMap((answer) => answer.id === finding.id ? [answer.status] : []);
-  return {
-    id: finding.id,
-    status: statuses.length === 0 ? "still_there" : statuses.reduce((worst, status) => rank[status] < rank[worst] ? status : worst)
-  };
-});
-var reviewText = (summary, findings, followUps) => [
-  `**Kitman review.** ${summary}`,
-  ...findings.length === 0 ? [] : [
-    findings.map((finding) => `- **${finding.severity}** \`${finding.id}\` ${finding.detail} _(${finding.seats.join(", ")})_`).join(`
-`)
-  ],
-  ...followUps.length === 0 ? [] : [
-    `Earlier findings:
-${followUps.map((entry) => `- \`${entry.id}\` ${entry.status.replace("_", " ")}`).join(`
-`)}`
-  ]
-].join(`
-
-`);
-var fixBrief = (changeRequestId, findings) => [
-  `Fix what a review of ChangeRequest ${changeRequestId} found, on its branch:`,
-  ...findings.map((finding) => `- ${finding.id} (${finding.severity}): ${finding.detail}`)
-].join(`
-`);
-var review_default = defineLoop({
-  id: "review",
-  version: "3.3.0",
-  title: "Review",
-  input: Input,
-  output: Output,
-  agents: { "code-review": "code-reviewer", quality: "quality-reviewer" },
-  checkout: "read",
-  capabilities: [
-    "agent_work",
-    "post_comment",
-    "ask",
-    "call",
-    "verify",
-    "change_request",
-    "write_back",
-    "read_change_request",
-    "merge_change_request",
-    "approve_change_request"
-  ],
-  calls: () => [build_default],
-  offers: [
-    { id: "build", title: "Build from it", loop: "build" },
-    { id: "review", title: "Review again", loop: "review" }
-  ],
-  run: (input) => gen(function* () {
-    const head = input.changeRequestId === undefined ? undefined : (yield* pipelineStatus("head", { changeRequestId: input.changeRequestId })).head;
-    const target = targetOf(input, head);
-    if (target === undefined)
-      return yield* new ReviewTargetMissing({ message: "Name a ChangeRequest, or both base and head revisions" });
-    const outputs = yield* forEach(seatNames, (seat) => agentWork(`review:${seat}`, {
-      agent: seat,
-      prompt: promptFor(seat, target, input),
-      output: SeatOutput
-    }).pipe(map8((output) => [seat, output])), { concurrency: "unbounded" });
-    const earlier = input.earlier ?? [];
-    const earlierIds = new Set(earlier.map((finding) => finding.id));
-    const followUps = followUpsOf(earlier, outputs.flatMap(([, output]) => output.followUps ?? []));
-    const standing = new Set(followUps.flatMap((entry) => entry.status === "fixed" ? [] : [entry.id]));
-    const carried = earlier.filter((finding) => standing.has(finding.id));
-    const fresh = mergeFindings(Object.fromEntries(outputs.map(([seat, output]) => [
-      seat,
-      output.findings.filter((finding) => !earlierIds.has(`${finding.file}:${finding.line}`))
-    ])));
-    const findings = [...carried, ...fresh];
-    const summary = findings.length === 0 ? "No findings: nothing stands in the way of merging." : outputs.map(([, output]) => output.summary).join(" ");
-    const freshIds = new Set(fresh.map((finding) => finding.id));
-    const text = reviewText(summary, findings, followUps);
-    const scope = input.files === undefined ? outputs.find(([seat]) => seat === scopeSeat)?.[1].scope : undefined;
-    const stored = yield* artifact("findings", {
-      kind: "review-findings",
-      title: "Review findings",
-      text,
-      data: { findings, followUps }
-    });
-    const reviewed = {
-      summary,
-      findings,
-      followUps,
-      verdicts: outputs.flatMap(([, output]) => output.verdicts ?? []),
-      blocking: findings.some(isBlocking),
-      artifactId: stored.artifactId,
-      ...scope === undefined ? undefined : { scope }
-    };
-    const changeRequestId = input.changeRequestId;
-    if (changeRequestId === undefined || head === undefined)
-      return reviewed;
-    const approval = reviewed.blocking || scope?.met === false || (input.failing?.length ?? 0) > 0 ? undefined : yield* approveChangeRequest("approve", { changeRequestId, head, summary }).pipe(map8((result) => result.approved ? { head, approved: true } : { head, approved: false, reason: result.reason }));
-    const answer = input.next ?? (yield* ask("next", {
-      prompt: `${summary}
-
-What next?`,
-      options: [
-        { value: "Post to the ChangeRequest", description: "Comments the findings on the ChangeRequest." },
-        { value: "Fix here", description: "A Build fixes them and pushes to this ChangeRequest." },
-        { value: "Build from it", description: "A Build fixes them in a new ChangeRequest." },
-        { value: "Done", description: "Keeps the review as an artifact and stops." }
-      ],
-      recommended: reviewed.blocking ? "Fix here" : "Done",
-      recommendationReason: reviewed.blocking ? "A blocking finding stops the merge, and fixing it here is the shortest way through." : "Nothing blocks the merge, so the findings can wait in the Run.",
-      default: "Done",
-      timeout: "1 hour"
-    }));
-    const choice = choices.find((option) => option === answer) ?? "Done";
-    const next = yield* gen(function* () {
-      if (choice === "Post to the ChangeRequest") {
-        yield* comment("post", { changeRequestId, body: text, summary: "kitman-review" });
-        const anchors = findings.flatMap((finding) => !freshIds.has(finding.id) || finding.line < 1 ? [] : [{ file: finding.file, line: finding.line, body: `**${finding.severity}:** ${finding.detail}` }]);
-        if (anchors.length === 0)
-          return { choice };
-        return yield* comment("anchors", { changeRequestId, body: "", anchors }).pipe(as({ choice }), catchTag("StepFailed", (error) => succeed6({ choice, detail: `Posted the summary; the line comments failed: ${error.reason}` })));
-      }
-      if (choice === "Fix here") {
-        const fixed = yield* call("fix", buildLoop(), {
-          words: fixBrief(changeRequestId, findings),
-          changeRequestId,
-          maxRounds: 2
-        });
-        return { choice, detail: fixed.settled ? "Fixed and pushed" : `Pushed; left: ${fixed.unsettled.join("; ")}` };
-      }
-      if (choice === "Build from it") {
-        const built = yield* call("build", buildLoop(), { words: fixBrief(changeRequestId, findings) });
-        return { choice, detail: built.changeRequest.url };
-      }
-      return { choice, detail: "The review is kept as an artifact" };
-    }).pipe(catchTag("ChildFailed", (failed) => succeed6({ choice, detail: failed.reason })));
-    return { ...reviewed, ...approval === undefined ? undefined : { approval }, next };
-  })
-});
-
-// packages/loops/src/shepherd-output.ts
-var ShepherdOutput = Struct({
-  status: Literals(["merged", "ready", "needs_you"]),
-  reason: String4,
-  fixRounds: Int,
-  replies: Int
-});
-
-// packages/loops/src/shepherd.ts
-var reviewLoop = () => ({ id: "review", input: Input, output: Output });
-var stepBudget = "45 minutes";
-var Input2 = Struct({
-  changeRequestId: String4,
-  taskId: optional(String4),
-  merge: optional(Boolean2),
-  branch: optional(String4),
-  continuing: optional(Continuing),
-  maxFixRounds: optional(Int),
-  maxCycles: optional(Int)
-});
-var Output2 = ShepherdOutput;
-var CiFix = Struct({
-  verdict: Literals(["fixed", "pre_existing", "flaky"]),
-  summary: String4
-});
-var Replies = Struct({
-  replies: ArraySchema(Struct({
-    threadId: String4,
-    reply: String4,
-    changed: Boolean2
-  }))
-});
-var failedJobs = (pipeline) => pipeline.jobs.flatMap((job) => job.status === "failed" ? [`### ${job.name}${job.url === undefined ? "" : ` (${job.url})`}
-
-${job.logTail ?? "No log was served."}`] : []);
-var ciFixPrompt = (pipeline, target) => [
-  `The pipeline at ${pipeline.head} failed. These jobs failed, with the end of each log:`,
-  ...failedJobs(pipeline),
-  "Run the failing job once more here to rule out a flake; if it passes, change nothing and answer flaky.",
-  `Then run it on the target branch (a worktree of \`origin/${target}\`, which Kitman fetched just before this Step; do not fetch). If it fails there too, the branch did not cause it: change nothing and answer pre_existing.`,
-  "Otherwise it is this branch's own failure: write or fix a test that shows it first, then fix it, and answer fixed. Kitman pushes what you leave."
-].join(`
-
-`);
-var threadLine = (thread) => [
-  `### Thread ${thread.id}${thread.path === undefined ? "" : ` on ${thread.path}${thread.line === undefined ? "" : `:${thread.line}`}`}`,
-  ...thread.comments.map((entry) => `${entry.author ?? "someone"}: ${entry.body}`)
-].join(`
-`);
-var ReviewFix = Struct({ summary: String4 });
-var reviewFixPrompt = (findings) => [
-  "A review of the files the catch-up merge changed found these. Fix each blocker and major finding, with a test that shows it where one can. Kitman pushes what you leave.",
-  ...findings.map((finding) => `- ${finding.id} (${finding.severity}): ${finding.detail}`)
-].join(`
-`);
-var catchUpVerdict = (catchUp) => {
-  if (catchUp.truncated)
-    return { kind: "changed", why: "it changed more files than the Runner compares" };
-  const files = [...new Set([...catchUp.conflicted, ...catchUp.rewritten])];
-  const elsewhere = catchUp.changed.filter((file) => !files.includes(file));
-  if (elsewhere.length > 0)
-    return { kind: "changed", why: `the branch's own diff changed in ${elsewhere.join(", ")}` };
-  return files.length === 0 ? { kind: "carry" } : { kind: "review", files };
-};
-var repliesPrompt = (threads) => [
-  "Reviewers left these comments on the ChangeRequest. For each thread, apply what you agree with and give the reply to post on it: what you changed, or why you did not. A comment that asks a question gets an answer and no change.",
-  "Never mark a thread resolved: whether a disputed point is settled is the reviewer's call.",
-  ...threads.map(threadLine)
-].join(`
-
-`);
-var threadKey = (thread) => `${thread.id}:${thread.comments.length}`;
-var shepherd_default = defineLoop({
-  id: "shepherd",
-  version: "1.1.0",
-  title: "Shepherd",
-  input: Input2,
-  output: Output2,
-  agents: { implementer: "implementer" },
-  checkout: "write",
-  capabilities: [
-    "agent_work",
-    "read_change_request",
-    "post_comment",
-    "merge_change_request",
-    "approve_change_request",
-    "call",
-    "write_back",
-    "ask",
-    "verify"
-  ],
-  calls: () => [review_default],
-  run: (input) => {
-    const changeRequestId = input.changeRequestId;
-    const target = input.continuing?.targetBranch ?? input.branch ?? "HEAD";
-    const answered = new Set;
-    const reranHeads = new Set;
-    const ranOnRunner = new Set;
-    let fixRounds = 0;
-    let replies = 0;
-    let stalledAt;
-    let stalls = 0;
-    let unreviewed;
-    let notCarried;
-    const done = (status, reason) => ({ status, reason, fixRounds, replies });
-    const runOnRunner = (step, cycle, head, checks) => gen(function* () {
-      const verification = `pipeline-${step}:${cycle}`;
-      const failed = yield* verify(verification, { revision: head, checks }).pipe(as(undefined), catchTag("StepFailed", (error) => succeed6(error.reason)));
-      if (failed === undefined)
-        yield* reportPipeline(`pipeline-${step === "run" ? "report" : "rereport"}:${cycle}`, {
-          changeRequestId,
-          verification
-        });
-      return failed;
-    });
-    return gen(function* () {
-      for (let cycle = 1;; cycle++) {
-        if (cycle > (input.maxCycles ?? 20)) {
-          const goOn = yield* ask(`continue:${cycle}`, {
-            prompt: `Shepherd has looked at this ChangeRequest ${cycle - 1} times without landing it. Keep going?`,
-            options: ["Keep going", "Stop"],
-            recommended: "Stop",
-            recommendationReason: `${cycle - 1} looks have not landed it, so something needs a person rather than another look.`,
-            default: "Stop",
-            timeout: "1 hour"
-          });
-          if (goOn === "Stop")
-            return done("needs_you", `Stopped after ${cycle - 1} looks without landing it`);
-        }
-        const pipeline = yield* pipelineStatus(`pipeline:${cycle}`, { changeRequestId });
-        if (pipeline.status === "none" && pipeline.runnerChecks !== undefined) {
-          if (ranOnRunner.has(pipeline.head))
-            return done("needs_you", `The pipeline ran on the Runner at ${pipeline.head}, but no result was recorded`);
-          ranOnRunner.add(pipeline.head);
-          const failed = yield* runOnRunner("run", cycle, pipeline.head, pipeline.runnerChecks);
-          if (failed !== undefined)
-            return done("needs_you", `The pipeline could not run on the Runner: ${failed}`);
-          continue;
-        }
-        if (pipeline.status === "none" || pipeline.status === "running") {
-          yield* pipelineMoved(`wait:${cycle}`, changeRequestId, pipeline);
-          continue;
-        }
-        if (pipeline.status === "failed" || pipeline.status === "canceled") {
-          if (stalledAt === pipeline.head)
-            stalls++;
-          else
-            stalls = 0;
-          if (stalls >= 2)
-            return done("needs_you", `Two fixes pushed nothing new; the pipeline at ${pipeline.head} still fails`);
-          if (fixRounds >= (input.maxFixRounds ?? 3))
-            return done("needs_you", `The pipeline still fails after ${fixRounds} fix rounds`);
-          fixRounds++;
-          stalledAt = pipeline.head;
-          const fixed = yield* agentWork(`ci-fix:${cycle}`, {
-            agent: "implementer",
-            prompt: ciFixPrompt(pipeline, target),
-            output: CiFix,
-            timeout: stepBudget
-          });
-          if (fixed.verdict === "pre_existing")
-            return done("needs_you", `The failure is pre-existing on the target branch: ${fixed.summary}`);
-          if (fixed.verdict === "flaky") {
-            if (pipeline.source === "reported") {
-              if (pipeline.runnerChecks === undefined)
-                return done("needs_you", `The failing job passed when run again, outside the forge: ${fixed.summary}`);
-              if (reranHeads.has(pipeline.head))
-                return done("needs_you", `The failing job failed again when run again on the Runner: ${fixed.summary}`);
-              reranHeads.add(pipeline.head);
-              const failed = yield* runOnRunner("rerun", cycle, pipeline.head, pipeline.runnerChecks);
-              if (failed !== undefined)
-                return done("needs_you", `The pipeline could not run on the Runner: ${failed}`);
-              continue;
-            }
-            if (reranHeads.has(pipeline.head))
-              return done("needs_you", `The failing job failed again when run again on the forge: ${fixed.summary}`);
-            reranHeads.add(pipeline.head);
-            yield* rerunPipeline(`rerun:${cycle}`, { changeRequestId });
-            yield* pipelineMoved(`rerun-wait:${cycle}`, changeRequestId, pipeline).pipe(catchTag("WaitTimedOut", () => void_3));
-          }
-          continue;
-        }
-        const threads = (yield* reviewThreads(`threads:${cycle}`, { changeRequestId })).threads.filter((thread) => !answered.has(threadKey(thread)));
-        if (threads.length > 0) {
-          const answers = yield* agentWork(`comments:${cycle}`, {
-            agent: "implementer",
-            prompt: repliesPrompt(threads),
-            output: Replies,
-            timeout: stepBudget
-          });
-          for (const answer of answers.replies) {
-            yield* comment(`reply:${cycle}:${answer.threadId}`, {
-              changeRequestId,
-              threadId: answer.threadId,
-              body: answer.reply
-            });
-            replies++;
-          }
-          for (const thread of threads)
-            answered.add(`${thread.id}:${thread.comments.length + 1}`);
-          if (answers.replies.some((answer) => answer.changed))
-            continue;
-        }
-        const commented = {
-          event: "change_request.comment",
-          filter: { changeRequestId },
-          ...pipeline.readAt === undefined ? undefined : { since: pipeline.readAt }
-        };
-        const mergeable = yield* waitFor(`mergeable:${cycle}`, {
-          event: "change_request.mergeable",
-          filter: { changeRequestId },
-          timeout: "1 hour",
-          or: [commented]
-        });
-        if (mergeable.type === commented.event)
-          continue;
-        if (mergeable.payload.mergeable === false) {
-          const synced = yield* syncBase(`sync:${cycle}`, { agent: "implementer", target });
-          if (synced.status === "conflict")
-            return done("needs_you", `Merging ${target} in conflicts on ${synced.files.join(", ")}: ${synced.reason}`);
-          if (synced.status === "merged") {
-            const caught = synced.catchUp;
-            const verdict = caught === undefined ? { kind: "changed", why: "its Runner did not report what it did to the branch" } : catchUpVerdict(caught);
-            if (verdict.kind === "changed") {
-              unreviewed = undefined;
-              notCarried = `merging ${target} in changed it: ${verdict.why}`;
-            } else if (caught !== undefined && unreviewed !== undefined) {
-              const files = [...new Set([...unreviewed.files, ...verdict.kind === "review" ? verdict.files : []])];
-              unreviewed = caught.from === unreviewed.synced ? { ...unreviewed, files, synced: caught.head } : { ...unreviewed, files };
-            } else if (caught !== undefined && verdict.kind === "review") {
-              notCarried = undefined;
-              unreviewed = { files: verdict.files, synced: caught.head, sync: `sync:${cycle}`, earlier: [] };
-            } else if (caught !== undefined) {
-              notCarried = undefined;
-              const carried = yield* approveChangeRequest(`carry:${cycle}`, {
-                changeRequestId,
-                head: caught.head,
-                summary: `Merging ${target} in left the branch's own diff as it was approved.`,
-                carries: `sync:${cycle}`
-              }).pipe(catchTag("StepFailed", (error) => succeed6({ approved: false, reason: error.reason })));
-              if (!carried.approved)
-                notCarried = `the approval was not carried: ${carried.reason}`;
-            }
-          }
-          continue;
-        }
-        let reviewedHere = false;
-        if (unreviewed !== undefined) {
-          const files = unreviewed;
-          const head = pipeline.head;
-          const reviewed = yield* call(`review:${cycle}`, reviewLoop(), {
-            base: `origin/${target}`,
-            head,
-            files: files.files,
-            ...head === files.synced ? undefined : { since: files.synced },
-            ...files.earlier.length === 0 ? undefined : { earlier: files.earlier }
-          });
-          if (reviewed.blocking) {
-            const blocking = reviewed.findings.filter(isBlocking);
-            if (fixRounds >= (input.maxFixRounds ?? 3))
-              return done("needs_you", `The review of the catch-up merge's files still finds ${blocking.map((finding) => finding.id).join(", ")} after ${fixRounds} fix rounds`);
-            fixRounds++;
-            yield* agentWork(`review-fix:${cycle}`, {
-              agent: "implementer",
-              prompt: reviewFixPrompt(blocking),
-              output: ReviewFix,
-              timeout: stepBudget
-            });
-            unreviewed = { ...files, earlier: reviewed.findings };
-            continue;
-          }
-          const approval = yield* approveChangeRequest(`approve:${cycle}`, {
-            changeRequestId,
-            head,
-            summary: `A review of the files merging ${target} in changed (${files.files.join(", ")}) passed with nothing blocking.`,
-            review: `review:${cycle}`,
-            carries: files.sync
-          }).pipe(catchTag("StepFailed", (error) => succeed6({ approved: false, reason: error.reason })));
-          unreviewed = undefined;
-          if (approval.approved)
-            reviewedHere = true;
-          else
-            notCarried = `merging ${target} in, whose files' review passed but did not approve it: ${approval.reason}`;
-        }
-        const moved = pipeline.readAt === undefined ? [] : [
-          { event: "change_request.pipeline", filter: { changeRequestId }, since: pipeline.readAt },
-          ...pipeline.source === "reported" ? [
-            {
-              event: "change_request.approval",
-              filter: { changeRequestId, approved: true },
-              since: pipeline.readAt
-            }
-          ] : []
-        ];
-        const approved = reviewedHere ? undefined : yield* waitFor(`approved:${cycle}`, {
-          event: "change_request.approval",
-          filter: { changeRequestId, approved: true, head: pipeline.head },
-          timeout: "7 days",
-          or: [commented, ...moved]
-        });
-        if (approved !== undefined && approved.type !== "change_request.approval")
-          continue;
-        if (pipeline.source === "reported" && approved !== undefined && approved.payload.head !== pipeline.head)
-          continue;
-        const merge = input.merge === true ? "Merge" : yield* ask(`merge:${cycle}`, {
-          prompt: "The ChangeRequest is approved, green and mergeable. Merge now?",
-          options: [
-            { value: "Merge", description: "Merges the head whose pipeline passed." },
-            { value: "Wait", description: "Leaves the merge to a person." }
-          ],
-          recommended: "Merge",
-          recommendationReason: "It is approved, green and mergeable, which is everything a merge waits for.",
-          default: "Wait",
-          timeout: "1 hour"
-        });
-        if (merge === "Wait")
-          return done("ready", "Approved, green and mergeable; left for a person to merge");
-        const merged = yield* mergeChangeRequest(`merge-change-request:${cycle}`, {
-          changeRequestId,
-          head: pipeline.head
-        });
-        if (merged.status !== "merged")
-          continue;
-        yield* writeBack("write-back", { milestone: "merged" });
-        return done("merged", `Merged at ${merged.revision}`);
-      }
-    }).pipe(catchIf((error) => error._tag === "StepFailed" && error.reason.includes("time budget"), (error) => succeed6(done("needs_you", `Step "${error.step}" ran past its ${stepBudget} budget`))), catchTags({
-      WaitTimedOut: (timedOut) => succeed6(done("needs_you", timedOut.event === "change_request.approval" && notCarried !== undefined ? `Nobody approved the head after ${notCarried}` : `Nothing happened on the ChangeRequest while waiting for ${timedOut.event}`)),
-      ChangeRequestClosed: (ended) => succeed6(ended.merged ? done("merged", "Someone else merged the ChangeRequest") : done("needs_you", "The ChangeRequest was closed"))
-    }));
-  }
-});
-
-// packages/loops/src/build.ts
-var BuildInput = Struct({
-  words: optional(String4),
-  taskId: optional(String4),
-  repoBindingId: optional(String4),
-  branch: optional(String4),
-  revision: optional(String4),
-  outcome: optional(LoopOutcome),
-  maxRounds: optional(Int),
-  continuing: optional(Continuing),
-  land: optional(Boolean2),
-  changeRequestId: optional(String4)
-});
-var CriterionAnswer = Struct({
-  criterion: String4,
-  status: Literals(["met", "after_merge", "not_met"]),
-  detail: String4
-});
-var Criteria = Struct({ criteria: ArraySchema(CriterionAnswer) });
-var SuggestedCheck = Struct({
-  name: CheckName,
-  command: String4,
-  workingDirectory: optionalKey(String4)
-});
-var Implemented = Struct({
-  title: String4,
-  summary: String4,
-  claims: ArraySchema(String4),
-  documented: optional(ArraySchema(String4)),
-  rollback: optional(String4),
-  criteria: optional(ArraySchema(CriterionAnswer)),
-  checks: optional(ArraySchema(SuggestedCheck))
-});
-var Reproduced = Struct({
-  check: String4,
-  summary: String4
-});
-var ReproducedOnBranch = Struct({
-  ...Reproduced.fields,
-  revision: optional(String4)
-});
-var Fixed = Struct({
-  summary: String4,
-  claims: ArraySchema(String4),
-  rebuttals: ArraySchema(Rebuttal)
-});
-var BuildOutput = Struct({
-  changeRequest: ChangeRequestResult,
-  revision: String4,
-  tree: String4,
-  settled: Boolean2,
-  unsettled: ArraySchema(String4),
-  rounds: Int,
-  stopped: Literals(["settled", "dispute_stands", "findings_returned", "round_cap"]),
-  criteria: ArraySchema(CriterionAnswer),
-  approval: optional(ApproveChangeRequestResult),
-  landed: optional(ShepherdOutput),
-  next: Struct({ changeRequestId: String4 })
-});
-
-class BuildTargetMissing extends TaggedError2()("BuildTargetMissing", {
-  message: String4
-}) {
-}
-var outcomeGuidance = {
-  feature: "Deliver the whole scope; review checks it was met.",
-  bug: "Your failing test is already in place: make it pass.",
-  refactor: "Keep behaviour exactly as it is; the approved verifications must pass before and after.",
-  investigation: "Investigate and report what you found, with its sources.",
-  docs: "Name, in `documented`, the approved checks that run the commands you documented.",
-  migration: "Name, in `rollback`, the approved check that rolls the migration back.",
-  performance: "Make it faster without changing behaviour."
-};
-
-class BuildOutcomeRefused extends TaggedError2()("BuildOutcomeRefused", {
-  message: String4
-}) {
-}
-var criteriaGuidance = "If your brief has a Task, answer each of its acceptance criteria in `criteria`: met, with the test or file that shows it; after_merge, with why it can only be seen once merged; or not_met, with why. Give an empty `criteria` when the Task has none.";
-var checksGuidance = "If your brief lists no approved verifications for this repository, name in `checks` the commands from its package scripts or CI config that test, lint and typecheck it, each with a `name` of letters, digits, `.`, `_`, `:` and `-` only, such as `unit-tests`; Kitman runs them and labels them as suggested by you.";
-var implementAdaptation = "You run the implement skill as a Kitman Step. The work is in this prompt and your brief, so fetch no ticket. Leave your changes uncommitted: the Run owns the branch. Skip its final code-review: a Review run or a person reviews the change.";
-var implementPrompt = (task, outcome, continuing) => [
-  ...continuing === undefined ? [] : [continuingBrief(continuing), "Fix forward from there."],
-  `Build ${task}`,
-  implementAdaptation,
-  ...outcome === undefined ? [] : [outcomeGuidance[outcome]],
-  'Commit nothing yourself: Kitman pushes what you leave in the workspace. Give the ChangeRequest a title and a summary, and list as claims what you believe but Kitman has not checked, such as "the tests pass".',
-  criteriaGuidance,
-  checksGuidance
-].join(`
-
-`);
-var criteriaPrompt = (unanswered, unmet) => [
-  unanswered ? "You did not answer the Task's acceptance criteria. Answer each one before anyone reviews the change." : "These acceptance criteria are not met yet. Meet them, or say why they cannot be met here:",
-  ...unmet.map((answer) => `- ${answer.criterion}: ${answer.detail}`),
-  criteriaGuidance
-].join(`
-
-`);
-var answerLine = (answer) => `${answer.criterion}: ${answer.status.replaceAll("_", " ")}, ${answer.detail}`;
-var reproducePrompt = (task) => [
-  `Reproduce the bug in ${task} before anyone fixes it.`,
-  "Add a test that fails because of the bug, and change nothing else. Name the approved check that runs it; it must fail now and pass once the bug is fixed."
-].join(`
-
-`);
-var reproducedOnBranchPrompt = (task) => [
-  `An earlier Run already worked on fixing the bug in ${task}, on this branch.`,
-  "Find the commit on this branch where the test reproducing the bug was in place and the fix was not yet, and give it as `revision`; name the approved check that runs that test. Change nothing.",
-  "If no commit on the branch has the reproducing test without the fix, add a test that fails on the branch head now, change nothing else, and give no `revision`."
-].join(`
-
-`);
-var findingLine = (finding) => `- **${finding.severity}** \`${finding.id}\` ${finding.detail}`;
-var disputeLine = ({ finding, rebuttal }) => `${findingLine(finding)}
-  You rebutted: ${rebuttal.reason}`;
-var fixPrompt = (settled) => {
-  const checks = settled.open.filter((finding) => isCheckFinding(finding.id));
-  const findings = settled.open.filter((finding) => !isCheckFinding(finding.id));
-  return [
-    ...checks.length === 0 ? [] : [
-      "These checks fail on your head and pass on the base. Only the check passing closes one. If you are sure the change did not cause it, such as a flaky test, rebut it with your reason: the ChangeRequest reports that as your claim and the check stays open. A check does not run again on an unchanged tree, so if you change nothing and only these are open, the rally ends.",
-      ...checks.map(findingLine)
-    ],
-    ...findings.length === 0 ? [] : [
-      "The review found these. Fix each, or rebut it with your reason if it is wrong; reviewers judge the rebuttals next round.",
-      ...findings.map(findingLine)
-    ],
-    ...settled.standing.length === 0 ? [] : [
-      "The reviewers rejected your rebuttal of these. Fix each, or rebut it again with a better reason; one you leave stays a dispute for a person to settle.",
-      ...settled.standing.map(disputeLine)
-    ]
-  ].join(`
-`);
-};
-var blockingIds = (settled) => settled.open.filter(isBlocking).map((finding) => finding.id);
-var onlyChecksBlock = (settled) => blockingIds(settled).every(isCheckFinding) && !settled.standing.some((entry) => isBlocking(entry.finding));
-var rally = (input) => gen(function* () {
-  const claims = [...input.claims];
-  const conflicts = [];
-  let rebuttals = [];
-  let earlier = [];
-  let previous;
-  let last;
-  const shown = new Set;
-  for (let round = 1;; round++) {
-    const synced = yield* syncBase(`sync:${round}`, {
-      agent: "implementer",
-      ...input.target === undefined ? undefined : { target: input.target }
-    });
-    if (synced.status === "conflict")
-      conflicts.push(`Could not merge the target branch in round ${round}: ${synced.files.join(", ")} (${synced.reason})`);
-    const head = yield* verify(`verify:${round}`, { suggested: input.suggested });
-    if (last !== undefined && last.head.tree === head.tree && rebuttals.length === 0 && onlyChecksBlock(last.settled))
-      return {
-        ...last,
-        round: round - 1,
-        head,
-        decision: { stop: true, reason: "findings_returned", unsettled: blockingIds(last.settled) },
-        claims,
-        conflicts
-      };
-    const failing = brokenChecks(head).map((check) => check.name);
-    const reviewed = yield* call(`review:${round}`, review_default, {
-      base: input.base,
-      head: head.revision,
-      ...rebuttals.length === 0 ? undefined : { rebuttals },
-      ...earlier.length === 0 ? undefined : { earlier },
-      ...input.outcome === undefined ? undefined : { outcome: input.outcome },
-      ...failing.length === 0 ? undefined : { failing },
-      claims: [...claims]
-    });
-    const checks = checkFindings(head);
-    const settled = settleRound({
-      findings: [...reviewed.findings, ...scopeFindings(reviewed.scope), ...checks],
-      rebuttals,
-      verdicts: reviewed.verdicts
-    });
-    earlier = [...settled.open, ...settled.standing.map((entry) => entry.finding)].filter((finding) => !finding.id.startsWith("scope: ") && !isCheckFinding(finding.id));
-    const unseen = checks.some((finding) => !shown.has(finding.detail));
-    const decision = rallyStop({
-      round,
-      maxRounds: input.maxRounds,
-      settled,
-      ...previous === undefined || unseen ? undefined : { previous }
-    });
-    if (decision.stop && (!unseen || round >= input.maxRounds))
-      return { round, head, settled, decision, claims, scope: reviewed.scope, conflicts };
-    for (const finding of checks)
-      shown.add(finding.detail);
-    const fixed = yield* agentWork(`fix:${round}`, {
-      agent: "implementer",
-      prompt: fixPrompt(settled),
-      output: Fixed
-    });
-    claims.push(...fixed.claims, ...fixed.rebuttals.flatMap((rebuttal) => isCheckFinding(rebuttal.findingId) ? [`Rebutted ${rebuttal.findingId}: ${rebuttal.reason}`] : []));
-    const rebutted = fixed.rebuttals.filter((rebuttal) => !isCheckFinding(rebuttal.findingId));
-    rebuttals = [
-      ...rebutted,
-      ...settled.standing.filter((entry) => isBlocking(entry.finding)).map((entry) => entry.rebuttal).filter((rebuttal) => !rebutted.some((entry) => entry.findingId === rebuttal.findingId))
-    ];
-    previous = blockingIds(settled);
-    last = { head, settled, scope: reviewed.scope };
-  }
-});
-var build_default = defineLoop({
-  id: "build",
-  version: "2.2.0",
-  title: "Build",
-  input: BuildInput,
-  output: BuildOutput,
-  agents: { implementer: "implementer" },
-  checkout: "write",
-  offers: [
-    { id: "shepherd", title: "Shepherd it to merge", loop: "shepherd", from: "next" },
-    { id: "review", title: "Review again", loop: "review", from: "next" },
-    { id: "tidy", title: "Tidy", loop: "tidy" },
-    { id: "retry", title: "Retry with a steer", loop: "build" }
-  ],
-  capabilities: ["agent_work", "verify", "change_request", "write_back", "post_comment", "approve_change_request"],
-  calls: () => [review_default, shepherd_default],
-  run: (input) => gen(function* () {
-    if (input.words === undefined && input.taskId === undefined)
-      return yield* new BuildTargetMissing({ message: "Give the words to build, or a Task" });
-    if (input.outcome === "performance")
-      return yield* new BuildOutcomeRefused({
-        message: "Build cannot prove a performance gain; start Hillclimb, which commits a benchmark and keeps only the changes Kitman measures faster"
-      });
-    yield* writeBack("write-back:started", { milestone: "started" });
-    const task = input.words === undefined ? "the Task your brief describes." : `this: ${input.words}`;
-    const outcome = input.outcome;
-    const target = input.branch ?? input.continuing?.targetBranch;
-    if (input.changeRequestId !== undefined && input.continuing?.changeRequestId !== input.changeRequestId)
-      return yield* new BuildTargetMissing({
-        message: `Kitman did not put this Run on ChangeRequest ${input.changeRequestId}'s branch`
-      });
-    const reproduced = outcome === "bug" ? yield* agentWork("reproduce", {
-      agent: "implementer",
-      prompt: input.continuing === undefined ? reproducePrompt(task) : reproducedOnBranchPrompt(task),
-      output: ReproducedOnBranch
-    }) : undefined;
-    const base = reproduced !== undefined ? yield* verify("verify:reproduction", reproduced.revision === undefined ? {} : { revision: reproduced.revision }) : outcome === "refactor" ? yield* verify("verify:base", {}) : undefined;
-    const implemented = yield* agentWorkOnce("implement", {
-      agent: "implementer",
-      skill: "implement",
-      prompt: implementPrompt(task, outcome, input.continuing),
-      output: Implemented
-    });
-    const unanswered = input.taskId !== undefined && implemented.criteria === undefined;
-    const unmet = (implemented.criteria ?? []).filter((answer) => answer.status === "not_met");
-    const criteria = unanswered || unmet.length > 0 ? (yield* agentWorkOnce("criteria", {
-      agent: "implementer",
-      prompt: criteriaPrompt(unanswered, unmet),
-      output: Criteria
-    })).criteria : implemented.criteria ?? [];
-    const last = yield* rally({
-      maxRounds: input.maxRounds ?? 3,
-      base: `origin/${target ?? "HEAD"}`,
-      target,
-      outcome,
-      claims: [...implemented.claims, ...criteria.map((answer) => `Criterion ${answerLine(answer)}`)],
-      suggested: implemented.checks ?? []
-    });
-    const verdict = evidenceGate({
-      ...outcome === undefined ? undefined : { outcome },
-      head: last.head,
-      ...base === undefined ? undefined : { base },
-      ...last.scope === undefined ? undefined : { review: last.scope },
-      ...reproduced === undefined ? undefined : { reproducing: reproduced.check },
-      ...implemented.documented === undefined ? undefined : { documented: implemented.documented },
-      ...implemented.rollback === undefined ? undefined : { rollback: implemented.rollback }
-    });
-    const unsettled = [
-      ...new Set([
-        ...verdict.settled ? [] : verdict.reasons,
-        ...brokenChecks(last.head).map((check) => failsOn("head", check.name, last.head.tree)),
-        ...unsettledItems(last.settled, last.decision),
-        ...last.conflicts,
-        ...criteria.flatMap((answer) => answer.status === "not_met" ? [`Criterion not met: ${answer.criterion} (${answer.detail})`] : [])
-      ])
-    ];
-    const body = changeRequestBody({
-      summary: implemented.summary,
-      head: last.head,
-      claims: last.claims,
-      unsettled,
-      criteria: criteria.map(answerLine),
-      later: last.settled.open.filter((finding) => !isBlocking(finding)).map((finding) => `${finding.id}: ${finding.detail}`),
-      rounds: last.round,
-      stopped: last.decision.reason
-    });
-    const named = input.changeRequestId === undefined ? undefined : input.continuing;
-    const opened = named === undefined ? yield* changeRequest("change-request", { title: implemented.title, body }) : yield* comment("report", { changeRequestId: named.changeRequestId, body, summary: "kitman-build" }).pipe(as({ id: named.changeRequestId, number: named.number, url: named.url }));
-    if (named === undefined)
-      yield* writeBack("write-back", { milestone: "change_request_opened", changeRequestUrl: opened.url });
-    const approval = unsettled.length === 0 ? yield* approveChangeRequest("approve", {
-      changeRequestId: opened.id,
-      head: last.head.revision,
-      summary: `Review round ${last.round} passed with nothing blocking.`,
-      review: `review:${last.round}`
-    }).pipe(catchTag("StepFailed", (error) => succeed6({ approved: false, reason: error.reason }))) : undefined;
-    const landed = input.land === true ? yield* call("land", shepherd_default, {
-      changeRequestId: opened.id,
-      ...input.taskId === undefined ? undefined : { taskId: input.taskId },
-      ...input.branch === undefined ? undefined : { branch: input.branch }
-    }) : undefined;
-    return {
-      changeRequest: opened,
-      revision: last.head.revision,
-      tree: last.head.tree,
-      settled: unsettled.length === 0,
-      unsettled,
-      rounds: last.round,
-      stopped: last.decision.reason,
-      criteria,
-      ...approval === undefined ? undefined : { approval },
-      ...landed === undefined ? undefined : { landed },
-      next: { changeRequestId: opened.id }
-    };
-  }).pipe(tapError2(() => ignore(writeBack("write-back:failed", { milestone: "failed" }))))
-});
-
-// packages/loops/src/errand.ts
-var Input3 = Struct({
-  words: String4,
-  taskId: optional(String4),
-  repoBindingId: optional(String4),
-  branch: optional(String4)
-});
-var Done = Struct({
-  status: Literals(["done", "blocked", "too_big"]),
-  summary: String4,
-  changed: Boolean2,
-  title: optional(String4),
-  checks: optional(ArraySchema(SuggestedCheck))
-});
-var budget = "1 hour";
-var Output3 = Struct({
-  status: Literals(["done", "blocked", "too_big", "opened", "handed_to_build", "discarded"]),
-  summary: String4,
-  changeRequest: optional(ChangeRequestResult)
-});
-var prompt = (words) => [
-  `Just do this: ${words}`,
-  implementAdaptation,
-  "It is an errand: a rename, a bump, regenerated fixtures, an answer to a question. Do it directly, run the tests of what you touch, and commit nothing you were not asked for.",
-  "If it turns out to be a feature (several parts, design choices, or more than an hour of work), change nothing and answer too_big with why: a Build will do it with a full review. If something stops you, answer blocked with what.",
-  "Answer with a summary for the person who asked, whether you changed files, a ChangeRequest title if you did, and checks to run if the repository has none approved."
-].join(`
-
-`);
-var errand_default = defineLoop({
-  id: "errand",
-  version: "1.0.0",
-  title: "Errand",
-  input: Input3,
-  output: Output3,
-  agents: { implementer: "implementer" },
-  checkout: "write",
-  offers: [{ id: "build", title: "Build it with a full review", loop: "build" }],
-  capabilities: ["agent_work", "verify", "change_request", "write_back", "ask"],
-  calls: () => [build_default],
-  run: (input) => gen(function* () {
-    const done = yield* agentWorkOnce("errand", {
-      agent: "implementer",
-      skill: "implement",
-      prompt: prompt(input.words),
-      output: Done,
-      timeout: budget
-    }).pipe(catchIf((error) => error._tag === "StepFailed" && error.reason.includes("time budget"), () => succeed6({
-      status: "too_big",
-      summary: `It took longer than an errand's ${budget}, so it is a feature: Build can do it with a full review.`,
-      changed: false
-    })));
-    if (done.status !== "done" || !done.changed)
-      return { status: done.status, summary: done.summary };
-    const head = yield* verify("verify", { suggested: done.checks ?? [] });
-    const answer = yield* ask("next", {
-      prompt: `${done.summary}
-
-The checks ${head.passed ? "pass" : "fail"}. What next?`,
-      options: [
-        { value: "Open a ChangeRequest", description: "Deliver it as it is, unreviewed." },
-        { value: "Hand to Build for a full review", description: "Build reviews and verifies it before delivering." },
-        { value: "Discard", description: "Drop the change." }
-      ],
-      recommended: head.passed ? "Open a ChangeRequest" : "Hand to Build for a full review",
-      recommendationReason: head.passed ? "The checks pass, and an errand is small enough to review on the ChangeRequest." : "The checks fail, so it needs the fixes and review a Build gives before anyone merges it.",
-      default: "Open a ChangeRequest",
-      timeout: "1 hour"
-    });
-    if (answer === "Discard")
-      return { status: "discarded", summary: done.summary };
-    if (answer === "Hand to Build for a full review") {
-      const built = yield* call("build", build_default, {
-        words: input.words,
-        revision: head.revision,
-        ...input.taskId === undefined ? undefined : { taskId: input.taskId },
-        ...input.branch === undefined ? undefined : { branch: input.branch }
-      });
-      return { status: "handed_to_build", summary: done.summary, changeRequest: built.changeRequest };
-    }
-    const opened = yield* changeRequest("change-request", {
-      title: done.title ?? input.words.slice(0, 120),
-      body: [
-        done.summary,
-        "> **Unreviewed errand.** One agent did this with no review; ask for a Build or a Review if it needs one.",
-        "## Evidence",
-        evidenceTable(head)
-      ].join(`
-
-`)
-    });
-    yield* writeBack("write-back", { milestone: "change_request_opened", changeRequestUrl: opened.url });
-    return { status: "opened", summary: done.summary, changeRequest: opened };
-  })
-});
-
-// packages/loops/src/file-tasks.ts
-var FileTasksInput = Struct({
-  tickets: PlanTickets,
-  projectId: optional(String4)
-});
-var Output4 = Struct({
-  tasks: ArraySchema(Struct({ key: String4, taskId: String4 }))
-});
-var file_tasks_default = defineLoop({
-  id: "file-tasks",
-  version: "1.0.0",
-  title: "File Tasks",
-  input: FileTasksInput,
-  output: Output4,
-  agents: {},
-  checkout: "none",
-  capabilities: ["create_tasks"],
-  run: (input) => createTasks("tasks", {
-    tickets: input.tickets,
-    ...input.projectId === undefined ? undefined : { projectId: input.projectId }
-  }).pipe(map8(({ tasks }) => ({ tasks })))
-});
-
-// packages/loops/src/hillclimb.ts
-var Input4 = Struct({
-  focus: optional(String4),
-  taskId: optional(String4),
-  repoBindingId: optional(String4),
-  branch: optional(String4),
-  cycles: optional(Int),
-  threshold: optional(Finite),
-  tolerance: optional(Finite)
-});
-var Opportunity = Struct({
-  title: String4,
-  detail: String4,
-  evidence: Literals(["measured", "telemetry", "hypothesis"]),
-  external: optional(Boolean2)
-});
-var Discovery = Struct({
-  stack: String4,
-  journeys: ArraySchema(Struct({ name: String4, objective: String4 })),
-  telemetry: ArraySchema(Struct({ source: String4, status: Literals(["used", "unavailable"]), why: String4 })),
-  opportunities: ArraySchema(Opportunity)
-});
-var Harness = Struct({
-  summary: String4,
-  plan: MeasurePlan
-});
-var Change = Struct({
-  status: Literals(["changed", "exhausted", "unsafe"]),
-  summary: String4
-});
-var Kept = Struct({ summary: String4, verdict: String4, reason: String4 });
-var Output5 = Struct({
-  status: Literals(["improved", "no_gain", "gain_gone", "checks_failed", "too_noisy"]),
-  reason: String4,
-  kept: ArraySchema(Kept),
-  cycles: Int,
-  reportArtifactId: String4,
-  changeRequest: optional(ChangeRequestResult),
-  external: ArraySchema(String4),
-  unsettled: optional(ArraySchema(String4))
-});
-var discoverPrompt = (focus) => [
-  `Find where this repository is slow${focus === undefined ? ", for the journeys that matter most" : `: ${focus}`}. Change nothing.`,
-  "Read the stack, the user journeys and the objective each has, the docs and earlier performance work. Read whatever telemetry you can reach, read-only and with bounded queries; list each source as used or unavailable, with why.",
-  "Rank the opportunities, most promising first, each marked measured, telemetry or hypothesis. Mark one that only another repository can make as external."
-].join(`
-
-`);
-var harnessPrompt = (discovery) => [
-  "Commit a local benchmark for these journeys, and change no product code:",
-  ...discovery.journeys.map((journey) => `- ${journey.name}: ${journey.objective}`),
-  "It runs on this Runner alone: never call a service, database or URL outside it. Each run prints one JSON line of numbers by metric name as its last line; wall time is measured for you as wall_ms. Keep it under a minute a run.",
-  "Give the measurement plan: the command, any prepare command, and the metrics with one primary and the rest guardrails. Add a low-variance counter (instructions, allocations, queries) where you can, marked lowVariance."
-].join(`
-
-`);
-var changePrompt = (discovery, plan, tried, cycle) => [
-  `Cycle ${cycle}: make one bounded change that should improve ${plan.metrics.find((metric) => metric.role === "primary")?.name ?? "the primary metric"} without making a guardrail worse, and commit it. Kitman measures it; do not report numbers of your own.`,
-  "Opportunities, most promising first:",
-  ...discovery.opportunities.flatMap((entry) => entry.external === true ? [] : [`- ${entry.title} (${entry.evidence}): ${entry.detail}`]),
-  ...tried.length === 0 ? [] : ["Already tried:", ...tried.map((entry) => `- ${entry}`)],
-  "Keep behaviour exactly as it is and run the tests you touch. Answer exhausted when nothing is left worth trying, or unsafe when the gain would cost correctness; either way change nothing."
-].join(`
-
-`);
-var revertPrompt = (start, cycle) => `Cycle ${cycle}'s change did not prove faster. Revert its commits, and only those: run \`git revert --no-edit ${start}..HEAD\`. Touch no commit at or before ${start}, never reset or force-push, and change nothing else.`;
-var fixPrompt2 = (findings) => [
-  "The review of the climb found these. Fix each, keep behaviour exactly as it is and keep the gain, and commit. Kitman verifies and measures again; a fix that costs the gain ends the climb.",
-  ...findings.map((finding) => `- ${finding.id}: ${finding.detail}`)
-].join(`
-
-`);
-var percent = (fraction) => `${(fraction * 100).toFixed(1)}%`;
-var numbers = (measured) => [
-  "| Metric | Role | Base median | Head median | Change | Noise |",
-  "|---|---|---|---|---|---|",
-  ...measured.metrics.map((metric) => `| ${metric.name} | ${metric.role} | ${metric.base.median} | ${metric.head.median} | ${percent(metric.change)} | ${percent(metric.noise)} |`)
-].join(`
-`);
-var report = (input) => [
-  `# Hillclimb findings
-
-${input.reason}`,
-  `## Stack
-
-${input.discovery.stack}`,
-  `## Telemetry
-
-${input.discovery.telemetry.map((entry) => `- ${entry.source}: ${entry.status}, ${entry.why}`).join(`
-`) || "- None reached"}`,
-  `## Benchmark
-
-${input.harness.summary}`,
-  `## Tried
-
-${input.tried.map((entry) => `- ${entry}`).join(`
-`) || "- Nothing"}`,
-  ...input.kept.length === 0 ? [] : [`## Kept
-
-${input.kept.map((entry) => `- ${entry.summary}: ${entry.reason}`).join(`
-`)}`],
-  ...input.final === undefined ? [] : [`## Final measurement
-
-${input.final.reason}
-
-${numbers(input.final)}`],
-  `## Opportunities
-
-${input.discovery.opportunities.map((entry) => `- ${entry.title} (${entry.evidence}${entry.external === true ? ", external" : ""}): ${entry.detail}`).join(`
-`)}`
-].join(`
-
-`);
-var steadier = (plan) => {
-  const counter = plan.metrics.find((metric) => metric.lowVariance === true && metric.role !== "primary");
-  return counter === undefined ? undefined : {
-    ...plan,
-    metrics: plan.metrics.map((metric) => ({
-      ...metric,
-      role: metric.name === counter.name ? "primary" : "guardrail"
-    }))
-  };
-};
-var hillclimb_default = defineLoop({
-  id: "hillclimb",
-  version: "1.3.0",
-  title: "Hillclimb",
-  outcome: "performance",
-  input: Input4,
-  output: Output5,
-  agents: { investigator: "climber", implementer: "implementer" },
-  checkout: "write",
-  capabilities: ["agent_work", "verify", "measure", "change_request", "write_back", "ask", "create_tasks"],
-  calls: () => [review_default],
-  offers: [{ id: "retry", title: "Climb again", loop: "hillclimb" }],
-  run: (input) => gen(function* () {
-    const limits = {
-      ...input.threshold === undefined ? undefined : { threshold: input.threshold },
-      ...input.tolerance === undefined ? undefined : { tolerance: input.tolerance }
-    };
-    const discovery = yield* agentWork("discover", {
-      agent: "investigator",
-      prompt: discoverPrompt(input.focus),
-      output: Discovery
-    });
-    const external = discovery.opportunities.flatMap((entry) => entry.external === true ? [entry.title] : []);
-    yield* syncBase("sync:start", {
-      agent: "implementer",
-      ...input.branch === undefined ? undefined : { target: input.branch }
-    });
-    const harness = yield* agentWorkOnce("harness", {
-      agent: "implementer",
-      prompt: harnessPrompt(discovery),
-      output: Harness
-    });
-    const baseline = (yield* verify("verify:harness", {})).revision;
-    let plan = harness.plan;
-    const calibrated = yield* measure("calibrate", { plan, base: baseline, head: baseline, ...limits });
-    const kept = [];
-    const tried = [];
-    let cycles = 0;
-    const ending = (status, reason, final) => gen(function* () {
-      const stored = yield* artifact("report", {
-        kind: "hillclimb-report",
-        title: "Hillclimb findings",
-        text: report({ discovery, harness, reason, kept, tried, final })
-      });
-      return { status, reason, kept, cycles, reportArtifactId: stored.artifactId, external };
-    });
-    if (calibrated.verdict === "too_noisy") {
-      const switched = steadier(plan);
-      if (switched === undefined)
-        return yield* ending("too_noisy", `${calibrated.reason}. ${calibrated.suggestion ?? ""}`.trim());
-      plan = switched;
-    }
-    let start = baseline;
-    let unkept = 0;
-    for (let cycle = 1;cycle <= (input.cycles ?? 5) && unkept < 2; cycle++) {
-      const change = yield* agentWorkOnce(`change:${cycle}`, {
-        agent: "implementer",
-        prompt: changePrompt(discovery, plan, tried, cycle),
-        output: Change
-      });
-      if (change.status !== "changed") {
-        tried.push(`Cycle ${cycle}: ${change.status}, ${change.summary}`);
-        break;
-      }
-      cycles = cycle;
-      const head = yield* verify(`verify:${cycle}`, {});
-      const measured = head.passed ? yield* measure(`measure:${cycle}`, { plan, base: start, head: head.revision, ...limits }) : undefined;
-      if (measured?.verdict === "gain") {
-        kept.push({ summary: change.summary, verdict: measured.verdict, reason: measured.reason });
-        tried.push(`Cycle ${cycle}, kept: ${change.summary} (${measured.reason})`);
-        start = head.revision;
-        unkept = 0;
-        continue;
-      }
-      tried.push(`Cycle ${cycle}, reverted: ${change.summary} (${measured === undefined ? "its checks failed" : measured.reason})`);
-      yield* agentWork(`revert:${cycle}`, {
-        agent: "implementer",
-        prompt: revertPrompt(start, cycle),
-        output: Struct({ reverted: Boolean2 })
-      });
-      unkept++;
-    }
-    if (external.length > 0) {
-      const file = yield* ask("external", {
-        prompt: `Only other repositories can make these improvements: ${external.join("; ")}. File them as Tasks?`,
-        options: ["File as Tasks", "Leave them"],
-        recommended: "File as Tasks",
-        recommendationReason: "Filed as Tasks, the improvements wait in the repositories that can make them instead of being lost.",
-        default: "Leave them",
-        timeout: "1 hour"
-      });
-      if (file === "File as Tasks")
-        yield* createTasks("external-tasks", {
-          tickets: discovery.opportunities.flatMap((entry, index) => entry.external === true ? [
-            {
-              key: `external-${index + 1}`,
-              title: entry.title,
-              body: entry.detail,
-              acceptanceCriteria: [],
-              blockedBy: [],
-              outcome: "performance"
-            }
-          ] : [])
-        });
-    }
-    if (kept.length === 0)
-      return yield* ending("no_gain", "No change proved faster than the noise allows");
-    const synced = yield* syncBase("sync:final", {
-      agent: "implementer",
-      ...input.branch === undefined ? undefined : { target: input.branch }
-    });
-    const checked = yield* verify("verify:final", {});
-    if (!checked.passed) {
-      const failing = checked.checks.filter((check) => check.status === "failed").map((check) => check.name);
-      return yield* ending("checks_failed", `The final tree fails ${failing.join(", ") || "its checks"}`);
-    }
-    let final = yield* measure("measure:final", { plan, base: baseline, head: checked.revision, ...limits });
-    if (final.verdict !== "gain")
-      return yield* ending("gain_gone", `The final tree no longer proves the gain: ${final.reason}`, final);
-    const claims = [
-      "Behaviour is preserved: every kept change leaves what the code does exactly as it was.",
-      `The measurement is valid: ${harness.summary}`,
-      ...kept.map((entry) => entry.summary)
-    ];
-    let reviewed = yield* call("review", review_default, {
-      base: baseline,
-      head: checked.revision,
-      outcome: "performance",
-      claims
-    });
-    for (let round = 1;round <= 2 && reviewed.findings.some(isBlocking); round++) {
-      const blocking = reviewed.findings.filter(isBlocking);
-      yield* agentWork(`fix:${round}`, {
-        agent: "implementer",
-        prompt: fixPrompt2(blocking),
-        output: Struct({ summary: String4 })
-      });
-      const fixed = yield* verify(`verify:fix:${round}`, {});
-      if (!fixed.passed) {
-        const failing = fixed.checks.filter((check) => check.status === "failed").map((check) => check.name);
-        return yield* ending("checks_failed", `The review's fixes fail ${failing.join(", ") || "the checks"}`);
-      }
-      final = yield* measure(`measure:fix:${round}`, { plan, base: baseline, head: fixed.revision, ...limits });
-      if (final.verdict !== "gain")
-        return yield* ending("gain_gone", `The review's fixes cost the gain: ${final.reason}`, final);
-      reviewed = yield* call(`review:${round + 1}`, review_default, {
-        base: baseline,
-        head: fixed.revision,
-        outcome: "performance",
-        claims,
-        earlier: blocking
-      });
-    }
-    const unsettled = [
-      ...[...reviewed.findings, ...scopeFindings(reviewed.scope)].flatMap((finding) => isBlocking(finding) ? [`${finding.id}: ${finding.detail}`] : []),
-      ...synced.status === "conflict" ? [`Merging the base in conflicts on ${synced.files.join(", ")}`] : []
-    ];
-    const caveats = synced.status === "merged" ? ["The base moved during the climb; the final measurement includes its changes too."] : [];
-    const opened = yield* changeRequest("change-request", {
-      title: `Faster: ${kept.map((entry) => entry.summary).join("; ")}`.slice(0, 240),
-      body: [
-        `${final.reason}, measured by Kitman against the benchmark on the base.`,
-        numbers(final),
-        `## Kept
-
-${kept.map((entry) => `- ${entry.summary}: ${entry.reason}`).join(`
-`)}`,
-        `## Benchmark
-
-${harness.summary}
-
-\`${plan.command}\``,
-        ...unsettled.length + caveats.length === 0 ? [] : [`## Unsettled
-
-${[...unsettled, ...caveats].map((entry) => `- ${entry}`).join(`
-`)}`]
-      ].join(`
-
-`)
-    });
-    yield* writeBack("write-back", { milestone: "change_request_opened", changeRequestUrl: opened.url });
-    return { ...yield* ending("improved", final.reason, final), changeRequest: opened, unsettled };
-  })
-});
-
-// packages/loops/src/firewatch.ts
-var Input5 = Struct({
-  alert: Record(String4, Json),
-  repoBindingId: optional(String4),
-  windowHours: optional(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(720))),
-  autoFix: optional(Boolean2)
-});
-var Conclusion = Struct({
-  summary: String4,
-  cause: String4,
-  confidence: Literals(["high", "medium", "low"]),
-  sources: NonEmptyArray(String4),
-  telemetry: ArraySchema(Struct({ source: String4, reached: Boolean2, tried: optional(String4) })),
-  inCode: Boolean2,
-  fix: optional(String4)
-});
-var FixRequest = Struct({ words: String4, outcome: Literal("bug") });
-var Output6 = Struct({
-  status: Literals(["folded", "resolved", "concluded"]),
-  taskId: optional(String4),
-  joinedRunId: optional(String4),
-  conclusionArtifactId: optional(String4),
-  resolvedDuring: Boolean2,
-  fix: Literals(["none", "declined", "started", "failed"]),
-  changeRequestUrl: optional(String4),
-  fixRequest: optional(FixRequest)
-});
-var firstText = (alert, ...keys) => keys.flatMap((key) => {
-  const value = alert[key];
-  return isString2(value) && value.trim() !== "" ? [value] : [];
-})[0];
-var alertTitle = (alert) => firstText(alert, "title", "name", "summary") ?? "Alert";
-var fingerprintOf = (alert) => firstText(alert, "fingerprint", "groupKey") ?? alertTitle(alert);
-var isResolved = (alert) => firstText(alert, "status", "state")?.toLowerCase() === "resolved";
-var priorities = new Map(Object.entries({
-  critical: "urgent",
-  p1: "urgent",
-  urgent: "urgent",
-  high: "high",
-  error: "high",
-  p2: "high",
-  warning: "medium",
-  medium: "medium",
-  p3: "medium",
-  low: "low",
-  info: "low",
-  p4: "low"
-}));
-var priorityOf = (alert) => {
-  const severity = firstText(alert, "severity", "priority", "level")?.toLowerCase();
-  return (severity === undefined ? undefined : priorities.get(severity)) ?? "high";
-};
-var investigatePrompt = (alert) => [
-  "Investigate this alert and conclude what happened and why.",
-  "```json",
-  JSON.stringify(alert, null, 2),
-  "```",
-  "Cite as sources the logs, metrics, commits or code that support your conclusion. List every telemetry source you tried and whether you could read it, with what you tried for one you could not; say how confident you are, lower when a source was out of reach.",
-  "Say whether the cause is in code Kitman can change, and propose a fix only then."
-].join(`
-
-`);
-var conclusionText = (conclusion, resolvedDuring) => [
-  conclusion.summary,
-  ...resolvedDuring ? ["It resolved on its own while it was being investigated."] : [],
-  `Cause: ${conclusion.cause} (confidence ${conclusion.confidence})`,
-  "Sources:",
-  ...conclusion.sources.map((source) => `- ${source}`),
-  ...conclusion.telemetry.some((source) => !source.reached) ? [
-    "Out of reach:",
-    ...conclusion.telemetry.filter((source) => !source.reached).map((source) => `- ${source.source}${source.tried === undefined ? "" : `: ${source.tried}`}`)
-  ] : [],
-  ...conclusion.fix === undefined ? [] : [`Fix: ${conclusion.fix}`]
-].join(`
-`);
-var firewatch_default = defineLoop({
-  id: "firewatch",
-  version: "1.0.0",
-  title: "Firewatch",
-  input: Input5,
-  output: Output6,
-  outcome: "investigation",
-  agents: { investigator: "investigator" },
-  checkout: "read",
-  when: [{ event: "monitoring.alert", input: { alert: "alert" } }],
-  offers: [{ id: "build-fix", title: "Build the fix", loop: "build", from: "fixRequest" }],
-  capabilities: ["agent_work", "ask", "create_tasks"],
-  calls: () => [build_default],
-  run: (input) => gen(function* () {
-    const fingerprint = fingerprintOf(input.alert);
-    const resolved = isResolved(input.alert);
-    const windowHours = input.windowHours ?? 6;
-    const request = { fingerprint, title: alertTitle(input.alert), windowHours, priority: priorityOf(input.alert) };
-    const placed = yield* alertTask("task", { ...request, ...resolved ? { resolved } : undefined });
-    const taskId = placed.taskId === undefined ? undefined : { taskId: placed.taskId };
-    if (placed.joined !== undefined)
-      return {
-        status: "folded",
-        ...taskId,
-        joinedRunId: placed.joined.runId,
-        resolvedDuring: false,
-        fix: "none"
-      };
-    if (resolved)
-      return { status: "resolved", ...taskId, resolvedDuring: false, fix: "none" };
-    const conclusion = yield* agentWork("investigate", {
-      agent: "investigator",
-      prompt: investigatePrompt(input.alert),
-      output: Conclusion
-    });
-    const resolvedDuring = (yield* alertTask("task:check", request)).resolved === true;
-    const stored = yield* artifact("conclusion", {
-      kind: "investigation_conclusion",
-      title: request.title,
-      text: conclusionText(conclusion, resolvedDuring),
-      data: { alert: input.alert, sources: conclusion.sources, confidence: conclusion.confidence }
-    });
-    yield* note("summary", { text: conclusion.summary, artifactId: stored.artifactId });
-    const concluded = {
-      status: "concluded",
-      ...taskId,
-      conclusionArtifactId: stored.artifactId,
-      resolvedDuring
-    };
-    if (conclusion.fix === undefined || !conclusion.inCode)
-      return { ...concluded, fix: "none" };
-    const fixRequest = {
-      words: `${conclusion.fix}
-
-${conclusionText(conclusion, resolvedDuring)}`,
-      outcome: "bug"
-    };
-    const confident = conclusion.confidence === "high" && !resolvedDuring;
-    const answer = yield* ask("start-fix", {
-      prompt: `${conclusion.summary}
-
-Start a Build that fixes it as a bug: ${conclusion.fix}?`,
-      options: [
-        { value: "Start a fix", description: "A Build fixes it as a bug and opens a ChangeRequest." },
-        { value: "Not now", description: "Keeps the finding on the Task." }
-      ],
-      recommended: confident ? "Start a fix" : "Not now",
-      recommendationReason: confident ? "Firewatch is confident of the cause and the alert is still firing." : resolvedDuring ? "The alert resolved while Firewatch looked, so a fix can wait for a person to judge." : "Firewatch is not confident of the cause, so a fix could aim at the wrong thing.",
-      default: input.autoFix === true && confident ? "Start a fix" : "Not now",
-      timeout: "1 hour"
-    });
-    if (answer === "Not now")
-      return { ...concluded, fix: "declined", fixRequest };
-    return yield* call("fix", build_default, {
-      ...fixRequest,
-      ...taskId,
-      ...input.repoBindingId === undefined ? undefined : { repoBindingId: input.repoBindingId }
-    }).pipe(map8((fixed) => ({ ...concluded, fix: "started", changeRequestUrl: fixed.changeRequest.url })), catchTag("ChildFailed", () => succeed6({ ...concluded, fix: "failed", fixRequest })));
-  })
-});
-
-// packages/loops/src/plan.ts
-var Input6 = Struct({
-  words: String4,
-  repoBindingId: optional(String4),
-  branch: optional(String4),
-  projectId: optional(String4),
-  implement: optional(Boolean2)
-});
-var Plan = Struct({
-  title: String4,
-  spec: String4,
-  tickets: PlanTickets,
-  outOfScope: ArraySchema(String4),
-  afterMerge: ArraySchema(String4),
-  docs: optional(Struct({ title: String4, summary: String4 }))
-});
-var CriteriaCheck = Struct({
-  alreadyMet: ArraySchema(Struct({ key: String4, criterion: String4 }))
-});
-var Rejected = Struct({ key: String4, reason: String4 });
-var Opinion = Struct({ summary: String4, concerns: ArraySchema(String4) });
-var TicketResult = Struct({
-  key: String4,
-  title: String4,
-  status: Literals(["merged", "failed", "skipped"]),
-  repoBindingId: optional(String4),
-  changeRequest: optional(ChangeRequestResult),
-  reason: optional(String4)
-});
-var Output7 = Struct({
-  title: String4,
-  outOfScope: ArraySchema(String4),
-  afterMerge: ArraySchema(String4),
-  rejected: ArraySchema(Rejected),
-  stopped: optional(String4),
-  implemented: Boolean2,
-  tickets: ArraySchema(TicketResult),
-  deliveries: ArraySchema(ChangeRequestResult),
-  tasks: optional(CreateTasksResult.fields.tasks),
-  docs: optional(ChangeRequestResult)
-});
-var menu = ["Implement now", "File as Tasks", "Second opinion", "Refine", "Finish"];
-var maxRounds = 6;
-var maxOpinionsPerPlan = 2;
-var menuDescriptions = {
-  "Implement now": "Builds the tickets in dependency order and delivers them.",
-  "File as Tasks": "Makes a Task of each ticket, to build later.",
-  "Second opinion": "Another Agent reviews the plan.",
-  Refine: "You say what to change and the planner rewrites it.",
-  Finish: "Ends the Run with the plan as it is."
-};
-var onFailure = ["Retry with a steer", "Skip it and its dependents", "Stop here"];
-var ticketRules = [
-  "Each ticket is one Build: a vertical slice an agent can implement, review and deliver as one ChangeRequest. Give it a short unique key, and list in blockedBy the keys of the tickets whose code it needs; tickets never block each other in a cycle. Set repoBindingId only when it changes another repository than the plan, keep one repository per ticket, and no cycle across repositories. Set outcome to the kind of change: feature, bug, refactor, docs, migration, investigation or performance.",
-  "Each acceptance criterion is something a Build can show before its ChangeRequest: a behaviour a test or a check proves. A text search is never a criterion, nor is something the code already does. Outcomes only visible after merge go under afterMerge, not under a ticket's criteria."
-].join(`
-
-`);
-var planPrompt = (words) => [
-  `Plan this: ${words}`,
-  "You run the grill-with-docs skill as a Kitman Step. Interview the person with the Kitman MCP ask tool, one question at a time, and ask only what changes what gets built: a clear goal needs no interview. Write the ADR and glossary changes the grilling settles in the checkout, and no other files.",
-  "Then write the spec and the tickets from the goal, the code and the answers.",
-  ticketRules,
-  "List in outOfScope what the plan deliberately leaves out, one item each; each holds the Builds of its tickets.",
-  "If you left ADR or glossary changes, give docs a ChangeRequest title and a summary of the decisions; Kitman opens it. Your Output is the plan, and Kitman stores it."
-].join(`
-
-`);
-var planText = (plan) => [
-  `# ${plan.title}`,
-  plan.spec,
-  ...plan.outOfScope.length === 0 ? [] : ["## Out of scope", plan.outOfScope.map((item) => `- ${item}`).join(`
-`)],
-  ...plan.afterMerge.length === 0 ? [] : ["## After merge", plan.afterMerge.map((item) => `- ${item}`).join(`
-`)],
-  "## Tickets",
-  ...plan.tickets.map(ticketText)
-].join(`
-
-`);
-var ticketText = (ticket) => [
-  `### ${ticket.key}: ${ticket.title}`,
-  ticket.body,
-  ...ticket.acceptanceCriteria.map((criterion) => `- [ ] ${criterion}`),
-  ...ticket.blockedBy.length === 0 ? [] : [`Blocked by: ${ticket.blockedBy.join(", ")}`]
-].join(`
-
-`);
-var opinionPrompt = (plan) => [
-  "Review this plan as a second opinion. Look for missing scope, tickets too big to review, wrong blockers and risks. Change nothing.",
-  planText(plan)
-].join(`
-
-`);
-var refinePrompt = (plan, words) => [`Change the plan as the user asks: ${words}`, ticketRules, planText(plan)].join(`
-
-`);
-var criteriaPrompt2 = (plan) => [
-  "Check each ticket's acceptance criteria against the base branch as it is now. List under alreadyMet each criterion the code already meets, with its ticket's key and the criterion word for word. Change nothing.",
-  planText(plan)
-].join(`
-
-`);
-var guard = " (guard: the base already does this)";
-var guarded = (plan, check) => {
-  const met = (ticket, criterion) => check.alreadyMet.some((entry) => entry.key === ticket.key && entry.criterion === criterion);
-  const rejected = plan.tickets.flatMap((ticket) => ticket.acceptanceCriteria.length > 0 && ticket.acceptanceCriteria.every((criterion) => met(ticket, criterion)) ? [{ key: ticket.key, reason: "The base branch already meets every one of its criteria" }] : []);
-  const gone = new Set(rejected.map((entry) => entry.key));
-  const tickets = plan.tickets.flatMap((ticket) => gone.has(ticket.key) ? [] : [
-    {
-      ...ticket,
-      acceptanceCriteria: ticket.acceptanceCriteria.map((criterion) => met(ticket, criterion) ? `${criterion}${guard}` : criterion),
-      blockedBy: ticket.blockedBy.filter((key) => !gone.has(key))
-    }
-  ]);
-  return { plan: { ...plan, tickets }, rejected };
-};
-var checked = (plan, revision) => map8(agentWork(`criteria-check:${revision}`, { agent: "reviewer", prompt: criteriaPrompt2(plan), output: CriteriaCheck }), (check) => guarded(plan, check));
-var storePlan = (plan, suffix) => gen(function* () {
-  yield* artifact(`spec${suffix}`, {
-    kind: "plan_spec",
-    title: plan.title,
-    text: plan.spec,
-    data: { outOfScope: [...plan.outOfScope] }
-  });
-  yield* artifact(`tickets${suffix}`, {
-    kind: "plan_tickets",
-    title: `Tickets for ${plan.title}`,
-    text: plan.tickets.map(ticketText).join(`
-
-`),
-    data: plan.tickets.map(({ repoBindingId, outcome, ...ticket }) => ({
-      ...ticket,
-      acceptanceCriteria: [...ticket.acceptanceCriteria],
-      blockedBy: [...ticket.blockedBy],
-      ...repoBindingId === undefined ? undefined : { repoBindingId },
-      ...outcome === undefined ? undefined : { outcome }
-    }))
-  });
-});
-var changelog = (before, after, words) => {
-  const was = new Map(before.tickets.map((ticket) => [ticket.key, ticketText(ticket)]));
-  const now = new Map(after.tickets.map((ticket) => [ticket.key, ticketText(ticket)]));
-  const lines = [
-    ...after.tickets.filter((ticket) => !was.has(ticket.key)).map((ticket) => `- Added ${ticket.key}: ${ticket.title}`),
-    ...before.tickets.filter((ticket) => !now.has(ticket.key)).map((ticket) => `- Removed ${ticket.key}: ${ticket.title}`),
-    ...after.tickets.filter((ticket) => was.has(ticket.key) && was.get(ticket.key) !== now.get(ticket.key)).map((ticket) => `- Changed ${ticket.key}: ${ticket.title}`),
-    ...before.spec === after.spec ? [] : ["- Changed the spec"],
-    ...before.title === after.title ? [] : [`- Renamed the plan from "${before.title}"`]
-  ];
-  return [`Asked: ${words}`, ...lines.length === 0 ? ["Nothing changed."] : lines].join(`
-`);
-};
-var buildWords = (ticket) => [
-  ticket.title,
-  ticket.body,
-  ...ticket.acceptanceCriteria.length === 0 ? [] : ["Acceptance criteria:", ...ticket.acceptanceCriteria.map((criterion) => `- ${criterion}`)]
-].join(`
-
-`);
-var settled = (ticket, result) => ({
-  key: ticket.key,
-  title: ticket.title,
-  ...result
-});
-var buildTicket = (ticket, start, taskId, retry) => gen(function* () {
-  let head = start;
-  const name = retry === undefined ? ticket.key : `${ticket.key}:${retry.label}`;
-  for (let attempt = 1;; attempt++) {
-    const suffix = attempt === 1 ? "" : `:${attempt}`;
-    const words = retry === undefined ? taskId === undefined ? { words: buildWords(ticket) } : undefined : { words: `${buildWords(ticket)}
-
-An earlier Build of this failed. ${retry.steer}` };
-    const built = yield* call(`build:${name}${suffix}`, build_default, {
-      ...words,
-      ...taskId === undefined ? undefined : { taskId },
-      repoBindingId: head.repoBindingId,
-      branch: head.branch,
-      revision: head.revision
-    }).pipe(catchTag("ChildFailed", (failure) => succeed6(failure)));
-    if (built instanceof ChildFailed)
-      return settled(ticket, { status: "failed", repoBindingId: head.repoBindingId, reason: built.reason });
-    const merged = yield* mergeChangeRequest(`merge:${name}${suffix}`, {
-      changeRequestId: built.changeRequest.id,
-      head: built.revision
-    });
-    const delivered = { repoBindingId: head.repoBindingId, changeRequest: built.changeRequest };
-    if (merged.status === "merged")
-      return settled(ticket, { status: "merged", ...delivered });
-    const choice = yield* ask(`conflict:${name}${suffix}`, {
-      prompt: `The ChangeRequest for ${ticket.key} (${built.changeRequest.url}) ${merged.status === "moved" ? "changed after it was built" : `conflicts with ${head.branch}`}. Rebuild ${ticket.key} on the integration branch as it is now, or skip it and the tickets it blocks?`,
-      options: [
-        {
-          value: "Rebuild on the integration branch",
-          description: "Builds the ticket again from the branch as it is now."
-        },
-        { value: "Skip", description: "Leaves it and the tickets it blocks undelivered." }
-      ],
-      recommended: "Rebuild on the integration branch",
-      recommendationReason: "A rebuild on the current branch usually resolves a conflict, and skipping also drops every ticket it blocks.",
-      default: "Skip",
-      timeout: "1 hour"
-    });
-    if (choice === "Skip")
-      return settled(ticket, { status: "failed", ...delivered, reason: `It conflicted with ${head.branch}` });
-    head = yield* integrationBranch(`rebuild-from:${name}:${attempt + 1}`, {
-      repoBindingId: head.repoBindingId
-    });
-  }
-});
-var deliveryBody = (plan, results) => {
-  const line = (result) => result.status === "merged" && result.changeRequest !== undefined ? `- **${result.key}** [${result.title}](${result.changeRequest.url}); its evidence is on that ChangeRequest` : `- **${result.key}** ${result.title}: ${result.reason ?? result.status}`;
-  const section = (title, status) => {
-    const lines = results.flatMap((result) => result.status === status ? [line(result)] : []);
-    return lines.length === 0 ? [] : [`## ${title}`, lines.join(`
-`)];
-  };
-  return [
-    `Delivers the plan "${plan.title}".`,
-    ...section("Merged", "merged"),
-    ...section("Failed", "failed"),
-    ...section("Skipped", "skipped")
-  ].join(`
-
-`);
-};
-var implement = (input, plan, revision, filed) => gen(function* () {
-  const tasks = filed?.revision === revision ? filed.tasks : (yield* createTasks("tasks", {
-    tickets: plan.tickets,
-    ...input.projectId === undefined ? undefined : { projectId: input.projectId }
-  })).tasks;
-  const taskOf = new Map(tasks.map((task) => [task.key, task.taskId]));
-  const results = new Map;
-  const waves = yield* planWaves(plan.tickets);
-  let stopped;
-  for (const [index, wave] of waves.entries()) {
-    const ready = [];
-    for (const ticket of wave) {
-      const unmerged = ticket.blockedBy.find((key) => results.get(key)?.status !== "merged");
-      if (stopped !== undefined)
-        results.set(ticket.key, settled(ticket, { status: "skipped", reason: stopped }));
-      else if (unmerged === undefined)
-        ready.push(ticket);
-      else
-        results.set(ticket.key, settled(ticket, { status: "skipped", reason: `blocked by ${unmerged}, which was not merged` }));
-    }
-    const repoOf = (ticket) => ticket.repoBindingId ?? input.repoBindingId;
-    const heads = new Map;
-    for (const repo of new Set(ready.map(repoOf)))
-      heads.set(repo, yield* integrationBranch(`integration:wave-${index + 1}:${repo ?? "default"}`, repo === undefined ? {} : { repoBindingId: repo }));
-    const built = yield* forEach(ready.flatMap((ticket) => {
-      const head = heads.get(repoOf(ticket));
-      return head === undefined ? [] : [buildTicket(ticket, head, taskOf.get(ticket.key))];
-    }), (building) => building, { concurrency: "unbounded" });
-    for (const first of built) {
-      const ticket = ready.find((entry) => entry.key === first.key);
-      let result = first;
-      for (let retry = 1;ticket !== undefined && result.status === "failed" && stopped === undefined; retry++) {
-        const choice = yield* ask(`failed:${ticket.key}:${retry}`, {
-          prompt: `The Build of ${ticket.key} failed: ${result.reason ?? "no reason given"}. Retry it with a steer, skip it and the tickets it blocks, or stop here?`,
-          options: onFailure,
-          recommended: "Retry with a steer",
-          recommendationReason: "The reason it failed is above, so a steer can aim the retry at it; skipping also drops the tickets it blocks.",
-          default: "Skip it and its dependents",
-          timeout: "1 hour"
-        });
-        if (choice === "Skip it and its dependents")
-          break;
-        if (choice === "Stop here") {
-          stopped = `Stopped after ${ticket.key} failed`;
-          break;
-        }
-        const steer = yield* ask(`steer:${ticket.key}:${retry}`, {
-          prompt: `What should the retry of ${ticket.key} do differently?`,
-          freeText: true,
-          recommended: `Address the failure: ${result.reason ?? "find out why it failed first"}`,
-          recommendationReason: "Pointing the retry at the reason it failed is the least a steer should do.",
-          default: null
-        });
-        const head = yield* integrationBranch(`integration:${ticket.key}:retry-${retry}`, {
-          ...repoOf(ticket) === undefined ? undefined : { repoBindingId: repoOf(ticket) }
-        });
-        result = yield* buildTicket(ticket, head, taskOf.get(ticket.key), { label: `retry-${retry}`, steer });
-      }
-      results.set(result.key, result);
-    }
-  }
-  const ordered = plan.tickets.flatMap((ticket) => results.get(ticket.key) ?? []);
-  const repos = [
-    ...new Set(ordered.flatMap((result) => result.status === "merged" ? result.repoBindingId ?? [] : []))
-  ];
-  const deliveries = yield* forEach(repos, (repo) => changeRequest(`deliver:${repo}`, {
-    title: plan.title,
-    body: deliveryBody(plan, ordered.filter((result) => result.repoBindingId === repo || result.repoBindingId === undefined)),
-    integration: repo
-  }));
-  return { tickets: ordered, deliveries, tasks, ...stopped === undefined ? undefined : { stopped } };
-});
-var plan_default = defineLoop({
-  id: "plan",
-  version: "2.0.0",
-  title: "Plan",
-  input: Input6,
-  output: Output7,
-  agents: { planner: "planner", reviewer: "reviewer" },
-  checkout: "write",
-  capabilities: [
-    "agent_work",
-    "ask",
-    "call",
-    "verify",
-    "change_request",
-    "write_back",
-    "create_tasks",
-    "merge_change_request",
-    "read_change_request",
-    "post_comment"
-  ],
-  calls: () => [build_default],
-  run: (input) => gen(function* () {
-    const drafted = yield* agentWorkOnce("plan", {
-      agent: "planner",
-      skill: "grill-with-docs",
-      prompt: planPrompt(input.words),
-      output: Plan
-    });
-    const docs = drafted.docs === undefined ? undefined : yield* changeRequest("docs", { title: drafted.docs.title, body: drafted.docs.summary });
-    let revision = 1;
-    let { plan, rejected } = yield* checked(drafted, revision);
-    let filed;
-    let opinions = 0;
-    yield* storePlan(plan, "");
-    const project = input.projectId === undefined ? undefined : { projectId: input.projectId };
-    const ended = (rest) => ({
-      title: plan.title,
-      outOfScope: plan.outOfScope,
-      afterMerge: plan.afterMerge,
-      rejected,
-      tickets: [],
-      deliveries: [],
-      ...filed === undefined ? undefined : { tasks: filed.tasks },
-      ...docs === undefined ? undefined : { docs },
-      ...rest
-    });
-    for (let round = 1;round <= maxRounds; round++) {
-      const isFiled = filed?.revision === revision;
-      const options = menu.filter((option) => !(option === "File as Tasks" && isFiled) && !(option === "Second opinion" && opinions >= maxOpinionsPerPlan));
-      const fallback = input.implement === true ? "Implement now" : isFiled ? "Finish" : "File as Tasks";
-      const answer = yield* ask(`next:${round}`, {
-        prompt: `What next for the plan "${plan.title}"?`,
-        options: options.map((option) => ({ value: option, description: menuDescriptions[option] })),
-        recommended: fallback,
-        recommendationReason: fallback === "Implement now" ? "You asked for the plan to be implemented." : fallback === "Finish" ? "The plan is filed as Tasks, so nothing is lost by finishing." : "Filing keeps the plan as Tasks a person or a Build can pick up later.",
-        default: fallback,
-        timeout: "1 hour"
-      });
-      const choice = menu.find((option) => option === answer) ?? fallback;
-      switch (choice) {
-        case "Finish":
-          return ended({ implemented: false });
-        case "Implement now": {
-          const delivered = yield* implement(input, plan, revision, filed);
-          return { ...ended({ implemented: true }), ...delivered };
-        }
-        case "File as Tasks": {
-          const made = yield* createTasks(`file-tasks:${round}`, { tickets: plan.tickets, ...project });
-          filed = { revision, tasks: made.tasks };
-          break;
-        }
-        case "Second opinion": {
-          opinions++;
-          const opinion = yield* agentWork(`second-opinion:${round}`, {
-            agent: "reviewer",
-            prompt: opinionPrompt(plan),
-            output: Opinion
-          });
-          yield* artifact(`opinion:${round}`, {
-            kind: "plan_review",
-            title: `Second opinion on ${plan.title}`,
-            text: [opinion.summary, ...opinion.concerns.map((concern) => `- ${concern}`)].join(`
-
-`)
-          });
-          break;
-        }
-        case "Refine": {
-          const words = yield* ask(`refine:${round}`, {
-            prompt: "What should change in the plan?",
-            freeText: true,
-            informationOnly: true,
-            recommendationReason: "You chose to refine it, so only you know what should change."
-          });
-          const refined = yield* agentWorkOnce(`refine-plan:${round}`, {
-            agent: "planner",
-            prompt: refinePrompt(plan, words),
-            output: Plan
-          });
-          const before = plan;
-          revision++;
-          ({ plan, rejected } = yield* checked(refined, revision));
-          yield* storePlan(plan, `:${round}`);
-          yield* artifact(`changes:${round}`, {
-            kind: "plan_changes",
-            title: `Revision ${revision} of ${plan.title}`,
-            text: changelog(before, plan, words)
-          });
-          break;
-        }
-      }
-    }
-    if (filed?.revision !== revision)
-      filed = {
-        revision,
-        tasks: (yield* createTasks("file-tasks:last", { tickets: plan.tickets, ...project })).tasks
-      };
-    return ended({
-      implemented: false,
-      stopped: `No decision after ${maxRounds} rounds, so the tickets are filed as Tasks for a person to pick up`
-    });
-  })
-});
-
-// packages/loops/src/project-update.ts
-var Health = Literals(["on_track", "at_risk", "off_track"]);
-var Input7 = Struct({ projectId: String4 });
-var Output8 = Struct({
-  draftId: optional(String4),
-  health: optional(Health)
-});
-var Written = Struct({
-  health: Health,
-  note: String4,
-  healthReason: optional(String4)
-});
-var label = { on_track: "on track", at_risk: "at risk", off_track: "off track" };
-var day = (iso) => new Date(iso).toLocaleDateString("en-US", { month: "short", day: "numeric", timeZone: "UTC" });
-var prompt2 = (read) => [
-  `Write a Project Update for ${read.project.name} from what happened ${read.since === undefined ? "so far" : `since its last Update on ${day(read.since)}`}.`,
-  "```json",
-  JSON.stringify({ health: read.health, runs: read.runs, taskChanges: read.taskChanges }, null, 2),
-  "```",
-  "Say in a few short paragraphs what moved, what is stuck and what comes next, naming Tasks by key. Suggest a health: on_track, at_risk or off_track.",
-  ...read.health === undefined ? [] : [
-    `The last Update said ${read.health}. If your health differs, give in healthReason one sentence on why, naming the Runs or Tasks that moved it.`
-  ],
-  "A person reviews and posts it, so claim nothing the Runs and Task changes do not show."
-].join(`
-`);
-var noteOf = (read, written) => {
-  if (read.health === undefined || read.health === written.health)
-    return written.note;
-  const moved = `Health moved from ${label[read.health]} to ${label[written.health]}`;
-  return `${written.healthReason === undefined ? `${moved}.` : `${moved}: ${written.healthReason}`}
-
-${written.note}`;
-};
-var project_update_default = defineLoop({
-  id: "project-update",
-  version: "2.0.1",
-  title: "Project update",
-  input: Input7,
-  output: Output8,
-  agents: { writer: "writer" },
-  checkout: "none",
-  capabilities: ["read_project", "agent_work", "draft_update"],
-  run: ({ projectId }) => gen(function* () {
-    const read = yield* projectActivity("read", { projectId });
-    if (read.runs.length === 0 && read.taskChanges.length === 0)
-      return {};
-    const written = yield* agentWork("write", { agent: "writer", prompt: prompt2(read), output: Written });
-    const draft = yield* draftUpdate("draft", {
-      projectId,
-      health: written.health,
-      note: noteOf(read, written),
-      writtenFrom: {
-        runs: read.runs.length,
-        taskChanges: read.taskChanges.length,
-        ...read.since === undefined ? undefined : { since: read.since }
-      }
-    });
-    return { draftId: draft.id, health: written.health };
-  })
-});
-
-// packages/loops/src/release.ts
-var Input8 = Struct({
-  tag: optional(String4),
-  revision: optional(String4),
-  changeRequestId: optional(String4),
-  deployTarget: optional(String4),
-  deployEvent: optional(String4),
-  deployTimeoutMinutes: optional(Int)
-});
-var Drafted = Struct({
-  tag: String4,
-  previousTag: optional(String4),
-  title: String4,
-  notes: String4,
-  changeRequests: ArraySchema(String4)
-});
-var Output9 = Struct({
-  status: Literals([
-    "gate_failed",
-    "not_mergeable",
-    "rejected",
-    "deployed",
-    "rolled_back",
-    "deploy_failed",
-    "timed_out"
-  ]),
-  reason: String4,
-  tag: optional(String4),
-  notesArtifactId: optional(String4),
-  revision: optional(String4),
-  url: optional(String4)
-});
-var draftPrompt = (tag, changeRequestId) => [
-  "Draft the release notes for the ChangeRequests merged since the last release tag on the base branch, including those with no linked Task.",
-  ...changeRequestId === undefined ? [] : [`The release ChangeRequest ${changeRequestId} is part of it.`],
-  "Group them by what a user of the software notices, and name each ChangeRequest you cover.",
-  tag === undefined ? "Propose the next version tag, following the scheme earlier tags use. With no earlier tag, propose v0.1.0 and say so in the notes." : `The release is tagged ${tag}.`,
-  "Give the latest earlier release tag as previousTag, or leave it out when there is none."
-].join(`
-
-`);
-var redraftPrompt = (drafted, edit) => [
-  "Redraft these release notes as asked, keeping the tag and everything not mentioned.",
-  `Asked: ${edit}`,
-  "```json",
-  JSON.stringify(drafted, null, 2),
-  "```"
-].join(`
-
-`);
-var readyToMerge = (changeRequestId, round = 1) => gen(function* () {
-  for (let pass = 1;; pass++) {
-    const at = (name) => {
-      const named = pass === 1 ? name : `${name}:moved:${pass}`;
-      return round === 1 ? named : `${named}:${round}`;
-    };
-    let read = yield* pipelineStatus(at("gate"), { changeRequestId });
-    for (let look = 1;look <= 10 && (read.status === "running" || read.status === "none"); look++) {
-      const again = (name) => at(look === 1 ? name : `${name}:${look}`);
-      yield* pipelineMoved(again("gate:pipeline"), changeRequestId, read);
-      read = yield* pipelineStatus(again("gate:after"), { changeRequestId });
-    }
-    if (read.status !== "success") {
-      const failing = read.jobs.filter((job) => job.status === "failed").map((job) => job.name);
-      return {
-        status: "gate_failed",
-        reason: `The pipeline at ${read.head} is ${read.status}${failing.length === 0 ? "" : `: ${failing.join(", ")}`}`,
-        revision: read.head
-      };
-    }
-    const approved = yield* waitFor(at("approved"), {
-      event: "change_request.approval",
-      filter: { changeRequestId, approved: true, head: read.head },
-      timeout: "7 days",
-      or: read.readAt === undefined ? [] : [{ event: "change_request.pipeline", filter: { changeRequestId }, since: read.readAt }]
-    });
-    if (approved.type !== "change_request.approval") {
-      if (pass >= 10)
-        return {
-          status: "not_mergeable",
-          reason: `ChangeRequest ${changeRequestId} kept moving while it awaited approval`
-        };
-      continue;
-    }
-    const mergeable = yield* waitFor(at("mergeable"), {
-      event: "change_request.mergeable",
-      filter: { changeRequestId },
-      timeout: "1 hour"
-    });
-    if (mergeable.payload.mergeable === false)
-      return {
-        status: "not_mergeable",
-        reason: `ChangeRequest ${changeRequestId} does not merge cleanly; bring it up to date first`
-      };
-    return { passed: read.head };
-  }
-}).pipe(catchTags({
-  WaitTimedOut: (timedOut) => succeed6({
-    status: "not_mergeable",
-    reason: `Nothing happened on ChangeRequest ${changeRequestId} while waiting for ${timedOut.event}`
-  }),
-  ChangeRequestClosed: (closed) => succeed6({
-    status: "not_mergeable",
-    reason: `ChangeRequest ${changeRequestId} was ${closed.merged ? "merged" : "closed"} before Kitman released it`
-  })
-}));
-var recovery = (previous) => previous === undefined ? ["Retry the deploy", "Leave it"] : ["Retry the deploy", `Roll back to ${previous}`, "Leave it"];
-var release_default = defineLoop({
-  id: "release",
-  version: "2.0.0",
-  title: "Release",
-  input: Input8,
-  output: Output9,
-  agents: { releaser: "releaser" },
-  checkout: "read",
-  capabilities: [
-    "agent_work",
-    "ask",
-    "verify",
-    "claim",
-    "publish_release",
-    "read_change_request",
-    "merge_change_request"
-  ],
-  run: (input) => gen(function* () {
-    const changeRequestId = input.changeRequestId;
-    let gated;
-    if (changeRequestId === undefined) {
-      const gate = yield* verify("gate", input.revision === undefined ? {} : { revision: input.revision });
-      if (!gate.passed) {
-        const failing = gate.checks.filter((check) => check.status !== "passed").map((check) => check.name);
-        return {
-          status: "gate_failed",
-          reason: `The checks fail at ${gate.revision}: ${failing.join(", ")}`,
-          revision: gate.revision
-        };
-      }
-      gated = gate.revision;
-    } else {
-      const ready = yield* readyToMerge(changeRequestId);
-      if (!("passed" in ready))
-        return ready;
-      gated = ready.passed;
-    }
-    let drafted = yield* agentWork("draft-notes", {
-      agent: "releaser",
-      prompt: draftPrompt(input.tag, changeRequestId),
-      output: Drafted
-    });
-    const tag = input.tag ?? drafted.tag;
-    for (let round = 1;; round++) {
-      const answer = yield* ask(round === 1 ? "approve" : `approve:${round}`, {
-        prompt: `Release ${tag} with these notes?
-
-${drafted.notes}`,
-        options: [
-          { value: "Approve", description: "Tags, publishes and deploys it." },
-          { value: "Edit notes", description: "Say what to change; the notes are redrafted." },
-          { value: "Reject", description: "Keeps the draft and releases nothing." }
-        ],
-        recommended: "Approve",
-        recommendationReason: "The release is proved: its checks pass, or its ChangeRequest is green, approved and mergeable.",
-        default: null
-      });
-      if (answer === "Approve")
-        break;
-      if (answer === "Reject") {
-        const why = yield* ask("reject-why", {
-          prompt: `Why not release ${tag}? The draft is kept.`,
-          freeText: true,
-          informationOnly: true,
-          recommendationReason: "Only you know why you rejected it.",
-          default: "No reason given",
-          timeout: "1 day"
-        });
-        const kept = yield* artifact("notes", {
-          kind: "release_notes",
-          title: drafted.title,
-          text: drafted.notes,
-          data: { tag, changeRequests: drafted.changeRequests }
-        });
-        return { status: "rejected", reason: why, tag, notesArtifactId: kept.artifactId };
-      }
-      const edit = yield* ask(`edit:${round}`, {
-        prompt: "What should change in the notes?",
-        freeText: true,
-        informationOnly: true,
-        recommendationReason: "You chose to edit them, so only you know what should change.",
-        default: "",
-        timeout: "1 day"
-      });
-      if (edit.trim() === "")
-        continue;
-      drafted = yield* agentWork(`redraft:${round}`, {
-        agent: "releaser",
-        prompt: redraftPrompt(drafted, edit),
-        output: Drafted
-      });
-    }
-    const notes = yield* artifact("notes", {
-      kind: "release_notes",
-      title: drafted.title,
-      text: drafted.notes,
-      data: { tag, changeRequests: drafted.changeRequests }
-    });
-    let revision = gated;
-    if (changeRequestId !== undefined) {
-      for (let round = 1;; round++) {
-        const merged = yield* mergeChangeRequest(round === 1 ? "merge" : `merge:${round}`, {
-          changeRequestId,
-          head: gated
-        });
-        if (merged.status === "conflict")
-          return {
-            status: "not_mergeable",
-            reason: `ChangeRequest ${changeRequestId} no longer merges cleanly`,
-            tag,
-            notesArtifactId: notes.artifactId
-          };
-        if (merged.status === "merged") {
-          revision = merged.revision;
-          break;
-        }
-        if (round >= 3)
-          return {
-            status: "not_mergeable",
-            reason: `ChangeRequest ${changeRequestId} kept moving while it was gated; it is at ${merged.head}`,
-            tag,
-            notesArtifactId: notes.artifactId
-          };
-        const ready = yield* readyToMerge(changeRequestId, round + 1);
-        if (!("passed" in ready))
-          return { ...ready, tag, notesArtifactId: notes.artifactId };
-        gated = ready.passed;
-      }
-    }
-    const deployEvent = input.deployEvent ?? "deploy";
-    yield* claim("deploy-target", { resource: `deploy:${input.deployTarget ?? deployEvent}` });
-    const released = yield* release2("tag", {
-      tag,
-      revision,
-      title: drafted.title,
-      notes: drafted.notes
-    });
-    const deployed = (step, deployTag) => waitFor(step, {
-      event: deployEvent,
-      filter: { tag: deployTag },
-      timeout: `${input.deployTimeoutMinutes ?? 60} minutes`
-    }).pipe(map8((deploy) => deploy.payload.status === "failed" ? "deploy_failed" : "deployed"), catchTag("WaitTimedOut", () => succeed6("timed_out")));
-    const settled = { tag, notesArtifactId: notes.artifactId, revision: released.revision, url: released.url };
-    let status = yield* deployed("deploy", tag);
-    for (let round = 1;status !== "deployed"; round++) {
-      const options = recovery(drafted.previousTag);
-      const answer = yield* ask(`recover:${round}`, {
-        prompt: `${tag} ${status === "timed_out" ? "did not report a deploy in time" : "failed to deploy"}. What now?`,
-        options,
-        recommended: "Retry the deploy",
-        recommendationReason: "A failed or late deploy is often passing, and a retry runs only the failed jobs of the same tag.",
-        default: "Leave it",
-        timeout: "1 hour"
-      });
-      if (answer === "Leave it")
-        return { status, reason: `${tag} at ${released.revision} was left undeployed`, ...settled };
-      if (answer === "Retry the deploy") {
-        yield* rerunPipeline(`deploy:rerun-${round}`, { ref: tag });
-        status = yield* deployed(`deploy:retry-${round}`, tag);
-        continue;
-      }
-      const previous = drafted.previousTag ?? tag;
-      yield* rerunPipeline(`deploy:redeploy-${round}`, { ref: previous, all: true });
-      const back = yield* deployed(`deploy:rollback-${round}`, previous);
-      if (back === "deployed")
-        return { status: "rolled_back", reason: `Rolled back to ${previous}`, ...settled };
-      status = back;
-    }
-    yield* artifact("report", {
-      kind: "release_report",
-      title: `${tag} deployed`,
-      text: `${tag} at ${released.revision} deployed. ${released.url}`,
-      data: { tag, status, revision: released.revision, url: released.url }
-    });
-    return { status: "deployed", reason: `${tag} deployed`, ...settled };
-  })
-});
-
-// packages/loops/src/research.ts
-class ResearchQuestionMissing extends TaggedError2()("ResearchQuestionMissing", {
-  message: String4
-}) {
-}
-var Input9 = Struct({
-  taskId: optional(String4),
-  words: optional(String4),
-  repoBindingId: optional(String4)
-});
-var Sources = NonEmptyArray(String4);
-var Fix = Struct({
-  words: String4,
-  outcome: LoopOutcome
-});
-var NextSteps = Struct({ tickets: PlanTickets });
-var Report = Struct({
-  title: String4,
-  summary: String4,
-  findings: ArraySchema(Struct({
-    finding: String4,
-    basis: Literals(["observed", "read", "inferred"]),
-    sources: Sources
-  })),
-  sources: Sources,
-  unreached: ArraySchema(Struct({ source: String4, tried: String4 })),
-  openQuestions: ArraySchema(String4),
-  nextSteps: ArraySchema(String4),
-  fix: optionalKey(Fix),
-  nextStepTasks: optionalKey(NextSteps)
-});
-var Verdict = Struct({
-  supported: Boolean2,
-  gaps: ArraySchema(String4)
-});
-var Output10 = Struct({
-  reportArtifactId: String4,
-  gaps: ArraySchema(String4),
-  unreached: ArraySchema(String4),
-  fix: optionalKey(Fix),
-  nextStepTasks: optionalKey(NextSteps)
-});
-var researchPrompt = (words) => [
-  words === undefined ? "Research the question this Task asks, using the `research` skill. The Task's title, description, Acceptance Criteria and comments are in your context." : `Research this, using the \`research\` skill: ${words}`,
-  "If your context has an earlier research report on this, extend it: keep what still holds, check what may have changed, and answer what it left open. Do not start over.",
-  "Cite primary sources for every finding: the code, official documentation, specifications and first-party APIs. You may run things to reproduce behaviour; change nothing in the repository. Mark each finding observed (you ran it and saw it), read (a source says so) or inferred (you concluded it).",
-  "List every source you needed and could not reach under `unreached`, with what you tried, and lower your conclusions to what the sources you did reach show.",
-  "If the question turns out to be a bug report, say so in the summary and give `fix` with outcome bug. If the report proposes any other change, give `fix` with its outcome. Give next steps worth doing as `nextStepTasks` tickets too.",
-  "Return the report as your Output. Do not write it into the repository."
-].join(`
-
-`);
-var reviewPrompt = (report) => [
-  "Judge whether this research report is supported: does each conclusion follow from the evidence it cites? Check the cited sources where you can.",
-  "Answer supported, and list every gap: a claim its evidence does not show, including one that rests on a source listed as unreached. Do not ask for more scope; judge what it claims.",
-  "```json",
-  JSON.stringify(report, null, 2),
-  "```"
-].join(`
-`);
-var againPrompt = (words, gaps) => [
-  researchPrompt(words),
-  "A reviewer found these claims unsupported by their evidence. Support each with evidence, or drop or weaken the claim:",
-  ...gaps.map((gap) => `- ${gap}`)
-].join(`
-
-`);
-var list = (items) => items.length === 0 ? ["None."] : items.map((item) => `- ${item}`);
-var reportMarkdown = (report, gaps) => [
-  `# ${report.title}`,
-  "",
-  report.summary,
-  "",
-  ...gaps.length === 0 ? [] : ["## Gaps", "", "A reviewer found these unsupported:", "", ...list(gaps), ""],
-  "## Findings",
-  "",
-  ...report.findings.flatMap(({ finding, basis, sources }) => [
-    `- ${finding} (${basis})`,
-    ...sources.map((source) => `  - ${source}`)
-  ]),
-  "",
-  "## Sources",
-  "",
-  ...list(report.sources),
-  "",
-  ...report.unreached.length === 0 ? [] : ["## Out of reach", "", ...report.unreached.map(({ source, tried }) => `- ${source}: ${tried}`), ""],
-  "## Open questions",
-  "",
-  ...list(report.openQuestions),
-  "",
-  "## Next steps",
-  "",
-  ...list(report.nextSteps),
-  ...report.fix === undefined ? [] : ["", "## Proposed fix", "", `${report.fix.words} (${report.fix.outcome})`]
-].join(`
-`);
-var sample = {
-  title: "Does the API cap request bodies?",
-  summary: "It does, at 1 MB.",
-  findings: [
-    {
-      finding: "The server sets maxRequestBodySize to 1 MB.",
-      basis: "read",
-      sources: ["apps/api/src/server.ts:20"]
-    }
-  ],
-  sources: ["apps/api/src/server.ts:20"],
-  unreached: [],
-  openQuestions: [],
-  nextSteps: []
-};
-var research_default = defineLoop({
-  id: "research",
-  version: "2.0.0",
-  title: "Research",
-  input: Input9,
-  output: Output10,
-  outcome: "investigation",
-  agents: { researcher: "researcher", reviewer: "reviewer" },
-  checkout: "read",
-  capabilities: ["agent_work"],
-  offers: [
-    { id: "file-next-steps", title: "File next steps as Tasks", loop: "file-tasks", from: "nextStepTasks" },
-    { id: "build-fix", title: "Build the fix", loop: "build", from: "fix" }
-  ],
-  checks: [
-    {
-      name: "reports",
-      script: { input: { taskId: "task-1" }, outputs: { research: sample, review: { supported: true, gaps: [] } } }
-    }
-  ],
-  run: (input) => gen(function* () {
-    if (input.taskId === undefined && input.words === undefined)
-      return yield* new ResearchQuestionMissing({ message: "Give the question to research, or a Task" });
-    const first = yield* agentWork("research", {
-      agent: "researcher",
-      prompt: researchPrompt(input.words),
-      output: Report
-    });
-    const firstVerdict = yield* agentWork("review", {
-      agent: "reviewer",
-      prompt: reviewPrompt(first),
-      output: Verdict
-    });
-    const report = firstVerdict.supported ? first : yield* agentWork("research:again", {
-      agent: "researcher",
-      prompt: againPrompt(input.words, firstVerdict.gaps),
-      output: Report
-    });
-    const gaps = firstVerdict.supported ? [] : yield* agentWork("review:again", { agent: "reviewer", prompt: reviewPrompt(report), output: Verdict }).pipe(map8((verdict) => verdict.supported ? [] : verdict.gaps));
-    const { nextStepTasks: _, ...data } = report;
-    const { artifactId } = yield* artifact("report", {
-      kind: "research_report",
-      title: report.title,
-      text: reportMarkdown(report, gaps),
-      data
-    });
-    if (input.taskId !== undefined)
-      yield* note("summary", { text: report.summary, artifactId });
-    return {
-      reportArtifactId: artifactId,
-      gaps,
-      unreached: report.unreached.map(({ source }) => source),
-      ...report.fix === undefined ? undefined : { fix: report.fix },
-      ...report.nextStepTasks === undefined ? undefined : { nextStepTasks: report.nextStepTasks }
-    };
-  })
-});
-
-// packages/loops/src/hindsight.ts
-var Input10 = Struct({
-  days: optional(Int.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo(31))),
-  teamId: optional(String4),
-  improvements: optional(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(5)))
-});
-var categories = [
-  "navigation",
-  "checks",
-  "standards",
-  "instructions",
-  "tool_economy",
-  "no_ops",
-  "information_access",
-  "kitman"
-];
-var Category = Literals(categories);
-var Finding2 = Struct({
-  key: String4.check(isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/), isMaxLength(80)),
-  category: Category,
-  kind: Literals(["memory", "task"]),
-  lesson: String4,
-  detail: optional(String4),
-  fix: optional(Struct({ size: Literals(["errand", "build"]), words: String4 })),
-  citations: ArraySchema(TranscriptPoint)
-});
-var Findings = Struct({ findings: ArraySchema(Finding2) });
-var Proposal = Struct({
-  key: String4,
-  category: Category,
-  kind: Literals(["memory", "task"]),
-  id: String4,
-  matched: Boolean2,
-  runIds: ArraySchema(String4)
-});
-var Output11 = Struct({
-  summary: String4,
-  proposals: ArraySchema(Proposal),
-  leftOut: ArraySchema(Struct({ key: String4, reason: String4 })),
-  improvements: ArraySchema(Struct({ key: String4, loop: Literals(["errand", "build"]), outcome: String4 }))
-});
-var prompt3 = (runs, days) => [
-  `These Runs settled in the last ${days} days, each with its status: a failed one with its failure, one with a retried Step marked retried. Find what keeps going wrong in more than one Run: a failure, or in Runs that completed, a wasted step, a wrong turn, a check run again and again, or work redone. Fix the cause, not the symptom.`,
-  "```json",
-  JSON.stringify(runs, null, 2),
-  "```",
-  `Give each finding a category: ${categories.join(", ")}. Use kitman when Kitman itself misbehaved: a Run that stalled, parked or needed rescue for a reason in Kitman, not in the work.`,
-  "Give each a stable kebab-case key naming the problem, not the week: the same problem must get the same key next time.",
-  "Propose Memory when agents can avoid it by knowing something, or a Task when something has to change; when the change is clear, say how to fix it as an errand (small) or a build (a feature). Cite every Transcript point (runId, stepAttemptId, sequence) it shows in. Cite what happened: tool calls and results, files and answers. An agent's own messages are not evidence. Leave out anything seen in one Run only.",
-  "Never quote a person's words into a lesson."
-].join(`
-
-`);
-var point = (cited) => `${cited.runId}/${cited.stepAttemptId}/${cited.sequence}`;
-var shared = (cited, field) => {
-  const values = new Set(cited.map((run) => run[field]));
-  const [only] = values;
-  return values.size === 1 ? only : undefined;
-};
-var proposal = (finding, runs) => {
-  const evidence = new Set(runs.flatMap((run) => run.entries.flatMap((entry) => entry.kind === "message" ? [] : [point({ runId: run.runId, stepAttemptId: entry.stepAttemptId, sequence: entry.sequence })])));
-  const citations = [
-    ...new Map(finding.citations.filter((cited) => evidence.has(point(cited))).map((cited) => [point(cited), cited])).values()
-  ];
-  const runIds = new Set(citations.map((cited) => cited.runId));
-  const [first, ...rest] = citations;
-  if (first === undefined)
-    return { reason: "It cites no evidence that was read: an agent\u2019s own words or a summary are not evidence" };
-  if (runIds.size < 2)
-    return { reason: "It was seen in one Run only" };
-  const teamId = shared(runs.filter((run) => runIds.has(run.runId)), "teamId");
-  if (finding.kind === "memory" && teamId !== undefined)
-    return { request: { kind: "memory", teamId, content: finding.lesson, citations: [first, ...rest] } };
-  return {
-    request: {
-      kind: "task",
-      title: finding.lesson,
-      description: finding.detail ?? finding.lesson,
-      ...teamId === undefined ? undefined : { teamId },
-      key: finding.key,
-      citations: [first, ...rest]
-    }
-  };
-};
-var hindsight_default = defineLoop({
-  id: "hindsight",
-  version: "1.0.0",
-  title: "Hindsight",
-  input: Input10,
-  output: Output11,
-  outcome: "investigation",
-  agents: { investigator: "investigator" },
-  checkout: "none",
-  schedule: { rule: { frequency: "weekly", daysOfWeek: [1], hour: 9, minute: 0 }, timezone: "UTC" },
-  capabilities: ["read_transcripts", "agent_work", "propose"],
-  calls: () => [errand_default, build_default],
-  run: (input) => gen(function* () {
-    const days = input.days ?? 7;
-    const read = yield* transcripts("read", { days });
-    const runs = read.runs.filter((run) => input.teamId === undefined || run.teamId === input.teamId);
-    if (runs.length < 2)
-      return {
-        summary: `Nothing recurred: ${runs.length === 0 ? "no Run" : "one Run"} settled in the last ${days} days.`,
-        proposals: [],
-        leftOut: [],
-        improvements: []
-      };
-    const { findings } = yield* agentWork("find", {
-      agent: "investigator",
-      prompt: prompt3(runs, days),
-      output: Findings
-    });
-    const judged = findings.map((finding) => ({ finding, judged: proposal(finding, runs) }));
-    const leftOut = judged.flatMap(({ finding, judged }) => judged.request === undefined ? [{ key: finding.key, reason: judged.reason }] : []);
-    const kept = judged.flatMap(({ finding, judged }) => judged.request === undefined ? [] : [{ finding, request: judged.request }]);
-    const proposals = yield* forEach(kept, ({ finding, request }) => map8(propose(`propose:${finding.key}`, request), (made) => ({
-      key: finding.key,
-      category: finding.category,
-      kind: made.kind,
-      id: made.id,
-      matched: made.matched === true,
-      runIds: [...new Set(request.citations.map((cited) => cited.runId))]
-    })));
-    const fixable = kept.flatMap(({ finding }) => finding.fix === undefined ? [] : [{ ...finding, fix: finding.fix }]);
-    const improvements = yield* forEach(fixable.slice(0, input.improvements ?? 0), (finding) => {
-      const started = finding.fix.size === "errand" ? map8(call(`improve:${finding.key}`, errand_default, { words: finding.fix.words }), (done) => done.status) : map8(call(`improve:${finding.key}`, build_default, { words: finding.fix.words }), (built) => built.stopped);
-      return started.pipe(catchTag("ChildFailed", (failed) => succeed6(`failed: ${failed.reason}`)), map8((outcome) => ({ key: finding.key, loop: finding.fix.size, outcome })));
-    });
-    const fresh = proposals.filter((made) => !made.matched).length;
-    return {
-      summary: proposals.length === 0 ? `Nothing recurred with evidence in ${runs.length} Runs.` : `${proposals.length} recurring ${proposals.length === 1 ? "problem" : "problems"}: ${fresh} proposed, ${proposals.length - fresh} added to earlier work.`,
-      proposals,
-      leftOut,
-      improvements
-    };
-  })
-});
-
-// packages/loops/src/sweep.ts
-var Input11 = Struct({
-  authors: optional(NonEmptyArray(String4)),
-  branch: optional(String4),
-  repoBindingId: optional(String4),
-  maxFixRounds: optional(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(5)))
-});
-var Decision = Literals(["batch", "alone", "hold"]);
-var Assessed = Struct({
-  updates: ArraySchema(Struct({
-    number: String4,
-    decision: Decision,
-    reason: String4,
-    major: Boolean2
-  }))
-});
-var Batched = Struct({
-  applied: ArraySchema(String4),
-  dropped: ArraySchema(Struct({ number: String4, reason: String4 })),
-  summary: String4
-});
-var Placed = Struct({ number: String4, title: String4, url: String4, reason: String4 });
-var Output12 = Struct({
-  status: Literals(["nothing_to_sweep", "reported", "opened", "landed"]),
-  summary: String4,
-  landed: ArraySchema(Placed),
-  left: ArraySchema(Placed),
-  reportArtifactId: optional(String4),
-  changeRequest: optional(ChangeRequestResult)
-});
-var defaultAuthors = ["renovate[bot]", "dependabot[bot]"];
-var listing = (requests) => requests.map((request) => [
-  `### !${request.number} ${request.title}`,
-  `Branch \`${request.sourceBranch}\` at ${request.head}, ${request.url}`,
-  request.body
-].join(`
-
-`)).join(`
-
-`);
-var assessPrompt = (requests) => [
-  "These dependency updates are open. Read each one\u2019s changelog and breaking-change notes, and what in this repository uses it.",
-  listing(requests),
-  "Decide for each: batch when it is safe to land with the others; alone when it needs its own review, such as a breaking change that needs code changes; hold when it should not land now, saying why.",
-  "Say whether it bumps a major version. Change nothing."
-].join(`
-
-`);
-var batchPrompt = (requests, target) => [
-  `Bring these dependency updates onto this branch, which starts from ${target}: for each, merge \`origin/<branch>\` at the head named; Kitman fetched origin just before this Step, so do not fetch. Where lockfiles conflict, regenerate them with the package manager instead of hand-merging.`,
-  listing(requests),
-  "An update that cannot be brought in cleanly is dropped: leave it out and say why. Commit nothing yourself; Kitman pushes what you leave."
-].join(`
-
-`);
-var fixPrompt3 = (failed, applied) => [
-  `The batch of ${applied.map((number) => `!${number}`).join(", ")} fails these checks:`,
-  ...failed.checks.filter((check) => check.status === "failed").map((check) => `- ${check.name}: \`${check.command}\``),
-  "Fix what an update broke, the way its changelog says to. If an update cannot be fixed in a small change, take it back out and drop it with the reason. Commit nothing yourself."
-].join(`
-
-`);
-var supersedes = "Supersedes:";
-var supersededLine = (update) => `- !${update.number} ${update.title} (${update.url}) at ${update.head}`;
-var supersededIn = (body) => {
-  const after = body.split(supersedes)[1] ?? "";
-  const listed = after.split("Left for a person:")[0] ?? "";
-  return listed.split(`
-`).flatMap((line) => {
-    const found = /^- !(\S+) (.+) \((\S+)\) at (\S+)$/u.exec(line.trim());
-    return found === null ? [] : [
-      {
-        number: found[1] ?? "",
-        title: found[2] ?? "",
-        url: found[3] ?? "",
-        head: found[4] ?? "",
-        reason: "Verified in the batch"
-      }
-    ];
-  });
-};
-var closeSuperseded = (landing, batchUrl) => map8(forEach(landing, ({ head, ...update }) => map8(closeChangeRequest(`close:${update.number}`, {
-  number: update.number,
-  head,
-  note: `Landed in ${batchUrl} with the other dependency updates Sweep verified together.`
-}), (closed) => closed.head === undefined ? [] : [{ ...update, reason: `The bot pushed ${closed.head} after Sweep batched ${head}, so it stays open` }])), (moved) => moved.flat());
-var afterClosing = (landing, left, moved) => ({
-  landed: landing.flatMap(({ head: _head, ...update }) => moved.some((open) => open.number === update.number) ? [] : [update]),
-  left: [...left, ...moved]
-});
-var reportText = (landing, left, heading) => [
-  heading,
-  ...landing.length === 0 ? [] : ["Landing:", ...landing.map((update) => `- !${update.number} ${update.title}`)],
-  ...left.length === 0 ? [] : ["Left for a person:", ...left.map((update) => `- !${update.number} ${update.title}: ${update.reason}`)]
-].join(`
-`);
-var sweep_default = defineLoop({
-  id: "sweep",
-  version: "1.0.0",
-  title: "Sweep",
-  input: Input11,
-  output: Output12,
-  agents: { assessor: "investigator", implementer: "implementer" },
-  checkout: "write",
-  schedule: { rule: { frequency: "weekly", daysOfWeek: [1], hour: 6, minute: 0 }, timezone: "UTC" },
-  capabilities: ["agent_work", "verify", "change_request", "read_change_request", "merge_change_request"],
-  calls: () => [shepherd_default],
-  run: (input) => gen(function* () {
-    const authors = input.authors ?? defaultAuthors;
-    const [earlier] = (yield* ownChangeRequests("earlier")).changeRequests;
-    if (earlier !== undefined) {
-      const landed = yield* call("land", shepherd_default, {
-        changeRequestId: earlier.id,
-        merge: true,
-        ...input.branch === undefined ? undefined : { branch: input.branch }
-      });
-      const summary = `${earlier.url}, from an earlier Sweep, is still open; Sweep took it on instead of batching again: ${landed.status}. ${landed.reason}`;
-      const landing = supersededIn(earlier.body);
-      const settled = afterClosing(landing, [], landed.status === "merged" ? yield* closeSuperseded(landing, earlier.url) : []);
-      const stored = yield* artifact("report", {
-        kind: "sweep_report",
-        title: "Sweep",
-        text: reportText(settled.landed, settled.left, summary)
-      });
-      return {
-        status: landed.status === "merged" ? "landed" : "opened",
-        summary,
-        ...settled,
-        reportArtifactId: stored.artifactId,
-        changeRequest: { id: earlier.id, number: earlier.number, url: earlier.url }
-      };
-    }
-    const open = (yield* openChangeRequests("bots", { authors })).changeRequests;
-    if (open.length === 0)
-      return {
-        status: "nothing_to_sweep",
-        summary: "The bots have nothing open.",
-        landed: [],
-        left: []
-      };
-    const assessed = yield* agentWork("assess", { agent: "assessor", prompt: assessPrompt(open), output: Assessed });
-    const decisions = open.map((request) => {
-      const decided = assessed.updates.find((update) => update.number === request.number);
-      const placed = { number: request.number, title: request.title, url: request.url };
-      if (decided === undefined)
-        return { ...placed, decision: "hold", reason: "It was not assessed" };
-      if (decided.major && decided.decision === "batch")
-        return { ...placed, decision: "alone", reason: `A major version bump goes alone. ${decided.reason}` };
-      return { ...placed, decision: decided.decision, reason: decided.reason };
-    });
-    const notBatched = decisions.flatMap(({ decision, ...placed }) => decision === "batch" ? [] : [placed]);
-    const batch = decisions.filter((update) => update.decision === "batch");
-    const reported = (status, summary, left) => map8(artifact("report", { kind: "sweep_report", title: "Sweep", text: reportText([], left, summary) }), (stored) => ({ status, summary, landed: [], left, reportArtifactId: stored.artifactId }));
-    if (batch.length === 0)
-      return yield* reported("reported", "Nothing is safe to batch.", notBatched);
-    const now = (yield* openChangeRequests("bots:again", { authors })).changeRequests;
-    const toBatch = now.filter((request) => batch.some((update) => update.number === request.number));
-    const gone = batch.flatMap((update) => toBatch.some((request) => request.number === update.number) ? [] : [
-      {
-        number: update.number,
-        title: update.title,
-        url: update.url,
-        reason: "It was closed or merged while Sweep ran"
-      }
-    ]);
-    const target = input.branch ?? "the default branch";
-    let batched = yield* agentWork("batch", {
-      agent: "implementer",
-      prompt: batchPrompt(toBatch, target),
-      output: Batched
-    });
-    let checked = yield* verify("verify", {});
-    const maxFixRounds = input.maxFixRounds ?? 2;
-    const dropped = new Map(batched.dropped.map((drop) => [drop.number, drop.reason]));
-    for (let round = 1;!checked.passed && round <= maxFixRounds && batched.applied.length > 0; round++) {
-      batched = yield* agentWork(`fix:${round}`, {
-        agent: "implementer",
-        prompt: fixPrompt3(checked, batched.applied),
-        output: Batched
-      });
-      for (const drop of batched.dropped)
-        dropped.set(drop.number, drop.reason);
-      checked = yield* verify(`verify:${round}`, {});
-    }
-    const titled = (number) => toBatch.find((request) => request.number === number);
-    const droppedOut = toBatch.flatMap((request) => {
-      const reason = dropped.get(request.number) ?? (batched.applied.includes(request.number) ? undefined : "It was not brought onto the branch");
-      return reason === undefined ? [] : [{ number: request.number, title: request.title, url: request.url, reason }];
-    });
-    const left = [...notBatched, ...gone, ...droppedOut];
-    const landing = batched.applied.flatMap((number) => {
-      const request = titled(number);
-      return request === undefined ? [] : [{ number, title: request.title, url: request.url, head: request.head, reason: "Verified in the batch" }];
-    });
-    if (landing.length === 0)
-      return yield* reported("reported", "No update survived the batch.", left);
-    if (!checked.passed) {
-      const failing = checked.checks.filter((check) => check.status === "failed").map((check) => check.name);
-      return yield* reported("reported", `The batch still fails ${failing.join(", ")} after ${maxFixRounds} rounds of fixing.`, [...left, ...landing.map(({ head: _head, ...update }) => ({ ...update, reason: "The batch did not pass" }))]);
-    }
-    const opened = yield* changeRequest("change-request", {
-      title: `Update ${landing.length} ${landing.length === 1 ? "dependency" : "dependencies"}`,
-      body: [
-        batched.summary,
-        supersedes,
-        ...landing.map(supersededLine),
-        ...left.length === 0 ? [] : ["Left for a person:", ...left.map((update) => `- !${update.number} ${update.title}: ${update.reason}`)]
-      ].join(`
-
-`)
-    });
-    const landed = yield* call("land", shepherd_default, {
-      changeRequestId: opened.id,
-      merge: true,
-      ...input.branch === undefined ? undefined : { branch: input.branch }
-    });
-    const merged = landed.status === "merged";
-    const closed = afterClosing(landing, left, merged ? yield* closeSuperseded(landing, opened.url) : []);
-    const stored = yield* artifact("report", {
-      kind: "sweep_report",
-      title: "Sweep",
-      text: reportText(closed.landed, closed.left, `${opened.url}: ${landed.status}. ${landed.reason}`)
-    });
-    const settled = { ...closed, reportArtifactId: stored.artifactId, changeRequest: opened };
-    if (!merged)
-      return {
-        status: "opened",
-        summary: `${opened.url} is ${landed.status}: ${landed.reason}`,
-        ...settled
-      };
-    return {
-      status: "landed",
-      summary: `Landed ${closed.landed.length} in ${opened.url}`,
-      ...settled
-    };
-  })
-});
-
-// packages/loops/src/tidy.ts
-var Input12 = Struct({
-  revision: optional(String4),
-  branch: optional(String4),
-  repoBindingId: optional(String4),
-  words: optional(String4)
-});
-var Hint = Literals(["architecture", "simplification"]);
-var Candidate = Struct({
-  title: String4,
-  words: String4,
-  hint: Hint,
-  worth: String4
-});
-var Survey = Struct({
-  report: String4,
-  htmlReport: optional(RunFile),
-  candidates: ArraySchema(Candidate),
-  questions: ArraySchema(Struct({
-    question: String4,
-    recommended: String4,
-    why: String4
-  })).check(isMaxLength(3))
-});
-var Tidied = Struct({
-  improved: Boolean2,
-  hint: optional(Hint),
-  title: optional(String4),
-  summary: String4,
-  claims: ArraySchema(String4)
-});
-var Output13 = Struct({
-  status: Literals(["nothing_worth_it", "reported", "planned", "opened"]),
-  summary: String4,
-  reportArtifactId: optional(String4),
-  changeRequest: optional(ChangeRequestResult),
-  settled: optional(Boolean2),
-  unsettled: optional(ArraySchema(String4))
-});
-var hints = [
-  "Hints, not a sequence; pick what is worth most:",
-  "- architecture: deepen a shallow module, close a seam that leaks, or move behaviour to the data it uses; apply the deletion test (would deleting it make things simpler?).",
-  "- simplification: duplication, dead code, needless indirection or abstraction."
-].join(`
-`);
-var surveyPrompt = (words, answers) => [
-  `Survey ${words === undefined ? "the repository" : `this area: ${words}`} for the code-quality improvements worth a reviewer's time.`,
-  "You run the improve-codebase-architecture skill as a Kitman Step. Write its HTML report, then keep it on the Run with attach_file and cite it as htmlReport instead of opening it. Stop after the report: Kitman asks the person which candidate to take, so do not grill here.",
-  hints,
-  "List the candidates most valuable first, and none when nothing is worth it; a small or cosmetic change is not worth it.",
-  answers.length === 0 ? "Ask only what the code cannot tell you, such as intent or plans, and at most three questions. Keep each to the context and the question, and give the answer you would assume and why in one or two sentences." : `Your questions were answered:
-${answers.join(`
-`)}
-Ask nothing more.`,
-  "Change nothing. Return a report in Markdown."
-].join(`
-
-`);
-var tidyPrompt = (scope, words) => [
-  `Make the one code-quality improvement worth most ${scope}.`,
-  ...words === undefined ? [] : [`Look at: ${words}`],
-  hints,
-  "Keep behaviour exactly as it is, and keep the change small enough to review in one sitting. If nothing is worth changing, change nothing and set improved to false: that is a good outcome.",
-  "Commit nothing yourself: Kitman pushes what you leave in the workspace. Give the ChangeRequest a title and a summary, and list as claims what you believe but Kitman has not checked."
-].join(`
-
-`);
-var areaOf = (revision, branch) => `in the area of the change at ${revision}: only the files that \`git diff $(git merge-base origin/${branch ?? "HEAD"} ${revision}) ${revision}\` touches, and the files that change with them`;
-var tidy_default = defineLoop({
-  id: "tidy",
-  version: "1.0.0",
-  title: "Tidy",
-  input: Input12,
-  output: Output13,
-  agents: { implementer: "implementer", surveyor: "surveyor" },
-  checkout: "write",
-  capabilities: ["agent_work", "ask", "verify", "change_request"],
-  calls: () => [review_default, plan_default],
-  run: (input) => gen(function* () {
-    const start = input.revision ?? `origin/${input.branch ?? "HEAD"}`;
-    const tidy = (scope, words) => gen(function* () {
-      const improvement = yield* agentWork("tidy", {
-        agent: "implementer",
-        prompt: tidyPrompt(scope, words),
-        output: Tidied
-      });
-      if (!improvement.improved)
-        return { status: "nothing_worth_it", summary: improvement.summary };
-      const base = yield* verify("verify:base", { revision: start });
-      const head = yield* verify("verify", {});
-      const reviewed = yield* call("review", review_default, {
-        base: start,
-        head: head.revision,
-        outcome: "refactor",
-        claims: improvement.claims
-      });
-      const settled = settleRound({ findings: reviewed.findings, rebuttals: [], verdicts: reviewed.verdicts });
-      const decision = rallyStop({ round: 1, maxRounds: 1, settled });
-      const verdict = evidenceGate({ outcome: "refactor", base, head });
-      const unsettled = [
-        ...verdict.settled ? [] : verdict.reasons,
-        ...decision.stop ? unsettledItems(settled, decision) : []
-      ];
-      const opened = yield* changeRequest("change-request", {
-        title: improvement.title ?? "Tidy",
-        body: changeRequestBody({
-          summary: improvement.summary,
-          head,
-          claims: improvement.claims,
-          unsettled,
-          rounds: 1,
-          stopped: decision.stop ? decision.reason : "round_cap"
-        })
-      });
-      return {
-        status: "opened",
-        summary: improvement.summary,
-        changeRequest: opened,
-        settled: unsettled.length === 0,
-        unsettled
-      };
-    });
-    if (input.revision !== undefined)
-      return yield* tidy(areaOf(input.revision, input.branch), input.words);
-    let survey = yield* agentWork("survey", {
-      agent: "surveyor",
-      skill: "improve-codebase-architecture",
-      prompt: surveyPrompt(input.words, []),
-      output: Survey
-    });
-    if (survey.questions.length > 0) {
-      const answers = yield* forEach(survey.questions, (question, index) => map8(ask(`question:${index + 1}`, {
-        prompt: question.question,
-        freeText: true,
-        recommended: question.recommended,
-        recommendationReason: question.why,
-        default: "No answer; go by the code.",
-        timeout: "1 day"
-      }), (answer) => `- ${question.question} ${answer}`));
-      survey = yield* agentWork("survey:answered", {
-        agent: "surveyor",
-        skill: "improve-codebase-architecture",
-        prompt: surveyPrompt(input.words, answers),
-        output: Survey
-      });
-    }
-    const stored = yield* artifact("report", {
-      kind: "tidy_report",
-      title: "Tidy report",
-      text: survey.report,
-      ...survey.htmlReport === undefined ? undefined : { files: [survey.htmlReport] }
-    });
-    const [top] = survey.candidates;
-    if (top === undefined)
-      return {
-        status: "nothing_worth_it",
-        summary: "Nothing here is worth a reviewer\u2019s time.",
-        reportArtifactId: stored.artifactId
-      };
-    const answer = yield* ask("next", {
-      prompt: `Tidy found ${survey.candidates.length} worth doing, top: ${top.title}. ${top.worth}
-
-What next?`,
-      options: [
-        { value: "Plan it", description: "Plan files the candidates as Tasks." },
-        { value: "Tidy the top one now", description: "An agent makes the top one and opens a ChangeRequest." },
-        { value: "Done", description: "Keep the report and stop." }
-      ],
-      recommended: "Tidy the top one now",
-      recommendationReason: `The top one is worth a reviewer's time on its own: ${top.worth}`,
-      default: "Done",
-      timeout: "1 day"
-    });
-    const reported = { summary: `Top: ${top.title}`, reportArtifactId: stored.artifactId };
-    if (answer === "Done")
-      return { status: "reported", ...reported };
-    if (answer === "Plan it") {
-      yield* call("plan", plan_default, {
-        words: [
-          "Plan these code-quality improvements:",
-          ...survey.candidates.map((candidate) => `- ${candidate.title}: ${candidate.words}`),
-          survey.report
-        ].join(`
-
-`),
-        ...input.repoBindingId === undefined ? undefined : { repoBindingId: input.repoBindingId },
-        ...input.branch === undefined ? undefined : { branch: input.branch }
-      });
-      return { status: "planned", ...reported };
-    }
-    const synced = yield* syncBase("sync", {
-      agent: "implementer",
-      ...input.branch === undefined ? undefined : { target: input.branch }
-    });
-    if (synced.status === "conflict")
-      return {
-        status: "reported",
-        ...reported,
-        summary: `Top: ${top.title}. Bringing the branch up to date conflicts on ${synced.files.join(", ")}`
-      };
-    const tidied = yield* tidy("", `${top.title}: ${top.words}`);
-    return { ...tidied, reportArtifactId: stored.artifactId };
-  })
-});
-
-// packages/loops/src/index.ts
-var shippedLoops = {
-  build: build_default,
-  errand: errand_default,
-  "file-tasks": file_tasks_default,
-  hillclimb: hillclimb_default,
-  firewatch: firewatch_default,
-  plan: plan_default,
-  "project-update": project_update_default,
-  release: release_default,
-  research: research_default,
-  hindsight: hindsight_default,
-  review: review_default,
-  shepherd: shepherd_default,
-  sweep: sweep_default,
-  tidy: tidy_default
-};
-export {
-  build_default as build,
-  errand_default as errand,
-  file_tasks_default as fileTasks,
-  firewatch_default as firewatch,
-  hillclimb_default as hillclimb,
-  hindsight_default as hindsight,
-  plan_default as plan,
-  project_update_default as projectUpdate,
-  release_default as release,
-  research_default as research,
-  review_default as review,
-  shepherd_default as shepherd,
-  shippedLoops,
-  sweep_default as sweep,
-  tidy_default as tidy
-};