@kitman-sh/cli 0.0.0-stage → 0.6.0

package/dist/chunk-dsefng1v.js

@@ -0,0 +1,1085 @@
+// @bun
+import {
+  isString,
+  Service2,
+  fromInputUnsafe,
+  isZero,
+  seconds,
+  isLessThanOrEqualTo,
+  forEach,
+  succeed5,
+  gen,
+  map3,
+  as,
+  catchTag,
+  tapError,
+  ignore,
+  sleep,
+  fnUntraced,
+  logInfo,
+  optional,
+  Literal,
+  String2,
+  Boolean2,
+  Struct,
+  Record,
+  ArraySchema,
+  NonEmptyArray,
+  Union,
+  Literals,
+  Finite,
+  Int,
+  TaggedError2,
+  Json
+} from "./chunk-txyq8r41.js";
+import"./chunk-hrvcz0m4.js";
+import {
+  LoopOutcome,
+  defineLoop,
+  make2,
+  await_,
+  make3,
+  evidenceGate,
+  ChildFailed,
+  agentWork,
+  ask,
+  call,
+  waitFor,
+  verify,
+  PlanTickets,
+  planWaves,
+  ChangeRequestResult,
+  CreateTasksResult,
+  changeRequest,
+  writeBack,
+  artifact,
+  note,
+  comment,
+  createTasks,
+  integrationBranch,
+  mergeChangeRequest,
+  release2,
+  Finding,
+  MergedFinding,
+  Rebuttal,
+  RebuttalVerdict,
+  ScopeJudgement,
+  isBlocking,
+  mergeFindings,
+  settleRound,
+  rallyStop
+} from "./chunk-n32jhswz.js";
+
+// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workflow/DurableClock.js
+var TypeId = "~effect/workflow/DurableClock";
+var make = (options) => ({
+  [TypeId]: TypeId,
+  name: options.name,
+  duration: fromInputUnsafe(options.duration),
+  deferred: make2(`DurableClock/${options.name}`)
+});
+var EngineTag = /* @__PURE__ */ Service2("effect/workflow/WorkflowEngine");
+var InstanceTag = /* @__PURE__ */ Service2("effect/workflow/WorkflowEngine/WorkflowInstance");
+var sleep2 = /* @__PURE__ */ fnUntraced(function* (options) {
+  const duration = fromInputUnsafe(options.duration);
+  if (isZero(duration)) {
+    return;
+  }
+  const inMemoryThreshold = options.inMemoryThreshold !== undefined ? fromInputUnsafe(options.inMemoryThreshold) : defaultInMemoryThreshold;
+  if (isLessThanOrEqualTo(duration, inMemoryThreshold)) {
+    return yield* make3({
+      name: `DurableClock/${options.name}`,
+      execute: sleep(duration)
+    });
+  }
+  const engine = yield* EngineTag;
+  const instance = yield* InstanceTag;
+  const clock = make(options);
+  yield* engine.scheduleClock(instance.workflow, {
+    executionId: instance.executionId,
+    clock
+  });
+  return yield* await_(clock.deferred);
+});
+var defaultInMemoryThreshold = /* @__PURE__ */ seconds(60);
+
+// packages/loops/src/change-request-body.ts
+var unsettledItems = (settled, decision) => decision.unsettled.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.command}\` | ${entry.status}${entry.preExisting ? " (also fails on the default branch)" : ""} |`)
+].join(`
+`);
+var changeRequestBody = (build) => [
+  build.summary,
+  "## Evidence",
+  evidenceTable(build.head),
+  "## 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}`),
+  "## Review",
+  `${build.rounds} review round${build.rounds === 1 ? "" : "s"}; the rally stopped: ${build.stopped.replaceAll("_", " ")}.`
+].join(`
+
+`);
+
+// packages/loops/src/review.ts
+var seats = {
+  correctness: "Correctness: bugs, broken edge cases, data loss, security, and behaviour the change does not deliver.",
+  standards: "Standards: the repository's documented conventions, tests at the right seams, names, and needless code."
+};
+var Input = Struct({
+  changeRequestId: optional(String2),
+  base: optional(String2),
+  head: optional(String2),
+  rebuttals: optional(ArraySchema(Rebuttal)),
+  outcome: optional(LoopOutcome),
+  claims: optional(ArraySchema(String2))
+});
+var SeatOutput = Struct({
+  findings: ArraySchema(Finding),
+  verdicts: optional(ArraySchema(RebuttalVerdict)),
+  scope: optional(ScopeJudgement)
+});
+var Output = Struct({
+  findings: ArraySchema(MergedFinding),
+  verdicts: ArraySchema(RebuttalVerdict),
+  blocking: Boolean2,
+  artifactId: String2,
+  scope: optional(ScopeJudgement)
+});
+
+class ReviewTargetMissing extends TaggedError2()("ReviewTargetMissing", {
+  message: String2
+}) {
+}
+var targetOf = (input) => {
+  if (input.changeRequestId !== undefined)
+    return `ChangeRequest ${input.changeRequestId}. Read it with \`kitman.changeRequests.get("${input.changeRequestId}")\` through Kitman's MCP, fetch its source branch, and review its diff against its target branch.`;
+  if (input.base !== undefined && input.head !== undefined)
+    return `the change \`git diff ${input.base}...${input.head}\` in your checkout.`;
+  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 promptFor = (seat, focus, target, input) => [
+  `You are the ${seat} seat on a review panel. ${focus}`,
+  `Review ${target}`,
+  "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. Report nothing you have not checked in the code.",
+  ...seat === "correctness" ? [scopePrompt(input)] : [],
+  ...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 summaryOf = (findings) => findings.length === 0 ? "Kitman review: no findings." : [
+  `Kitman review: ${findings.length} finding${findings.length === 1 ? "" : "s"}.`,
+  ...findings.map((finding) => `- **${finding.severity}** \`${finding.id}\` ${finding.detail} _(${finding.seats.join(", ")})_`)
+].join(`
+`);
+var review_default = defineLoop({
+  id: "review",
+  title: "Review",
+  input: Input,
+  output: Output,
+  agents: { correctness: "reviewer", standards: "reviewer" },
+  checkout: "read",
+  capabilities: ["agent_work", "post_comment"],
+  run: (input) => gen(function* () {
+    const target = targetOf(input);
+    if (target === undefined)
+      return yield* new ReviewTargetMissing({ message: "Name a ChangeRequest, or both base and head revisions" });
+    const outputs = yield* forEach(Object.entries(seats), ([seat, focus]) => agentWork(`review:${seat}`, {
+      agent: seat,
+      prompt: promptFor(seat, focus, target, input),
+      output: SeatOutput
+    }).pipe(map3((output) => [seat, output])), { concurrency: "unbounded" });
+    const scope = outputs.find(([seat]) => seat === "correctness")?.[1].scope;
+    const findings = mergeFindings(Object.fromEntries(outputs.map(([seat, output]) => [seat, output.findings])));
+    const summary = summaryOf(findings);
+    const stored = yield* artifact("findings", {
+      kind: "review-findings",
+      title: "Review findings",
+      text: summary,
+      data: { findings }
+    });
+    if (input.changeRequestId !== undefined)
+      yield* comment("post", { changeRequestId: input.changeRequestId, body: summary });
+    return {
+      findings,
+      verdicts: outputs.flatMap(([, output]) => output.verdicts ?? []),
+      blocking: findings.some(isBlocking),
+      artifactId: stored.artifactId,
+      ...scope === undefined ? undefined : { scope }
+    };
+  })
+});
+
+// packages/loops/src/build.ts
+var Input2 = Struct({
+  words: optional(String2),
+  taskId: optional(String2),
+  repoBindingId: optional(String2),
+  branch: optional(String2),
+  revision: optional(String2),
+  outcome: optional(LoopOutcome),
+  maxRounds: optional(Int)
+});
+var Implemented = Struct({
+  title: String2,
+  summary: String2,
+  claims: ArraySchema(String2),
+  documented: optional(ArraySchema(String2)),
+  rollback: optional(String2)
+});
+var Reproduced = Struct({
+  check: String2,
+  summary: String2
+});
+var Fixed = Struct({
+  summary: String2,
+  claims: ArraySchema(String2),
+  rebuttals: ArraySchema(Rebuttal)
+});
+var Output2 = Struct({
+  changeRequest: ChangeRequestResult,
+  revision: String2,
+  tree: String2,
+  settled: Boolean2,
+  unsettled: ArraySchema(String2),
+  rounds: Int,
+  stopped: Literals(["settled", "dispute_stands", "findings_returned", "round_cap"])
+});
+
+class BuildTargetMissing extends TaggedError2()("BuildTargetMissing", {
+  message: String2
+}) {
+}
+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."
+};
+var implementPrompt = (task, outcome) => [
+  `Build ${task}`,
+  ...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".'
+].join(`
+
+`);
+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 findingLine = (finding) => `- **${finding.severity}** \`${finding.id}\` ${finding.detail}`;
+var fixPrompt = (settled) => [
+  "The review found these. Fix each, or rebut it with your reason if it is wrong; reviewers judge the rebuttals next round.",
+  ...settled.open.map(findingLine),
+  ...settled.standing.map((entry) => findingLine(entry.finding))
+].join(`
+`);
+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: ["correctness"]
+}));
+var blockingIds = (settled) => settled.open.filter(isBlocking).map((finding) => finding.id);
+var rally = (input) => gen(function* () {
+  const claims = [...input.claims];
+  let rebuttals = [];
+  let previous;
+  for (let round = 1;; round++) {
+    const head = yield* verify(`verify:${round}`, {});
+    const reviewed = yield* call(`review:${round}`, review_default, {
+      base: input.base,
+      head: head.revision,
+      ...rebuttals.length === 0 ? undefined : { rebuttals },
+      ...input.outcome === undefined ? undefined : { outcome: input.outcome },
+      claims: [...claims]
+    });
+    const settled = settleRound({
+      findings: [...reviewed.findings, ...scopeFindings(reviewed.scope)],
+      rebuttals,
+      verdicts: reviewed.verdicts
+    });
+    const decision = rallyStop({
+      round,
+      maxRounds: input.maxRounds,
+      settled,
+      ...previous === undefined ? undefined : { previous }
+    });
+    if (decision.stop)
+      return { round, head, settled, decision, claims, scope: reviewed.scope };
+    const fixed = yield* agentWork(`fix:${round}`, {
+      agent: "implementer",
+      prompt: fixPrompt(settled),
+      output: Fixed
+    });
+    claims.push(...fixed.claims);
+    rebuttals = fixed.rebuttals;
+    previous = blockingIds(settled);
+  }
+});
+var build_default = defineLoop({
+  id: "build",
+  title: "Build",
+  input: Input2,
+  output: Output2,
+  agents: { implementer: "implementer" },
+  checkout: "write",
+  offers: [{ id: "code-quality", title: "Improve code quality", loop: "code-quality" }],
+  capabilities: ["agent_work", "call", "verify", "change_request", "write_back"],
+  run: (input) => gen(function* () {
+    if (input.words === undefined && input.taskId === undefined)
+      return yield* new BuildTargetMissing({ message: "Give the words to build, or a Task" });
+    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 reproduced = outcome === "bug" ? yield* agentWork("reproduce", { agent: "implementer", prompt: reproducePrompt(task), output: Reproduced }) : undefined;
+    const base = outcome === "bug" ? yield* verify("verify:reproduction", {}) : outcome === "refactor" ? yield* verify("verify:base", {}) : undefined;
+    const implemented = yield* agentWork("implement", {
+      agent: "implementer",
+      prompt: implementPrompt(task, outcome),
+      output: Implemented
+    });
+    const last = yield* rally({
+      maxRounds: input.maxRounds ?? 3,
+      base: input.revision ?? `origin/${input.branch ?? "HEAD"}`,
+      outcome,
+      claims: implemented.claims
+    });
+    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 = [...verdict.settled ? [] : verdict.reasons, ...unsettledItems(last.settled, last.decision)];
+    const opened = yield* changeRequest("change-request", {
+      title: implemented.title,
+      body: changeRequestBody({
+        summary: implemented.summary,
+        head: last.head,
+        claims: last.claims,
+        unsettled,
+        rounds: last.round,
+        stopped: last.decision.reason
+      })
+    });
+    yield* writeBack("write-back", { milestone: "change_request_opened", changeRequestUrl: opened.url });
+    return {
+      changeRequest: opened,
+      revision: last.head.revision,
+      tree: last.head.tree,
+      settled: unsettled.length === 0,
+      unsettled,
+      rounds: last.round,
+      stopped: last.decision.reason
+    };
+  }).pipe(tapError(() => ignore(writeBack("write-back:failed", { milestone: "failed" }))))
+});
+
+// packages/loops/src/code-quality-pass.ts
+var CodeQualityPasses = ["architecture", "simplification"];
+var Pass = Literals(CodeQualityPasses);
+var PassInput = Struct({
+  pass: Pass,
+  revision: optional(String2),
+  branch: optional(String2),
+  repoBindingId: optional(String2),
+  words: optional(String2)
+});
+var Improved = Struct({
+  improved: Boolean2,
+  title: optional(String2),
+  summary: String2,
+  claims: ArraySchema(String2)
+});
+var PassOutput = Struct({
+  pass: Pass,
+  improved: Boolean2,
+  changeRequest: optional(ChangeRequestResult),
+  revision: optional(String2),
+  tree: optional(String2),
+  settled: optional(Boolean2),
+  unsettled: optional(ArraySchema(String2))
+});
+var passes = {
+  architecture: {
+    title: "Improve the architecture",
+    task: "Find the one architecture improvement worth most here: deepen a shallow module, close a seam that leaks, or move behaviour to the data it uses."
+  },
+  simplification: {
+    title: "Simplify the code",
+    task: "Find the code that is harder to read than it needs to be: duplication, dead code, needless indirection or abstraction, and simplify it."
+  }
+};
+var improvePrompt = (input) => [
+  passes[input.pass].task,
+  ...input.words === undefined ? [] : [`Look at: ${input.words}`],
+  "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.",
+  "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 code_quality_pass_default = defineLoop({
+  id: "code-quality-pass",
+  title: "Code Quality pass",
+  input: PassInput,
+  output: PassOutput,
+  agents: { implementer: "implementer" },
+  checkout: "write",
+  capabilities: ["agent_work", "call", "verify", "change_request"],
+  run: (input) => gen(function* () {
+    const improvement = yield* agentWork("improve", {
+      agent: "implementer",
+      prompt: improvePrompt(input),
+      output: Improved
+    });
+    if (!improvement.improved)
+      return { pass: input.pass, improved: false };
+    const start = input.revision ?? `origin/${input.branch ?? "HEAD"}`;
+    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 });
+    const settled = settleRound({ findings: reviewed.findings, rebuttals: [], verdicts: reviewed.verdicts });
+    const decision = rallyStop({ round: 1, maxRounds: 1, settled });
+    const stopped = decision.stop ? decision.reason : "round_cap";
+    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 ?? passes[input.pass].title,
+      body: changeRequestBody({
+        summary: improvement.summary,
+        head,
+        claims: improvement.claims,
+        unsettled,
+        rounds: 1,
+        stopped
+      })
+    });
+    return {
+      pass: input.pass,
+      improved: true,
+      changeRequest: opened,
+      revision: head.revision,
+      tree: head.tree,
+      settled: unsettled.length === 0,
+      unsettled
+    };
+  })
+});
+
+// packages/loops/src/code-quality.ts
+var Input3 = PassInput.mapFields(({ pass: _pass, ...fields }) => fields);
+var Output3 = Struct({
+  improvements: ArraySchema(PassOutput)
+});
+var code_quality_default = defineLoop({
+  id: "code-quality",
+  title: "Code Quality",
+  input: Input3,
+  output: Output3,
+  agents: {},
+  checkout: "read",
+  capabilities: code_quality_pass_default.capabilities,
+  run: (input) => gen(function* () {
+    const improvements = [];
+    for (const pass of CodeQualityPasses) {
+      const result = yield* call(pass, code_quality_pass_default, { pass, ...input });
+      if (result.improved)
+        improvements.push(result);
+    }
+    return { improvements };
+  })
+});
+
+// packages/loops/src/hello.ts
+var hello_default = defineLoop({
+  id: "hello",
+  title: "Hello",
+  input: Struct({ name: String2, napSeconds: optional(Finite) }),
+  output: Struct({ greeting: String2, mood: String2 }),
+  agents: {},
+  checkout: "none",
+  capabilities: ["ask"],
+  run: ({ name, napSeconds }) => gen(function* () {
+    const greeting = yield* make3({
+      name: "greet",
+      success: String2,
+      execute: as(logInfo("hello_greeted", name), `Hello, ${name}`)
+    });
+    const mood = yield* ask("mood", { prompt: `${greeting}. How are you?`, options: ["good", "tired"] });
+    yield* sleep2({ name: "nap", duration: `${napSeconds ?? 2} seconds`, inMemoryThreshold: 0 });
+    return { greeting, mood };
+  })
+});
+
+// packages/loops/src/incident.ts
+var Input4 = Struct({
+  alert: Record(String2, Json),
+  repoBindingId: optional(String2)
+});
+var Conclusion = Struct({
+  summary: String2,
+  cause: String2,
+  sources: NonEmptyArray(String2),
+  fix: optional(String2)
+});
+var Output4 = Struct({
+  conclusionArtifactId: String2,
+  fix: Literals(["none", "declined", "started"]),
+  changeRequestUrl: optional(String2)
+});
+var alertTitle = (alert) => {
+  const title = alert.title ?? alert.name ?? alert.summary;
+  return isString(title) ? title : "Incident";
+};
+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. Propose a fix only when the cause is in code Kitman can change."
+].join(`
+`);
+var conclusionText = (conclusion) => [
+  conclusion.summary,
+  `Cause: ${conclusion.cause}`,
+  "Sources:",
+  ...conclusion.sources.map((source) => `- ${source}`),
+  ...conclusion.fix === undefined ? [] : [`Fix: ${conclusion.fix}`]
+].join(`
+`);
+var incident_default = defineLoop({
+  id: "incident",
+  title: "Incident",
+  input: Input4,
+  output: Output4,
+  outcome: "investigation",
+  agents: { investigator: "investigator" },
+  checkout: "read",
+  when: [{ event: "monitoring.alert", input: { alert: "alert" } }],
+  capabilities: ["agent_work", "ask", "call"],
+  run: (input) => gen(function* () {
+    const conclusion = yield* agentWork("investigate", {
+      agent: "investigator",
+      prompt: investigatePrompt(input.alert),
+      output: Conclusion
+    });
+    const stored = yield* artifact("conclusion", {
+      kind: "investigation_conclusion",
+      title: alertTitle(input.alert),
+      text: conclusionText(conclusion),
+      data: { alert: input.alert, sources: conclusion.sources }
+    });
+    const conclusionArtifactId = stored.artifactId;
+    if (conclusion.fix === undefined)
+      return { conclusionArtifactId, fix: "none" };
+    const answer = yield* ask("start-fix", {
+      prompt: `${conclusion.summary}
+
+Start a Build that fixes it as a bug: ${conclusion.fix}?`,
+      options: ["Start a fix", "Not now"]
+    });
+    if (answer === "Not now")
+      return { conclusionArtifactId, fix: "declined" };
+    const fixed = yield* call("fix", build_default, {
+      words: `${conclusion.fix}
+
+${conclusionText(conclusion)}`,
+      ...input.repoBindingId === undefined ? undefined : { repoBindingId: input.repoBindingId },
+      outcome: "bug"
+    });
+    return { conclusionArtifactId, fix: "started", changeRequestUrl: fixed.changeRequest.url };
+  })
+});
+
+// packages/loops/src/plan.ts
+var Input5 = Struct({
+  words: String2,
+  repoBindingId: optional(String2),
+  branch: optional(String2)
+});
+var Grilled = Struct({
+  summary: String2,
+  decisions: ArraySchema(String2)
+});
+var Plan = Struct({
+  title: String2,
+  spec: String2,
+  tickets: PlanTickets,
+  outOfScope: ArraySchema(String2)
+});
+var Opinion = Struct({ summary: String2, concerns: ArraySchema(String2) });
+var TicketResult = Struct({
+  key: String2,
+  title: String2,
+  status: Literals(["merged", "failed", "skipped"]),
+  repoBindingId: optional(String2),
+  changeRequest: optional(ChangeRequestResult),
+  reason: optional(String2)
+});
+var Output5 = Struct({
+  title: String2,
+  outOfScope: ArraySchema(String2),
+  implemented: Boolean2,
+  tickets: ArraySchema(TicketResult),
+  deliveries: ArraySchema(ChangeRequestResult),
+  tasks: optional(CreateTasksResult.fields.tasks)
+});
+var menu = ["Implement now", "File as Tasks", "Second opinion", "Refine", "Finish"];
+var onConflict = ["Rebuild on the integration branch", "Skip"];
+var grillPrompt = (words) => [
+  `Plan this: ${words}`,
+  "Interview the user until you understand what they want: ask one question at a time with the Kitman MCP `ask` tool, and give options when the choices are clear. Ask about scope, constraints and what done looks like, not what you can read in the code.",
+  "Write no files. Summarize what you learned, and list each decision the user made."
+].join(`
+
+`);
+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. Set repoBindingId only when it changes another repository than the plan. Set outcome to the kind of change: feature, bug, refactor, docs, migration or investigation.";
+var planPrompt = (words, grilled) => [
+  `Write the spec and the tickets for: ${words}`,
+  `From the interview: ${grilled.summary}`,
+  ...grilled.decisions.map((decision) => `- ${decision}`),
+  ticketRules,
+  "List in outOfScope what the plan deliberately leaves out, one item each; each holds the Builds of its tickets.",
+  "Write no files: 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(`
+`)],
+  "## 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 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 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) => gen(function* () {
+  let head = start;
+  for (let attempt = 1;; attempt++) {
+    const suffix = attempt === 1 ? "" : `:${attempt}`;
+    const built = yield* call(`build:${ticket.key}${suffix}`, build_default, {
+      ...taskId === undefined ? { words: buildWords(ticket) } : { taskId },
+      repoBindingId: head.repoBindingId,
+      branch: head.branch,
+      revision: head.revision
+    }).pipe(catchTag("ChildFailed", (failure) => succeed5(failure)));
+    if (built instanceof ChildFailed)
+      return settled(ticket, { status: "failed", repoBindingId: head.repoBindingId, reason: built.reason });
+    const merged = yield* mergeChangeRequest(`merge:${ticket.key}${suffix}`, {
+      changeRequestId: built.changeRequest.id
+    });
+    const delivered = { repoBindingId: head.repoBindingId, changeRequest: built.changeRequest };
+    if (merged.status === "merged")
+      return settled(ticket, { status: "merged", ...delivered });
+    const choice = yield* ask(`conflict:${ticket.key}${suffix}`, {
+      prompt: `The ChangeRequest for ${ticket.key} (${built.changeRequest.url}) conflicts with ${head.branch}. Rebuild ${ticket.key} on the integration branch as it is now, or skip it and the tickets it blocks?`,
+      options: onConflict
+    });
+    if (choice === "Skip")
+      return settled(ticket, { status: "failed", ...delivered, reason: `It conflicted with ${head.branch}` });
+    head = yield* integrationBranch(`rebuild-from:${ticket.key}:${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) => gen(function* () {
+  const created = yield* createTasks("tasks", { tickets: plan.tickets });
+  const taskOf = new Map(created.tasks.map((task) => [task.key, task.taskId]));
+  const results = new Map;
+  const waves = yield* planWaves(plan.tickets);
+  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 (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 result of built)
+      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 };
+});
+var plan_default = defineLoop({
+  id: "plan",
+  title: "Plan",
+  input: Input5,
+  output: Output5,
+  agents: { planner: "planner", reviewer: "reviewer" },
+  checkout: "read",
+  capabilities: [
+    "agent_work",
+    "ask",
+    "call",
+    "verify",
+    "change_request",
+    "write_back",
+    "create_tasks",
+    "merge_change_request"
+  ],
+  run: (input) => gen(function* () {
+    const grilled = yield* agentWork("grill", { agent: "planner", prompt: grillPrompt(input.words), output: Grilled });
+    let plan = yield* agentWork("plan", { agent: "planner", prompt: planPrompt(input.words, grilled), output: Plan });
+    yield* storePlan(plan, "");
+    for (let round = 1;; round++) {
+      const choice = yield* ask(`next:${round}`, { prompt: `What next for the plan "${plan.title}"?`, options: menu });
+      switch (choice) {
+        case "Finish":
+          return { title: plan.title, outOfScope: plan.outOfScope, implemented: false, tickets: [], deliveries: [] };
+        case "Implement now":
+          return {
+            title: plan.title,
+            outOfScope: plan.outOfScope,
+            implemented: true,
+            ...yield* implement(input, plan)
+          };
+        case "File as Tasks": {
+          const filed = yield* createTasks(`file-tasks:${round}`, { tickets: plan.tickets });
+          return {
+            title: plan.title,
+            outOfScope: plan.outOfScope,
+            implemented: false,
+            tickets: [],
+            deliveries: [],
+            tasks: filed.tasks
+          };
+        }
+        case "Second opinion": {
+          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 });
+          plan = yield* agentWork(`refine-plan:${round}`, {
+            agent: "planner",
+            prompt: refinePrompt(plan, words),
+            output: Plan
+          });
+          yield* storePlan(plan, `:${round}`);
+          break;
+        }
+      }
+    }
+  })
+});
+
+// packages/loops/src/release.ts
+var Input6 = Struct({
+  tag: optional(String2),
+  revision: optional(String2),
+  deployEvent: optional(String2),
+  deployTimeoutMinutes: optional(Int)
+});
+var Drafted = Struct({
+  tag: String2,
+  title: String2,
+  notes: String2,
+  changeRequests: ArraySchema(String2)
+});
+var Output6 = Union([
+  Struct({ status: Literal("rejected"), tag: String2, notesArtifactId: String2 }),
+  Struct({
+    status: Literals(["deployed", "deploy_failed", "timed_out"]),
+    tag: String2,
+    notesArtifactId: String2,
+    revision: String2,
+    url: String2
+  })
+]);
+var draftPrompt = (tag) => [
+  "Draft the release notes for the ChangeRequests merged since the last release tag on the base branch.",
+  "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." : `The release is tagged ${tag}.`
+].join(`
+
+`);
+var reports = {
+  deployed: "deployed",
+  deploy_failed: "reported a failed deploy",
+  timed_out: "timed out waiting for the deploy"
+};
+var release_default = defineLoop({
+  id: "release",
+  title: "Release",
+  input: Input6,
+  output: Output6,
+  agents: { releaser: "releaser" },
+  checkout: "read",
+  capabilities: ["agent_work", "ask", "publish_release"],
+  run: (input) => gen(function* () {
+    const drafted = yield* agentWork("draft-notes", {
+      agent: "releaser",
+      prompt: draftPrompt(input.tag),
+      output: Drafted
+    });
+    const tag = input.tag ?? drafted.tag;
+    const notes = yield* artifact("notes", {
+      kind: "release_notes",
+      title: drafted.title,
+      text: drafted.notes,
+      data: { tag, changeRequests: drafted.changeRequests }
+    });
+    const approval = yield* ask("approve", {
+      prompt: `Release ${tag} with these notes?
+
+${drafted.notes}`,
+      options: ["Approve", "Reject"]
+    });
+    if (approval === "Reject")
+      return { status: "rejected", tag, notesArtifactId: notes.artifactId };
+    const released = yield* release2("tag", {
+      tag,
+      ...input.revision === undefined ? undefined : { revision: input.revision },
+      title: drafted.title,
+      notes: drafted.notes
+    });
+    const status = yield* waitFor("deploy", {
+      event: input.deployEvent ?? "deploy",
+      filter: { tag },
+      timeout: `${input.deployTimeoutMinutes ?? 60} minutes`
+    }).pipe(map3((deploy) => deploy.payload.status === "failed" ? "deploy_failed" : "deployed"), catchTag("WaitTimedOut", () => succeed5("timed_out")));
+    yield* artifact("report", {
+      kind: "release_report",
+      title: `${tag} ${reports[status]}`,
+      text: `${tag} at ${released.revision} ${reports[status]}. ${released.url}`,
+      data: { tag, status, revision: released.revision, url: released.url }
+    });
+    return { status, tag, notesArtifactId: notes.artifactId, revision: released.revision, url: released.url };
+  })
+});
+
+// packages/loops/src/research.ts
+var Input7 = Struct({
+  taskId: String2,
+  repoBindingId: optional(String2)
+});
+var Sources = NonEmptyArray(String2);
+var Report = Struct({
+  title: String2,
+  summary: String2,
+  findings: ArraySchema(Struct({ finding: String2, sources: Sources })),
+  sources: Sources,
+  openQuestions: ArraySchema(String2),
+  nextSteps: ArraySchema(String2)
+});
+var Output7 = Struct({ reportArtifactId: String2 });
+var prompt = [
+  "Research the question this Task asks, using the `research` skill. The Task's title, description, Acceptance Criteria and comments are in your context.",
+  "Cite primary sources for every finding: the code, official documentation, specifications and first-party APIs. Say what you read or ran and what it showed; separate what you established from what you suspect.",
+  "Return the report as your Output, with `title` set to the Task's title. Do not write it into the repository."
+].join(`
+
+`);
+var list = (items) => items.length === 0 ? ["None."] : items.map((item) => `- ${item}`);
+var reportMarkdown = (report) => [
+  `# ${report.title}`,
+  "",
+  report.summary,
+  "",
+  "## Findings",
+  "",
+  ...report.findings.flatMap(({ finding, sources }) => [`- ${finding}`, ...sources.map((source) => `  - ${source}`)]),
+  "",
+  "## Sources",
+  "",
+  ...list(report.sources),
+  "",
+  "## Open questions",
+  "",
+  ...list(report.openQuestions),
+  "",
+  "## Next steps",
+  "",
+  ...list(report.nextSteps)
+].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.", sources: ["apps/api/src/server.ts:20"] }],
+  sources: ["apps/api/src/server.ts:20"],
+  openQuestions: [],
+  nextSteps: []
+};
+var research_default = defineLoop({
+  id: "research",
+  title: "Research",
+  input: Input7,
+  output: Output7,
+  outcome: "investigation",
+  agents: { researcher: "researcher" },
+  checkout: "read",
+  capabilities: ["agent_work"],
+  checks: [{ name: "reports", script: { input: { taskId: "task-1" }, outputs: { research: sample } } }],
+  run: () => gen(function* () {
+    const report = yield* agentWork("research", { agent: "researcher", prompt, output: Report });
+    const { artifactId } = yield* artifact("report", {
+      kind: "research_report",
+      title: report.title,
+      text: reportMarkdown(report),
+      data: report
+    });
+    yield* note("summary", { text: report.summary, artifactId });
+    return { reportArtifactId: artifactId };
+  })
+});
+
+// packages/loops/src/index.ts
+var shippedLoops = {
+  build: build_default,
+  "code-quality": code_quality_default,
+  "code-quality-pass": code_quality_pass_default,
+  hello: hello_default,
+  incident: incident_default,
+  plan: plan_default,
+  release: release_default,
+  research: research_default,
+  review: review_default
+};
+export {
+  build_default as build,
+  code_quality_default as codeQuality,
+  code_quality_pass_default as codeQualityPass,
+  hello_default as hello,
+  incident_default as incident,
+  plan_default as plan,
+  release_default as release,
+  research_default as research,
+  review_default as review,
+  shippedLoops
+};