@kitman-sh/cli 0.10.52 → 0.10.54

package/dist/chunk-g7vk5tjp.js

@@ -0,0 +1,1109 @@
+// @bun
+import {
+  dual,
+  getOrElse,
+  Service2,
+  empty3,
+  add,
+  getOrUndefined2,
+  merge3,
+  TaggedClass,
+  TaggedError,
+  encode,
+  isSuccess2,
+  addFinalizerExit,
+  effectDiscard,
+  forEach,
+  promise,
+  tryPromise,
+  suspend3,
+  sync2,
+  void_3,
+  gen,
+  die3,
+  flatMap3,
+  andThen2,
+  tap2,
+  map8,
+  orDie,
+  context,
+  contextWith,
+  provideContext2,
+  provideService,
+  scoped,
+  acquireUseRelease,
+  uninterruptibleMask2,
+  annotateCurrentSpan,
+  withSpan,
+  fnUntraced,
+  makeFormatterStandardSchemaV1,
+  transform,
+  declare,
+  is,
+  encodeEffect,
+  isSchema,
+  optionalKey,
+  optional,
+  Literal,
+  Never,
+  Null,
+  String4,
+  Boolean2,
+  Void,
+  Struct,
+  Record,
+  ArraySchema,
+  NonEmptyArray,
+  Union,
+  Literals,
+  decodeTo2,
+  tag,
+  TaggedStruct,
+  makeFilter,
+  isPattern,
+  Finite,
+  isGreaterThanOrEqualTo,
+  isLessThanOrEqualTo,
+  Int,
+  isMinLength,
+  isMaxLength,
+  Defect,
+  fromJsonString,
+  Cause,
+  Class2,
+  TaggedError2,
+  toEquivalence,
+  toCodecJson,
+  Json
+} from "./chunk-61k67vxh.js";
+import {
+  guard
+} from "./chunk-4kssrezn.js";
+import {
+  currentTimeMillis,
+  WebCrypto,
+  SafeJson,
+  AgentSandboxNetwork,
+  AgentEfforts,
+  AgentCapabilities,
+  LoopDataSchemaRef,
+  LoopVersion,
+  ProgramLoop,
+  AgentFallback,
+  ProgramWorkUnit,
+  MeasureEvidence,
+  CatchUp,
+  RunFileRefused,
+  runFileContentType,
+  sha256Hasher,
+  put,
+  setHeaders,
+  bodyUint8Array,
+  filterStatusOk,
+  HttpClient,
+  KitName,
+  KitDigest,
+  KitSetup,
+  RunnerRpcError
+} from "./chunk-m32wb6t0.js";
+import {
+  runForEach,
+  FileSystem
+} from "./chunk-xgwjcq4z.js";
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/crypto/internal/webCrypto.js
+var subtleUnavailable = () => new Error("crypto.subtle is unavailable; browsers expose it only in secure contexts");
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/crypto/internal/digest.js
+var webCryptoDigest = (crypto, algorithm, data) => {
+  const implementation = algorithm.implementation;
+  if (implementation !== undefined) {
+    return sync2(() => implementation(data));
+  }
+  return suspend3(() => {
+    const subtle = crypto?.subtle;
+    if (subtle === undefined)
+      return die3(subtleUnavailable());
+    return promise(async () => new Uint8Array(await subtle.digest(algorithm.name, data)));
+  });
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/crypto/Digest.js
+var sha256 = {
+  name: "SHA-256",
+  outputLength: 32,
+  implementation: undefined
+};
+
+// packages/core/src/schedule.ts
+var ScheduleFrequency = ["daily", "weekly"];
+var ScheduleMisfirePolicies = ["skip", "fire_once", "catch_up"];
+var ScheduleOverlapPolicies = ["allow", "skip", "coalesce"];
+var ScheduleVersionStatuses = ["draft", "published", "disabled", "archived"];
+var ScheduleCalendarRule = Struct({
+  frequency: Literals(ScheduleFrequency),
+  hour: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(23)),
+  minute: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(59)),
+  second: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(59))),
+  daysOfWeek: optionalKey(ArraySchema(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(6))).check(isMinLength(1), isMaxLength(7)))
+});
+var ScheduleCronRule = Struct({
+  cron: String4.check(isMinLength(9), isMaxLength(200), isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
+});
+var ScheduleRule = Union([ScheduleCalendarRule, ScheduleCronRule]);
+var cronBounds = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7]
+];
+function cronField(field, [min, max]) {
+  const values = new Set;
+  for (const part of field.split(",")) {
+    const match = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+    if (match === null)
+      return;
+    const from = match[1] === "*" ? min : Number(match[2]);
+    const to = match[1] === "*" ? max : match[3] === undefined ? match[4] === undefined ? from : max : Number(match[3]);
+    const step = match[4] === undefined ? 1 : Number(match[4]);
+    if (from < min || to > max || from > to || step < 1)
+      return;
+    for (let value = from;value <= to; value += step)
+      values.add(value);
+  }
+  return values;
+}
+function parseCron(cron) {
+  const fields = cron.split(" ");
+  const [minutes, hours, days, months, weekdays] = fields.map((field, index) => cronField(field, cronBounds[index] ?? [0, 0]));
+  if (fields.length !== 5 || !minutes || !hours || !days || !months || !weekdays)
+    return;
+  return {
+    minutes,
+    hours,
+    days,
+    months,
+    weekdays: new Set([...weekdays].map((value) => value % 7)),
+    dayRestricted: !(fields[2] ?? "").startsWith("*"),
+    weekdayRestricted: !(fields[4] ?? "").startsWith("*")
+  };
+}
+function isScheduleRule(value) {
+  return guard(ScheduleRule)(value) && (!("cron" in value) || parseCron(value.cron) !== undefined);
+}
+var ScheduleVersion = Struct({
+  contractVersion: Literal("schedule.v1"),
+  id: String4.check(isMinLength(1)),
+  scheduleId: String4.check(isMinLength(1)),
+  workspaceId: String4.check(isMinLength(1)),
+  teamId: optionalKey(String4.check(isMinLength(1))),
+  loopId: optionalKey(String4.check(isMinLength(1))),
+  name: optionalKey(String4.check(isMinLength(1), isMaxLength(200))),
+  version: Int.check(isGreaterThanOrEqualTo(1)),
+  status: Literals(ScheduleVersionStatuses),
+  timezone: String4.check(isMinLength(1), isMaxLength(80)),
+  rule: ScheduleRule,
+  misfirePolicy: Literals(ScheduleMisfirePolicies),
+  overlapPolicy: Literals(ScheduleOverlapPolicies),
+  maxCatchUp: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(200)),
+  misfireGraceSeconds: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(604800))),
+  inputSchemaRef: optionalKey(LoopDataSchemaRef),
+  input: optionalKey(SafeJson),
+  createdAt: String4.check(isMinLength(1))
+});
+var zones = new Map;
+var resolvedLocalDateTimes = new Map;
+
+// packages/core/src/kit-declarations.ts
+var LoopCapabilities = [
+  "agent_work",
+  "ask",
+  "call",
+  "verify",
+  "change_request",
+  "write_back",
+  "post_comment",
+  "create_tasks",
+  "merge_change_request",
+  "approve_change_request",
+  "publish_release",
+  "read_transcripts",
+  "read_change_request",
+  "measure",
+  "claim",
+  "propose",
+  "read_project",
+  "draft_update"
+];
+var JsonObject = Record(String4, Json);
+var SecretName = String4.check(isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
+var EventFilterValue = Union([String4, Finite, Boolean2, Null]);
+var LoopManifest = Struct({
+  id: String4,
+  title: String4,
+  version: optionalKey(LoopVersion),
+  input: JsonObject,
+  output: JsonObject,
+  outcome: optionalKey(Literals(["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"])),
+  agents: Record(String4, String4),
+  checkout: Literals(["none", "read", "write"]),
+  when: ArraySchema(Struct({
+    event: String4,
+    filter: optionalKey(Record(String4, Union([EventFilterValue, ArraySchema(EventFilterValue)]))),
+    input: Record(String4, String4),
+    values: optionalKey(JsonObject)
+  })),
+  offers: ArraySchema(Struct({
+    id: String4,
+    title: String4,
+    loop: String4,
+    from: optionalKey(String4)
+  })),
+  capabilities: ArraySchema(Literals(LoopCapabilities)),
+  secrets: optionalKey(ArraySchema(SecretName)),
+  network: optionalKey(AgentSandboxNetwork),
+  schedule: optionalKey(Struct({ rule: ScheduleRule, timezone: String4 }))
+});
+var LoopDetail = Struct({
+  id: String4,
+  resolved: optionalKey(Struct({
+    ...ProgramLoop.fields,
+    agents: LoopManifest.fields.agents,
+    when: LoopManifest.fields.when,
+    schedule: optionalKey(Struct({
+      rule: ScheduleRule,
+      timezone: String4,
+      on: Boolean2,
+      nextRunAt: optionalKey(String4)
+    }))
+  }))
+});
+var AgentDeclaration = Struct({
+  extends: optionalKey(String4),
+  instructions: optionalKey(String4),
+  harness: optionalKey(String4),
+  model: optionalKey(String4),
+  effort: optionalKey(Literals(AgentEfforts)),
+  fallbacks: optionalKey(ArraySchema(AgentFallback)),
+  tools: optionalKey(ArraySchema(Literals(AgentCapabilities))),
+  skills: optionalKey(ArraySchema(String4.check(isMinLength(1)))),
+  network: optionalKey(Union([Struct({ hosts: ArraySchema(String4) }), Literal("open")])),
+  sandbox: optionalKey(Literal("docker"))
+});
+var scheduleFields = {
+  name: String4.check(isMinLength(1)),
+  loop: String4,
+  team: optionalKey(String4),
+  input: optionalKey(JsonObject),
+  timezone: String4,
+  misfire: optionalKey(Literals(ScheduleMisfirePolicies)),
+  overlap: optionalKey(Literals(ScheduleOverlapPolicies))
+};
+var ScheduleDeclaration = Union([
+  Struct({
+    ...scheduleFields,
+    cron: String4.check(makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
+  }),
+  Struct({
+    ...scheduleFields,
+    rule: declare((value) => isScheduleRule(value), {
+      expected: "a Schedule rule: frequency daily or weekly, hour, minute, and optionally second and daysOfWeek"
+    })
+  })
+]);
+var CarriedKit = Struct({
+  name: KitName,
+  version: String4.check(isMinLength(1)),
+  setup: KitDigest,
+  loops: ArraySchema(String4),
+  agents: ArraySchema(String4)
+});
+var KitDeclarations = Struct({
+  loops: ArraySchema(LoopManifest),
+  agents: Record(String4, AgentDeclaration),
+  schedules: optionalKey(Record(String4, ScheduleDeclaration)),
+  carried: optionalKey(ArraySchema(CarriedKit))
+});
+var sameLoop = toEquivalence(LoopManifest);
+var sameAgent = toEquivalence(AgentDeclaration);
+
+// packages/sdk/src/loop/define.ts
+var LoopOutcome = Literals([
+  "feature",
+  "bug",
+  "refactor",
+  "investigation",
+  "docs",
+  "migration",
+  "performance"
+]);
+class ManifestInvalid extends TaggedError2()("ManifestInvalid", {
+  loop: String4,
+  message: String4
+}) {
+}
+var JsonObjectSchema = Record(String4, Json);
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/workflow/internal/crypto.js
+var encoder = /* @__PURE__ */ new TextEncoder;
+var makeHashDigest = (original) => WebCrypto.use((crypto) => map8(webCryptoDigest(crypto, sha256, encoder.encode(original)), (bytes) => encode(bytes).slice(0, 32)));
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/workflow/Workflow.js
+var TypeId = "~effect/workflow/Workflow";
+var EngineTag = /* @__PURE__ */ Service2("effect/workflow/WorkflowEngine");
+var InstanceTag = /* @__PURE__ */ Service2("effect/workflow/WorkflowEngine/WorkflowInstance");
+var makeExecutionIdFromPayload = (self, payload) => makeHashDigest(`${self._tag.length}:${self._tag}:${self.idempotencyKey(payload)}`);
+var Proto = {
+  [TypeId]: TypeId,
+  annotate(tag, value) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      annotations: add(this.annotations, tag, value),
+      idempotencyKey: this.idempotencyKey,
+      suspendedRetrySchedule: this.suspendedRetrySchedule
+    });
+  },
+  annotateMerge(context) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      annotations: merge3(this.annotations, context),
+      idempotencyKey: this.idempotencyKey,
+      suspendedRetrySchedule: this.suspendedRetrySchedule
+    });
+  },
+  execute(fields, opts) {
+    return suspend3(() => {
+      const payload = this.payloadSchema.make(fields);
+      const run = flatMap3(EngineTag, (engine) => flatMap3(makeExecutionIdFromPayload(this, payload), (executionId) => andThen2(annotateCurrentSpan({
+        executionId
+      }), engine.execute(this, {
+        executionId,
+        payload,
+        discard: opts?.discard,
+        detached: opts?.detached,
+        suspendedRetrySchedule: this.suspendedRetrySchedule
+      }))));
+      return opts?.discard ? run : withPendingActivity(run);
+    }).pipe(withSpan(`${this._tag}.execute`, {}, {
+      captureStackTrace: false
+    }));
+  },
+  poll(executionId) {
+    return flatMap3(EngineTag, (engine) => engine.poll(this, executionId)).pipe(withSpan(`${this._tag}.poll`, {
+      attributes: {
+        executionId
+      }
+    }, {
+      captureStackTrace: false
+    }));
+  },
+  interrupt(executionId) {
+    return flatMap3(EngineTag, (engine) => engine.interrupt(this, executionId)).pipe(withSpan(`${this._tag}.interrupt`, {
+      attributes: {
+        executionId
+      }
+    }, {
+      captureStackTrace: false
+    }));
+  },
+  resume(executionId) {
+    return flatMap3(EngineTag, (engine) => engine.resume(this, executionId)).pipe(withSpan(`${this._tag}.resume`, {
+      attributes: {
+        executionId
+      }
+    }, {
+      captureStackTrace: false
+    }));
+  },
+  toLayer(execute) {
+    return effectDiscard(flatMap3(EngineTag, (engine) => engine.register(this, execute)));
+  },
+  executionId(payload) {
+    return flatMap3(orDie(this.payloadSchema.makeEffect(payload)), (payload) => makeExecutionIdFromPayload(this, payload));
+  },
+  withCompensation: (...args) => withCompensation(...args)
+};
+var makeProto = (options) => {
+  function Workflow() {}
+  Object.setPrototypeOf(Workflow, Proto);
+  Object.assign(Workflow, options);
+  return Workflow;
+};
+var make = (tag, options) => makeProto({
+  _tag: tag,
+  payloadSchema: isSchema(options.payload) ? options.payload : Struct(options.payload),
+  successSchema: options.success ?? Void,
+  errorSchema: options.error ?? Never,
+  annotations: options.annotations ?? empty3(),
+  idempotencyKey: options.idempotencyKey,
+  suspendedRetrySchedule: options.suspendedRetrySchedule
+});
+var ResultTypeId = "~effect/workflow/Workflow/Result";
+class Suspended extends (/* @__PURE__ */ Class2("effect/workflow/Workflow/Suspended")({
+  _tag: /* @__PURE__ */ tag("Suspended"),
+  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Cause(Never, /* @__PURE__ */ Defect())),
+  failed: /* @__PURE__ */ optional(Boolean2)
+})) {
+  [ResultTypeId] = ResultTypeId;
+}
+var PendingActivityRegistration = /* @__PURE__ */ Service2("effect/workflow/Workflow/PendingActivityRegistration");
+var registerActivityUnsafe = (instance) => {
+  const state = instance.activityState;
+  if (state.count === 0)
+    state.latch.closeUnsafe();
+  state.count++;
+  return {
+    instance,
+    state: "pending"
+  };
+};
+var releaseActivityUnsafe = (registration) => {
+  if (registration.state === "released")
+    return;
+  registration.state = "released";
+  const state = registration.instance.activityState;
+  state.count--;
+  if (state.count === 0)
+    state.latch.openUnsafe();
+};
+var withPendingActivity = (effect) => contextWith((context) => {
+  const instance = getOrUndefined2(context, InstanceTag);
+  if (!instance)
+    return effect;
+  return acquireUseRelease(sync2(() => registerActivityUnsafe(instance)), (registration) => provideService(effect, PendingActivityRegistration, registration), (registration) => sync2(() => releaseActivityUnsafe(registration)));
+});
+var addFinalizer = /* @__PURE__ */ fnUntraced(function* (f) {
+  const instance = yield* InstanceTag;
+  const services = yield* context();
+  yield* addFinalizerExit(instance.scope, (exit) => instance.abandoned ? void_3 : provideContext2(f(exit), services));
+});
+var withCompensation = /* @__PURE__ */ dual(2, (effect, compensation) => uninterruptibleMask2((restore) => tap2(restore(effect), (value) => addFinalizer((exit) => isSuccess2(exit) ? void_3 : compensation(value, exit.cause)))));
+// packages/sdk/src/loop/evidence.ts
+var EvidenceCheck = Struct({
+  name: String4,
+  command: String4,
+  status: Literals(["passed", "failed"]),
+  preExisting: Boolean2,
+  durationMs: Finite,
+  evidenceId: String4,
+  outputTail: optionalKey(String4),
+  suggested: optionalKey(Boolean2)
+});
+var VerifyResult = Struct({
+  revision: String4,
+  tree: String4,
+  passed: Boolean2,
+  unchanged: optionalKey(Boolean2),
+  checks: ArraySchema(EvidenceCheck)
+});
+
+// packages/sdk/src/loop/steps.ts
+class StepFailed extends TaggedError2()("StepFailed", {
+  step: String4,
+  reason: String4
+}) {
+  get message() {
+    return `Step "${this.step}" failed: ${this.reason}`;
+  }
+}
+
+class OutputInvalid extends TaggedError2()("OutputInvalid", {
+  step: String4,
+  message: String4
+}) {
+}
+
+class QuestionRefused extends TaggedError2()("QuestionRefused", {
+  step: String4,
+  answer: String4,
+  options: ArraySchema(String4)
+}) {
+}
+
+class WaitTimedOut extends TaggedError2()("WaitTimedOut", {
+  step: String4,
+  event: String4
+}) {
+}
+
+class ChangeRequestClosed extends TaggedError2()("ChangeRequestClosed", {
+  step: String4,
+  merged: Boolean2
+}) {
+}
+
+class ChildFailed extends TaggedError2()("ChildFailed", {
+  step: String4,
+  loop: String4,
+  reason: String4
+}) {
+  get message() {
+    return `Child Run of "${this.loop}" for Step "${this.step}" failed: ${this.reason}`;
+  }
+}
+
+class CapabilityDenied extends TaggedError2()("CapabilityDenied", {
+  step: String4,
+  capability: Literals(LoopCapabilities),
+  secret: optionalKey(String4)
+}) {
+  get message() {
+    return this.secret === undefined ? `Step "${this.step}" needs the "${this.capability}" capability, which this Run was not granted` : `Step "${this.step}" names the Secret "${this.secret}", which its Loop does not declare`;
+  }
+}
+
+class DuplicateStep extends TaggedError2()("DuplicateStep", {
+  step: String4
+}) {
+}
+
+class InputInvalid extends TaggedError2()("InputInvalid", {
+  loop: String4,
+  message: String4
+}) {
+}
+var LoopEvent = Struct({ type: String4, payload: Record(String4, Json) });
+
+class LoopRun extends Service2()("@kitman-sh/sdk/loop/LoopRun") {
+}
+
+class LoopHost extends Service2()("@kitman-sh/sdk/loop/LoopHost") {
+}
+// packages/sdk/src/loop/plan.ts
+var PlanTicket = Struct({
+  key: String4,
+  title: String4,
+  body: String4,
+  acceptanceCriteria: ArraySchema(String4),
+  repoBindingId: optional(String4),
+  blockedBy: ArraySchema(String4),
+  outcome: optional(LoopOutcome)
+});
+var cycleMessage = (keys) => `These tickets block each other in a cycle, so none can start: ${keys.join(", ")}`;
+var ticketsProblem = (tickets) => {
+  const keys = new Set;
+  for (const ticket of tickets) {
+    if (keys.has(ticket.key))
+      return `Two tickets have the key "${ticket.key}"`;
+    keys.add(ticket.key);
+  }
+  for (const ticket of tickets)
+    for (const blocker of ticket.blockedBy)
+      if (!keys.has(blocker))
+        return `Ticket "${ticket.key}" is blocked by "${blocker}", which is not a ticket`;
+  const { blocked } = wavesOf(tickets);
+  return blocked.length === 0 ? undefined : cycleMessage(blocked);
+};
+var PlanTickets = ArraySchema(PlanTicket).check(makeFilter((tickets) => ticketsProblem(tickets) ?? true));
+
+class BlockingCycle extends TaggedError2()("BlockingCycle", {
+  tickets: ArraySchema(String4)
+}) {
+  get message() {
+    return cycleMessage(this.tickets);
+  }
+}
+var byRepoBinding = (left, right) => (left.repoBindingId ?? "").localeCompare(right.repoBindingId ?? "");
+function wavesOf(tickets) {
+  const placed = new Set;
+  const waves = [];
+  let left = tickets;
+  while (left.length > 0) {
+    const ready = left.filter((ticket) => ticket.blockedBy.every((blocker) => placed.has(blocker)));
+    if (ready.length === 0)
+      break;
+    for (const ticket of ready)
+      placed.add(ticket.key);
+    waves.push(ready.toSorted(byRepoBinding));
+    left = left.filter((ticket) => !placed.has(ticket.key));
+  }
+  return { waves, blocked: left.map((ticket) => ticket.key) };
+}
+
+// packages/sdk/src/loop/activities.ts
+var ChangeRequestRequest = Struct({
+  title: String4,
+  body: String4,
+  integration: optional(String4)
+});
+var ChangeRequestResult = Struct({ id: String4, number: String4, url: String4 });
+var WriteBackMilestones = ["started", "change_request_opened", "merged", "failed"];
+var WriteBackRequest = Struct({
+  milestone: optional(Literals(WriteBackMilestones)),
+  changeRequestUrl: optional(String4)
+});
+var RunFile = Struct({ runFile: String4 }).pipe(decodeTo2(Struct({ id: String4 }), transform({
+  decode: ({ runFile }) => ({ id: runFile }),
+  encode: ({ id }) => ({ runFile: id })
+})));
+var FileRequest = Struct({ path: String4, caption: optional(String4) });
+var ArtifactRequest = Struct({
+  kind: String4,
+  title: String4,
+  text: String4,
+  data: optional(Json),
+  files: optional(ArraySchema(RunFile))
+});
+var ArtifactResult = Struct({ artifactId: String4 });
+var NoteRequest = Struct({ text: String4, artifactId: optional(String4) });
+var CreateTasksRequest = Struct({
+  tickets: ArraySchema(PlanTicket),
+  projectId: optionalKey(String4)
+});
+var CreateTasksResult = Struct({
+  tasks: ArraySchema(Struct({ key: String4, taskId: String4 }))
+});
+var AlertTaskRequest = Struct({
+  fingerprint: String4.check(isMinLength(1), isMaxLength(400)),
+  title: String4,
+  windowHours: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo(720)),
+  resolved: optionalKey(Boolean2),
+  priority: optionalKey(Literals(["urgent", "high", "medium", "low"]))
+});
+var AlertTaskResult = Struct({
+  taskId: optionalKey(String4),
+  created: Boolean2,
+  resolved: optionalKey(Boolean2),
+  joined: optionalKey(Struct({ kind: Literals(["run", "recent"]), runId: String4 }))
+});
+var IntegrationBranchRequest = Struct({ repoBindingId: optional(String4) });
+var IntegrationBranch = Struct({
+  repoBindingId: String4,
+  branch: String4,
+  revision: String4
+});
+var MergeChangeRequestRequest = Struct({
+  changeRequestId: String4,
+  head: optionalKey(String4)
+});
+var MergeResult = Union([
+  Struct({ status: Literal("merged"), revision: String4 }),
+  Struct({ status: Literal("conflict") }),
+  Struct({ status: Literal("moved"), head: String4 })
+]);
+var ApproveChangeRequestRequest = Struct({
+  changeRequestId: String4,
+  head: String4,
+  summary: String4,
+  review: optionalKey(String4),
+  carries: optionalKey(String4)
+});
+var ApproveChangeRequestResult = Union([
+  Struct({ approved: Literal(true), reviewId: String4 }),
+  Struct({ approved: Literal(false), reason: String4 })
+]);
+var CloseChangeRequestRequest = Struct({
+  number: String4,
+  head: String4,
+  note: String4
+});
+var CloseChangeRequestResult = Struct({
+  closed: Boolean2,
+  head: optionalKey(String4)
+});
+var RerunPipelineRequest = Union([
+  Struct({ changeRequestId: String4 }),
+  Struct({ ref: String4, all: optionalKey(Boolean2) })
+]);
+var RerunPipelineResult = Struct({ head: String4, pipelines: Int });
+var ReportPipelineRequest = Struct({ changeRequestId: String4, verification: String4 });
+var ReportPipelineResult = Struct({
+  head: String4,
+  status: Literals(["success", "failed"])
+});
+var CommentRequest = Struct({
+  changeRequestId: String4,
+  body: String4,
+  threadId: optionalKey(String4),
+  summary: optionalKey(String4),
+  anchors: optionalKey(ArraySchema(Struct({
+    file: String4,
+    line: Int.check(isGreaterThanOrEqualTo(1)),
+    body: String4.check(isMinLength(1))
+  })))
+});
+var ReleaseRequest = Struct({
+  tag: String4,
+  revision: optional(String4),
+  title: String4,
+  notes: String4
+});
+var ReleaseResult = Struct({ tag: String4, revision: String4, url: String4 });
+var ChangeRequestReadRequest = Struct({ changeRequestId: String4 });
+var PipelineJob = Struct({
+  name: String4,
+  status: Literals(["running", "success", "failed", "skipped"]),
+  url: optional(String4),
+  logTail: optional(String4)
+});
+var PipelineStatus = Struct({
+  head: String4,
+  status: Literals(["none", "running", "success", "failed", "canceled"]),
+  source: Literals(["forge", "reported"]),
+  jobs: ArraySchema(PipelineJob),
+  readAt: optionalKey(String4),
+  runnerChecks: optionalKey(ArraySchema(String4))
+});
+var ReviewThread = Struct({
+  id: String4,
+  path: optional(String4),
+  line: optional(Int),
+  outdated: optional(Boolean2),
+  comments: ArraySchema(Struct({ author: optional(String4), body: String4 }))
+});
+var ReviewThreads = Struct({ threads: ArraySchema(ReviewThread) });
+var OpenChangeRequestsRequest = Struct({ authors: NonEmptyArray(String4) });
+var OpenChangeRequest = Struct({
+  number: String4,
+  title: String4,
+  body: String4,
+  url: String4,
+  author: String4,
+  sourceBranch: String4,
+  head: String4
+});
+var OpenChangeRequests = Struct({ changeRequests: ArraySchema(OpenChangeRequest) });
+var OwnChangeRequest = Struct({
+  id: String4,
+  number: String4,
+  url: String4,
+  title: String4,
+  sourceBranch: String4,
+  body: String4
+});
+var OwnChangeRequests = Struct({ changeRequests: ArraySchema(OwnChangeRequest) });
+var TranscriptPoint = Struct({
+  runId: String4,
+  stepAttemptId: String4,
+  sequence: Int
+});
+var TranscriptsRequest = Struct({
+  days: Int.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo(31))
+});
+var TranscriptsResult = Struct({
+  runs: ArraySchema(Struct({
+    runId: String4,
+    loopId: String4,
+    status: optional(Literals(["completed", "failed", "canceled", "expired"])),
+    teamId: optional(String4),
+    failure: optional(String4),
+    retried: optional(Boolean2),
+    entries: ArraySchema(Struct({ stepAttemptId: String4, sequence: Int, kind: String4, text: String4 }))
+  }))
+});
+var Citations = NonEmptyArray(TranscriptPoint);
+var ProposeRequest = Union([
+  Struct({
+    kind: Literal("memory"),
+    teamId: String4,
+    content: String4,
+    citations: Citations
+  }),
+  Struct({
+    kind: Literal("task"),
+    title: String4,
+    description: String4,
+    teamId: optional(String4),
+    key: optionalKey(String4.check(isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/), isMaxLength(80))),
+    citations: Citations
+  })
+]);
+var ProposeResult = Struct({
+  kind: Literals(["memory", "task"]),
+  id: String4,
+  matched: optionalKey(Boolean2)
+});
+var Health = Literals(["on_track", "at_risk", "off_track"]);
+var ProjectActivityRequest = Struct({ projectId: String4 });
+var ProjectActivityResult = Struct({
+  project: Struct({ id: String4, name: String4 }),
+  health: optional(Health),
+  since: optional(String4),
+  runs: ArraySchema(Struct({
+    runId: String4,
+    loopId: String4,
+    status: String4,
+    taskKey: optional(String4),
+    taskTitle: optional(String4),
+    summary: optional(String4),
+    entries: ArraySchema(Struct({ stepAttemptId: String4, sequence: Int, kind: String4, text: String4 }))
+  })),
+  taskChanges: ArraySchema(Struct({ taskKey: String4, title: String4, change: String4, at: String4 }))
+});
+var DraftUpdateRequest = Struct({
+  projectId: String4,
+  health: Health,
+  note: String4,
+  writtenFrom: Struct({
+    runs: Int,
+    taskChanges: Int,
+    since: optional(String4)
+  })
+});
+var DraftUpdateResult = Struct({ id: String4 });
+
+class ChangeRequestActivity extends Service2()("@kitman-sh/sdk/loop/ChangeRequestActivity") {
+}
+
+class WriteBackActivity extends Service2()("@kitman-sh/sdk/loop/WriteBackActivity") {
+}
+
+class ArtifactActivity extends Service2()("@kitman-sh/sdk/loop/ArtifactActivity") {
+}
+
+class FileActivity extends Service2()("@kitman-sh/sdk/loop/FileActivity") {
+}
+
+class NoteActivity extends Service2()("@kitman-sh/sdk/loop/NoteActivity") {
+}
+
+class CommentActivity extends Service2()("@kitman-sh/sdk/loop/CommentActivity") {
+}
+
+class CreateTasksActivity extends Service2()("@kitman-sh/sdk/loop/CreateTasksActivity") {
+}
+
+class AlertTaskActivity extends Service2()("@kitman-sh/sdk/loop/AlertTaskActivity") {
+}
+
+class IntegrationBranchActivity extends Service2()("@kitman-sh/sdk/loop/IntegrationBranchActivity") {
+}
+
+class MergeChangeRequestActivity extends Service2()("@kitman-sh/sdk/loop/MergeChangeRequestActivity") {
+}
+
+class ReleaseActivity extends Service2()("@kitman-sh/sdk/loop/ReleaseActivity") {
+}
+
+class TranscriptsActivity extends Service2()("@kitman-sh/sdk/loop/TranscriptsActivity") {
+}
+
+class ProposeActivity extends Service2()("@kitman-sh/sdk/loop/ProposeActivity") {
+}
+
+class ProjectActivityActivity extends Service2()("@kitman-sh/sdk/loop/ProjectActivityActivity") {
+}
+
+class DraftUpdateActivity extends Service2()("@kitman-sh/sdk/loop/DraftUpdateActivity") {
+}
+
+class ChangeRequestReadActivity extends Service2()("@kitman-sh/sdk/loop/ChangeRequestReadActivity") {
+}
+// packages/sdk/src/loop/measure.ts
+var MetricStats = Struct({
+  samples: Finite,
+  median: Finite,
+  mean: Finite,
+  min: Finite,
+  max: Finite,
+  stdev: Finite
+});
+var MeasureVerdict = Literals(["gain", "no_gain", "guardrail_regressed", "too_noisy"]);
+var Measurement = Struct({
+  verdict: MeasureVerdict,
+  reason: String4,
+  metrics: ArraySchema(Struct({
+    name: String4,
+    role: Literals(["primary", "guardrail"]),
+    direction: Literals(["lower", "higher"]),
+    base: MetricStats,
+    head: MetricStats,
+    change: Finite,
+    noise: Finite
+  })),
+  suggestion: optional(String4),
+  evidence: MeasureEvidence
+});
+var floors = new WeakMap;
+
+// packages/sdk/src/loop/test-loop.ts
+var LoopJournal = Struct({
+  activities: Record(String4, Json),
+  deferreds: Record(String4, Json)
+});
+
+class ScriptedFailure extends TaggedClass("ScriptedFailure") {
+}
+// packages/sdk/src/loop/review.ts
+var Severity = Literals(["blocker", "major", "minor"]);
+var Finding = Struct({
+  severity: Severity,
+  file: String4,
+  line: Int,
+  detail: String4
+});
+var MergedFinding = Struct({
+  id: String4,
+  ...Finding.fields,
+  seats: ArraySchema(String4)
+});
+var Rebuttal = Struct({ findingId: String4, reason: String4 });
+var RebuttalVerdict = Struct({ findingId: String4, accepted: Boolean2 });
+var ScopeJudgement = Struct({ met: Boolean2, unmet: ArraySchema(String4) });
+// packages/sdk/src/loop/check.ts
+class CheckFailed extends TaggedError2()("CheckFailed", {
+  loop: String4,
+  check: String4,
+  reason: String4
+}) {
+  get detail() {
+    return `Check "${this.check}": ${this.reason}`;
+  }
+  get message() {
+    return `Loop "${this.loop}": ${this.detail}`;
+  }
+}
+
+class StepNamedTwice extends TaggedError2()("StepNamedTwice", {
+  loop: String4,
+  check: String4,
+  step: String4
+}) {
+  get detail() {
+    return `Check "${this.check}": Step "${this.step}" is named twice`;
+  }
+  get message() {
+    return `Loop "${this.loop}": ${this.detail}`;
+  }
+}
+
+class ReplayDiverged extends TaggedError2()("ReplayDiverged", {
+  loop: String4,
+  check: String4,
+  first: ArraySchema(String4),
+  replay: ArraySchema(String4),
+  rerun: ArraySchema(String4)
+}) {
+  get detail() {
+    const steps = (names) => names.join(", ") || "no Steps";
+    return `Check "${this.check}": its replay from the journal diverged; it took ${steps(this.first)} and then ${steps(this.replay)}${this.rerun.length > 0 ? `, running ${this.rerun.join(", ")} again` : ""}. Keep effects and randomness inside Activities.`;
+  }
+  get message() {
+    return `Loop "${this.loop}": ${this.detail}`;
+  }
+}
+var LoopCheckError = Union([CheckFailed, StepNamedTwice, ReplayDiverged]);
+// packages/sdk/src/loop/sync.ts
+var UpToDate = Struct({ status: Literal("up_to_date") });
+var Conflict = Struct({
+  status: Literal("conflict"),
+  files: NonEmptyArray(String4),
+  reason: String4
+});
+var merged = {
+  status: Literal("merged"),
+  settled: ArraySchema(String4)
+};
+var SyncAnswer = Union([UpToDate, Struct(merged), Conflict]);
+var BaseSync = Union([
+  UpToDate,
+  Struct({ ...merged, catchUp: optionalKey(CatchUp) }),
+  Conflict
+]);
+// packages/sdk/src/loop/continuing.ts
+var Continuing = Struct({
+  changeRequestId: String4,
+  number: String4,
+  url: String4,
+  branch: String4,
+  targetBranch: String4,
+  revision: optional(String4),
+  lastRunId: optional(String4),
+  lastRunStatus: optional(String4),
+  lastRunSummary: optional(String4)
+});
+// packages/sdk/src/program/engine.ts
+class JournalWriteFailed extends TaggedError("JournalWriteFailed") {
+  get message() {
+    return `Journal write failed: ${this.cause.message}`;
+  }
+}
+var JournalEntries = Record(String4, Json);
+var isSuspended = is(Suspended);
+var emptyWorkflow = make("kitman-loop/none", { payload: {}, idempotencyKey: () => "none" });
+var replayStatuses = new Set([401, 403, 409, 429]);
+var isRunnerRpcError = is(RunnerRpcError);
+var isRunFileRefused = is(RunFileRefused);
+var issues = makeFormatterStandardSchemaV1();
+var put2 = (target, contentType, body) => gen(function* () {
+  const response = yield* (yield* HttpClient).execute(put(target.url).pipe(bodyUint8Array(body, contentType), setHeaders(target.headers ?? {})));
+  return (yield* filterStatusOk(response)).headers.etag ?? "";
+});
+var readRange = (path, offset, size) => scoped(gen(function* () {
+  const file = yield* (yield* FileSystem).open(path);
+  return getOrElse(yield* file.readAlloc(size, { position: BigInt(offset) }), () => new Uint8Array);
+}));
+var partUrlMarginMillis = 60000;
+var uploadParts = (files, path, contentType, fileId, upload) => forEach(upload.parts, (part) => gen(function* () {
+  const now = yield* currentTimeMillis;
+  const fresh = Date.parse(part.expiresAt) - now > partUrlMarginMillis ? part : (yield* files.runFileParts({ fileId, partNumbers: [part.partNumber] }))[0] ?? part;
+  const body = yield* readRange(path, (part.partNumber - 1) * upload.partSize, upload.partSize);
+  return { partNumber: part.partNumber, etag: yield* put2(fresh, contentType, body) };
+}));
+var uploadRunFile = (files, file) => gen(function* () {
+  const fs = yield* FileSystem;
+  const contentType = runFileContentType(file.name);
+  const byteSize = Number((yield* fs.stat(file.path)).size);
+  const hash = sha256Hasher();
+  yield* runForEach(fs.stream(file.path), (chunk) => sync2(() => hash.update(chunk)));
+  const { file: slotted, upload } = yield* files.createRunFile({
+    step: file.step,
+    name: file.name,
+    ...file.caption === undefined ? undefined : { caption: file.caption },
+    contentType,
+    byteSize,
+    sha256: hash.digest("hex")
+  });
+  if (upload === undefined)
+    return slotted;
+  return yield* upload.kind === "single" ? readRange(file.path, 0, byteSize).pipe(flatMap3((body) => put2(upload, contentType, body)), andThen2(files.completeRunFile({ fileId: slotted.id }))) : flatMap3(uploadParts(files, file.path, contentType, slotted.id, upload), (parts) => files.completeRunFile({ fileId: slotted.id, parts }));
+});
+var programLease = (work) => ({
+  workUnitId: work.id,
+  leaseOwnerId: work.lease.leaseOwnerId,
+  runnerReplicaId: work.lease.runnerReplicaId,
+  leaseId: work.lease.leaseId,
+  attempt: work.lease.attempt,
+  fencingToken: work.lease.fencingToken,
+  capacitySlot: work.lease.capacitySlot
+});
+var rpcRunFiles = (rpc, lease) => ({
+  createRunFile: (file) => rpc.createRunFile({ lease, ...file }),
+  runFileParts: (request) => map8(rpc.runFileParts({ lease, ...request, partNumbers: [...request.partNumbers] }), ({ parts }) => parts),
+  completeRunFile: ({ parts, ...request }) => rpc.completeRunFile({ lease, ...request, ...parts === undefined ? undefined : { parts: [...parts] } })
+});
+
+// packages/sdk/src/program/host.ts
+var describeFlag = "--kitman-describe";
+var DescribedKit = Struct({
+  name: String4,
+  version: String4,
+  loops: ArraySchema(LoopManifest),
+  agents: Record(String4, Json),
+  schedules: optionalKey(Record(String4, Json)),
+  setup: optionalKey(KitSetup)
+});
+var Described = Union([
+  TaggedStruct("Described", { kits: ArraySchema(DescribedKit) }),
+  TaggedStruct("Refused", { error: Union([ManifestInvalid, LoopCheckError]) })
+]);
+var encodeDescribed = encodeEffect(fromJsonString(toCodecJson(Described)));
+
+class ProgramRefused extends TaggedError2()("ProgramRefused", { reason: String4 }) {
+  get message() {
+    return this.reason;
+  }
+}
+var programHostsEnv = "KITMAN_PROGRAM_HOSTS";
+var undeclaredHostsEnv = "KITMAN_UNDECLARED_HOSTS";
+var redirectStatuses = new Set([301, 302, 303, 307, 308]);
+var readStdin = tryPromise(() => Bun.stdin.text());
+var isWorkUnit = guard(ProgramWorkUnit);
+
+export { AgentDeclaration, KitDeclarations, uploadRunFile, programLease, rpcRunFiles, describeFlag, Described, programHostsEnv, undeclaredHostsEnv };