@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-kdb1cbnx.js

@@ -1,1273 +0,0 @@
-// @bun
-import {
-  dual,
-  hasProperty,
-  Prototype,
-  isNone,
-  Service,
-  empty,
-  add,
-  getOrUndefined2,
-  get,
-  merge,
-  Reference,
-  fromInputUnsafe,
-  toMillis,
-  TaggedClass,
-  hasInterruptsOnly,
-  combine,
-  squash,
-  hasInterrupts,
-  isSuccess2,
-  addFinalizerExit,
-  effectDiscard,
-  min,
-  exponential,
-  spaced,
-  while_,
-  setInputType,
-  promise,
-  succeed5,
-  suspend,
-  sync,
-  void_2,
-  callback,
-  gen,
-  fail4,
-  failCause2,
-  die3,
-  try_,
-  yieldNow,
-  flatMap2,
-  andThen,
-  tap,
-  map3,
-  catch_,
-  mapError,
-  orDie,
-  retry,
-  sandbox,
-  matchEffect,
-  context,
-  contextWith,
-  provideContext,
-  provideService,
-  acquireUseRelease,
-  onExit,
-  interruptible,
-  uninterruptibleMask,
-  annotateCurrentSpan,
-  withSpan,
-  fnUntraced,
-  getCurrent,
-  encode2,
-  transform,
-  encodeBase64Url,
-  decodeBase64UrlString,
-  transform2,
-  declare,
-  decodeUnknownEffect,
-  decodeEffect,
-  decodeSync,
-  encodeUnknownEffect,
-  encodeEffect,
-  encodeSync,
-  isSchema,
-  optionalKey,
-  optional,
-  Literal,
-  Never,
-  Unknown,
-  Null,
-  String2,
-  Boolean2,
-  Void,
-  Struct,
-  Record,
-  Tuple,
-  ArraySchema,
-  NonEmptyArray,
-  Union,
-  Literals,
-  decodeTo,
-  tag,
-  makeFilter,
-  isPattern,
-  Finite,
-  isGreaterThanOrEqualTo,
-  isLessThanOrEqualTo2,
-  Int,
-  isMinLength,
-  isMaxLength,
-  Defect,
-  fromJsonString,
-  Cause,
-  Exit,
-  Class,
-  TaggedError2,
-  toEquivalence,
-  toJsonSchemaDocument,
-  toCodecJson,
-  Json,
-  guard,
-  SafeJson,
-  relativePathPattern,
-  skillNamePattern,
-  AgentSandboxNetwork,
-  AgentEfforts,
-  LoopDataSchemaRef,
-  ProgramLoop,
-  KitKinds
-} from "./chunk-3gxahgnq.js";
-
-// 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), isLessThanOrEqualTo2(23)),
-  minute: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59)),
-  second: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59))),
-  daysOfWeek: optionalKey(ArraySchema(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(6))).check(isMinLength(1), isMaxLength(7)))
-});
-var ScheduleCronRule = Struct({
-  cron: String2.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: String2.check(isMinLength(1)),
-  scheduleId: String2.check(isMinLength(1)),
-  workspaceId: String2.check(isMinLength(1)),
-  teamId: optionalKey(String2.check(isMinLength(1))),
-  loopId: optionalKey(String2.check(isMinLength(1))),
-  name: optionalKey(String2.check(isMinLength(1), isMaxLength(200))),
-  version: Int.check(isGreaterThanOrEqualTo(1)),
-  status: Literals(ScheduleVersionStatuses),
-  timezone: String2.check(isMinLength(1), isMaxLength(80)),
-  rule: ScheduleRule,
-  misfirePolicy: Literals(ScheduleMisfirePolicies),
-  overlapPolicy: Literals(ScheduleOverlapPolicies),
-  maxCatchUp: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(200)),
-  misfireGraceSeconds: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(604800))),
-  inputSchemaRef: optionalKey(LoopDataSchemaRef),
-  input: optionalKey(SafeJson),
-  createdAt: String2.check(isMinLength(1))
-});
-var zones = new Map;
-var resolvedLocalDateTimes = new Map;
-
-// packages/core/src/package-declarations.ts
-var LoopCapabilities = [
-  "agent_work",
-  "ask",
-  "call",
-  "verify",
-  "change_request",
-  "write_back",
-  "post_comment",
-  "create_tasks",
-  "merge_change_request",
-  "publish_release",
-  "read_transcripts",
-  "propose",
-  "read_project",
-  "draft_update"
-];
-var JsonObject = Record(String2, Json);
-var recordKeyedBy = (pattern, value) => Record(String2, value).check(makeFilter((record) => {
-  const bad = Object.keys(record).find((key) => !new RegExp(pattern).test(key));
-  return bad === undefined ? true : `${JSON.stringify(bad)} is not a valid name or relative path`;
-}));
-var SecretName = String2.check(isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
-var EventFilterValue = Union([String2, Finite, Boolean2, Null]);
-var LoopManifest = Struct({
-  id: String2,
-  title: String2,
-  input: JsonObject,
-  output: JsonObject,
-  outcome: optionalKey(Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"])),
-  agents: Record(String2, String2),
-  checkout: Literals(["none", "read", "write"]),
-  when: ArraySchema(Struct({
-    event: String2,
-    filter: optionalKey(Record(String2, Union([EventFilterValue, ArraySchema(EventFilterValue)]))),
-    input: Record(String2, String2)
-  })),
-  offers: ArraySchema(Struct({ id: String2, title: String2, loop: String2 })),
-  capabilities: ArraySchema(Literals(LoopCapabilities)),
-  secrets: optionalKey(ArraySchema(SecretName)),
-  network: optionalKey(AgentSandboxNetwork),
-  schedule: optionalKey(Struct({ rule: ScheduleRule, timezone: String2 }))
-});
-var LoopDetail = Struct({
-  id: String2,
-  resolved: optionalKey(Struct({
-    ...ProgramLoop.fields,
-    agents: LoopManifest.fields.agents,
-    when: LoopManifest.fields.when,
-    schedule: optionalKey(Struct({
-      rule: ScheduleRule,
-      timezone: String2,
-      on: Boolean2,
-      nextRunAt: optionalKey(String2)
-    }))
-  }))
-});
-var AgentDeclaration = Struct({
-  extends: optionalKey(String2),
-  instructions: optionalKey(String2),
-  harness: optionalKey(String2),
-  model: optionalKey(String2),
-  effort: optionalKey(Literals(AgentEfforts)),
-  kits: optionalKey(ArraySchema(String2)),
-  network: optionalKey(Union([Struct({ hosts: ArraySchema(String2) }), Literal("open")])),
-  sandbox: optionalKey(Literal("docker"))
-});
-var scheduleFields = {
-  name: String2.check(isMinLength(1)),
-  loop: String2,
-  team: optionalKey(String2),
-  input: optionalKey(JsonObject),
-  timezone: String2,
-  misfire: optionalKey(Literals(ScheduleMisfirePolicies)),
-  overlap: optionalKey(Literals(ScheduleOverlapPolicies))
-};
-var ScheduleDeclaration = Union([
-  Struct({
-    ...scheduleFields,
-    cron: String2.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 AuthoredKitDeclaration = Struct({
-  name: String2.check(isMinLength(1)),
-  kind: optionalKey(Literals(KitKinds)),
-  description: optionalKey(String2),
-  context: String2,
-  skills: optionalKey(recordKeyedBy(skillNamePattern, recordKeyedBy(relativePathPattern, String2)))
-});
-var KitInstallationDeclaration = Struct({
-  source: String2.check(isMinLength(1)),
-  version: optionalKey(String2)
-});
-var KitAssignmentDeclaration = Struct({
-  kit: String2.check(isMinLength(1)),
-  workspace: optionalKey(Literals(["default", "mandatory"])),
-  teams: optionalKey(ArraySchema(String2))
-});
-var KitDeclaration = Union([
-  KitInstallationDeclaration,
-  KitAssignmentDeclaration,
-  AuthoredKitDeclaration
-]);
-var PackageDeclarations = Struct({
-  loops: ArraySchema(LoopManifest),
-  agents: Record(String2, AgentDeclaration),
-  schedules: optionalKey(Record(String2, ScheduleDeclaration)),
-  kits: optionalKey(Record(String2, KitDeclaration))
-});
-var sameLoop = toEquivalence(LoopManifest);
-var sameAgent = toEquivalence(AgentDeclaration);
-
-// packages/sdk/src/loop/define.ts
-var LoopOutcome = Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"]);
-var defineLoop = (definition) => definition;
-
-class ManifestInvalid extends TaggedError2()("ManifestInvalid", {
-  loop: String2,
-  message: String2
-}) {
-}
-var jsonSchemaOf = (loop, schema) => try_({
-  try: () => toJsonSchemaDocument(schema),
-  catch: (error) => new ManifestInvalid({ loop, message: `Schema has no JSON Schema: ${String(error)}` })
-}).pipe(flatMap2((document) => decodeUnknownEffect(JsonObjectSchema)({ ...document.schema, $defs: document.definitions }).pipe(mapError((error) => new ManifestInvalid({ loop, message: error.message })))));
-var JsonObjectSchema = Record(String2, Json);
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workflow/internal/crypto.js
-var makeHashDigest = (original) => map3(promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(original))), (buffer) => {
-  const data = new Uint8Array(buffer);
-  let hexString = "";
-  for (let i = 0;i < 16; i++) {
-    hexString += data[i].toString(16).padStart(2, "0");
-  }
-  return hexString;
-});
-
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workflow/Workflow.js
-var TypeId = "~effect/workflow/Workflow";
-var EngineTag = /* @__PURE__ */ Service("effect/workflow/WorkflowEngine");
-var InstanceTag = /* @__PURE__ */ Service("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: merge(this.annotations, context),
-      idempotencyKey: this.idempotencyKey,
-      suspendedRetrySchedule: this.suspendedRetrySchedule
-    });
-  },
-  execute(fields, opts) {
-    return suspend(() => {
-      const payload = this.payloadSchema.make(fields);
-      const run = flatMap2(EngineTag, (engine) => flatMap2(makeExecutionIdFromPayload(this, payload), (executionId) => andThen(annotateCurrentSpan({
-        executionId
-      }), engine.execute(this, {
-        executionId,
-        payload,
-        discard: opts?.discard,
-        suspendedRetrySchedule: this.suspendedRetrySchedule
-      }))));
-      return opts?.discard ? run : withPendingActivity(run);
-    }).pipe(withSpan(`${this._tag}.execute`, {}, {
-      captureStackTrace: false
-    }));
-  },
-  poll(executionId) {
-    return flatMap2(EngineTag, (engine) => engine.poll(this, executionId)).pipe(withSpan(`${this._tag}.poll`, {
-      attributes: {
-        executionId
-      }
-    }, {
-      captureStackTrace: false
-    }));
-  },
-  interrupt(executionId) {
-    return flatMap2(EngineTag, (engine) => engine.interrupt(this, executionId)).pipe(withSpan(`${this._tag}.interrupt`, {
-      attributes: {
-        executionId
-      }
-    }, {
-      captureStackTrace: false
-    }));
-  },
-  resume(executionId) {
-    return flatMap2(EngineTag, (engine) => engine.resume(this, executionId)).pipe(withSpan(`${this._tag}.resume`, {
-      attributes: {
-        executionId
-      }
-    }, {
-      captureStackTrace: false
-    }));
-  },
-  toLayer(execute) {
-    return effectDiscard(flatMap2(EngineTag, (engine) => engine.register(this, execute)));
-  },
-  executionId(payload) {
-    return flatMap2(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 ?? empty(),
-  idempotencyKey: options.idempotencyKey,
-  suspendedRetrySchedule: options.suspendedRetrySchedule
-});
-var ResultTypeId = "~effect/workflow/Workflow/Result";
-var isResult = (u) => hasProperty(u, ResultTypeId);
-class Suspended extends (/* @__PURE__ */ Class("effect/workflow/Workflow/Suspended")({
-  _tag: /* @__PURE__ */ tag("Suspended"),
-  cause: /* @__PURE__ */ optional(/* @__PURE__ */ Cause(Never, /* @__PURE__ */ Defect()))
-})) {
-  [ResultTypeId] = ResultTypeId;
-}
-var wrapActivityResult = (effect, isSuspend) => contextWith((context) => {
-  const instance = get(context, InstanceTag);
-  return acquireUseRelease(sync(() => adoptActivityUnsafe(context, instance) ?? registerActivityUnsafe(instance)), () => effect, (registration, exit) => {
-    releaseActivityUnsafe(registration);
-    const isSuspended = isSuccess2(exit) && isSuspend(exit.value);
-    if (isSuccess2(exit) && isResult(exit.value) && exit.value._tag === "Suspended" && exit.value.cause) {
-      instance.cause = instance.cause ? combine(instance.cause, exit.value.cause) : exit.value.cause;
-    }
-    return isSuspended && instance.activityState.count > 0 ? waitForZero(instance) : void_2;
-  });
-});
-var PendingActivityRegistration = /* @__PURE__ */ Service("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 adoptActivityUnsafe = (context, instance) => {
-  const pending = getOrUndefined2(context, PendingActivityRegistration);
-  if (!pending || pending.instance !== instance) {
-    return;
-  }
-  if (pending.state !== "pending") {
-    throw new Error("Workflow.wrapActivityResult: pending child registration has already been consumed");
-  }
-  pending.state = "adopted";
-  return 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(sync(() => registerActivityUnsafe(instance)), (registration) => provideService(effect, PendingActivityRegistration, registration), (registration) => sync(() => releaseActivityUnsafe(registration)));
-});
-var waitForZero = /* @__PURE__ */ fnUntraced(function* (instance) {
-  const state = instance.activityState;
-  while (true) {
-    if (state.count > 0) {
-      yield* state.latch.await;
-      yield* yieldNow;
-      continue;
-    }
-    yield* yieldNow;
-    if (state.count === 0)
-      return;
-  }
-});
-var addFinalizer = /* @__PURE__ */ fnUntraced(function* (f) {
-  const instance = yield* InstanceTag;
-  const services = yield* context();
-  yield* addFinalizerExit(instance.scope, (exit) => instance.abandoned ? void_2 : provideContext(f(exit), services));
-});
-var withCompensation = /* @__PURE__ */ dual(2, (effect, compensation) => uninterruptibleMask((restore) => tap(restore(effect), (value) => addFinalizer((exit) => isSuccess2(exit) ? void_2 : compensation(value, exit.cause)))));
-var suspend2 = (instance) => interruptible(callback(() => {
-  instance.suspended = true;
-  const fiber = getCurrent();
-  fiber.interruptUnsafe(fiber.id);
-}));
-
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workflow/DurableDeferred.js
-var TypeId2 = "~effect/workflow/DurableDeferred";
-var make2 = (name, options) => {
-  const successSchema = options?.success ?? Void;
-  const errorSchema = options?.error ?? Never;
-  return {
-    [TypeId2]: TypeId2,
-    name,
-    successSchema,
-    errorSchema,
-    exitSchema: Exit(toCodecJson(successSchema), toCodecJson(errorSchema), toCodecJson(Defect())),
-    withActivityAttempt: gen(function* () {
-      const attempt = yield* CurrentAttempt;
-      return make2(`${name}/${attempt}`, {
-        success: successSchema,
-        error: errorSchema
-      });
-    })
-  };
-};
-var EngineTag2 = /* @__PURE__ */ Service("effect/workflow/WorkflowEngine");
-var InstanceTag2 = /* @__PURE__ */ Service("effect/workflow/WorkflowEngine/WorkflowInstance");
-var CurrentAttempt = /* @__PURE__ */ Reference("effect/workflow/Activity/CurrentAttempt", {
-  defaultValue: () => 1
-});
-var awaitOwners = /* @__PURE__ */ new WeakMap;
-var registerAwait = (instance, name) => {
-  instance.awaitedDeferreds.set(name, (instance.awaitedDeferreds.get(name) ?? 0) + 1);
-  awaitOwners.get(instance)?.push(name);
-};
-var await_ = /* @__PURE__ */ fnUntraced(function* (self) {
-  const engine = yield* EngineTag2;
-  const instance = yield* InstanceTag2;
-  registerAwait(instance, self.name);
-  const exit = yield* wrapActivityResult(engine.deferredResult(self), isNone);
-  if (isNone(exit)) {
-    return yield* suspend2(instance);
-  }
-  return yield* exit.value;
-});
-class TokenParsed extends (/* @__PURE__ */ Class("effect/workflow/DurableDeferred/TokenParsed")({
-  workflowName: String2,
-  executionId: String2,
-  deferredName: String2
-})) {
-  get asToken() {
-    return encode2(JSON.stringify([this.workflowName, this.executionId, this.deferredName]));
-  }
-  static FromString = /* @__PURE__ */ String2.pipe(/* @__PURE__ */ decodeTo(/* @__PURE__ */ fromJsonString(/* @__PURE__ */ Tuple([String2, String2, String2])), {
-    decode: /* @__PURE__ */ decodeBase64UrlString(),
-    encode: /* @__PURE__ */ encodeBase64Url()
-  }), /* @__PURE__ */ decodeTo(TokenParsed, {
-    decode: /* @__PURE__ */ transform(([workflowName, executionId, deferredName]) => new TokenParsed({
-      workflowName,
-      executionId,
-      deferredName
-    })),
-    encode: /* @__PURE__ */ transform((parsed) => [parsed.workflowName, parsed.executionId, parsed.deferredName])
-  }));
-  static fromString = /* @__PURE__ */ decodeSync(TokenParsed.FromString);
-  static encode = /* @__PURE__ */ encodeSync(TokenParsed.FromString);
-}
-var token = /* @__PURE__ */ fnUntraced(function* (self) {
-  const instance = yield* InstanceTag2;
-  return tokenFromExecutionId(self, instance);
-});
-var tokenFromExecutionId = /* @__PURE__ */ dual(2, (self, options) => new TokenParsed({
-  workflowName: options.workflow._tag,
-  executionId: options.executionId,
-  deferredName: self.name
-}).asToken);
-
-// node_modules/.bun/effect@4.0.4/node_modules/effect/dist/workflow/Activity.js
-var TypeId3 = "~effect/workflow/Activity";
-var make3 = (options) => {
-  const successSchema = options.success ?? Void;
-  const errorSchema = options.error ?? Never;
-  const successSchemaJson = toCodecJson(successSchema);
-  const errorSchemaJson = toCodecJson(errorSchema);
-  let execute;
-  const executeWithoutInterrupt = retryOnInterrupt(options.name, options.interruptRetryPolicy)(options.execute);
-  const self = {
-    ...Prototype({
-      label: "Activity",
-      evaluate(_) {
-        return execute;
-      }
-    }),
-    [TypeId3]: TypeId3,
-    name: options.name,
-    successSchema,
-    errorSchema,
-    exitSchema: Exit(successSchemaJson, errorSchemaJson, Defect()),
-    exitSchemaPartial: Exit(successSchemaJson, errorSchemaJson, Unknown),
-    annotations: options.annotations ?? empty(),
-    annotate(tag, value) {
-      return make3({
-        ...options,
-        annotations: add(self.annotations, tag, value)
-      });
-    },
-    annotateMerge(context) {
-      return make3({
-        ...options,
-        annotations: merge(self.annotations, context)
-      });
-    },
-    execute: executeWithoutInterrupt,
-    executeEncoded: matchEffect(executeWithoutInterrupt, {
-      onFailure: (error) => flatMap2(orDie(encodeEffect(errorSchemaJson)(error)), fail4),
-      onSuccess: (value) => orDie(encodeEffect(successSchemaJson)(value))
-    })
-  };
-  execute = makeExecute(self);
-  return self;
-};
-var interruptRetryPolicy = /* @__PURE__ */ min([exponential(400, 1.5), spaced("10 seconds")]).pipe(/* @__PURE__ */ setInputType(), /* @__PURE__ */ while_((meta) => meta.attempt <= 10 && hasInterrupts(meta.input)));
-var retryOnInterrupt = (name, policy = interruptRetryPolicy) => (effect) => flatMap2(InstanceTag3, (instance) => effect.pipe(sandbox, retry({
-  schedule: policy,
-  while: () => !instance.suspended
-}), catch_((cause) => hasInterrupts(cause) && !instance.suspended ? die3(`Activity "${name}" interrupted and retry attempts exhausted`) : failCause2(cause))));
-var CurrentAttempt2 = /* @__PURE__ */ Reference("effect/workflow/Activity/CurrentAttempt", {
-  defaultValue: () => 1
-});
-var EngineTag3 = /* @__PURE__ */ Service("effect/workflow/WorkflowEngine");
-var InstanceTag3 = /* @__PURE__ */ Service("effect/workflow/WorkflowEngine/WorkflowInstance");
-var makeExecute = /* @__PURE__ */ fnUntraced(function* (activity) {
-  const engine = yield* EngineTag3;
-  const instance = yield* InstanceTag3;
-  const attempt = yield* CurrentAttempt2;
-  yield* annotateCurrentSpan({
-    executionId: instance.executionId
-  });
-  const result = yield* wrapActivityResult(engine.activityExecute(activity, attempt), (_) => _._tag === "Suspended");
-  if (result._tag === "Suspended") {
-    return yield* suspend2(instance);
-  }
-  return yield* result.exit;
-}, (effect, activity) => withSpan(effect, activity.name, {
-  captureStackTrace: false
-}));
-// packages/sdk/src/loop/evidence.ts
-var EvidenceCheck = Struct({
-  name: String2,
-  command: String2,
-  status: Literals(["passed", "failed"]),
-  preExisting: Boolean2,
-  durationMs: Finite,
-  evidenceId: String2
-});
-var VerifyResult = Struct({
-  revision: String2,
-  tree: String2,
-  passed: Boolean2,
-  checks: ArraySchema(EvidenceCheck)
-});
-var verdict = (reasons) => reasons.length === 0 ? { settled: true } : { settled: false, reasons };
-var missing = (side) => `No verification evidence for the ${side}`;
-var allPass = (side, result) => {
-  if (result === undefined)
-    return [missing(side)];
-  if (result.checks.length === 0)
-    return [`No approved verification ran on the ${side} tree ${result.tree}`];
-  return result.checks.filter((check) => check.status === "failed" && !check.preExisting).map((check) => `${check.name} fails on the ${side} tree ${result.tree}`);
-};
-var checkOn = (side, result, name) => {
-  if (result === undefined)
-    return { reason: missing(side) };
-  if (name === undefined)
-    return { reason: `No check was named for the ${side}` };
-  const found = result.checks.find((check) => check.name === name);
-  return found === undefined ? { reason: `No evidence for ${name} on the ${side} tree ${result.tree}` } : { found };
-};
-var passesOnHead = (head, name) => {
-  const { found, reason } = checkOn("head", head, name);
-  if (found === undefined)
-    return [reason];
-  return found.status === "passed" ? [] : [`${found.name} fails on the head tree ${head?.tree}`];
-};
-var bugReasons = (input) => {
-  const base = checkOn("base", input.base, input.reproducing);
-  const head = checkOn("head", input.head, input.reproducing);
-  return [
-    ...base.found === undefined ? [base.reason] : base.found.status === "failed" ? [] : [`${base.found.name} does not fail on the base tree ${input.base?.tree}, so the bug is not reproduced`],
-    ...head.found === undefined ? [head.reason] : head.found.status === "passed" ? [] : [`${head.found.name} fails on the head tree ${input.head?.tree}`]
-  ];
-};
-var conclusionReasons = (conclusion) => {
-  if (conclusion === undefined || conclusion.text.trim() === "")
-    return ["No conclusion was given"];
-  return conclusion.sources.length === 0 ? ["The conclusion names no sources"] : [];
-};
-var scopeReasons = (scope) => {
-  if (scope === undefined)
-    return ["Review has not judged the scope"];
-  if (scope.met)
-    return [];
-  return scope.unmet.length === 0 ? ["Review found the scope unmet"] : scope.unmet.map((item) => `Review found the scope unmet: ${item}`);
-};
-var evidenceGate = (input) => {
-  switch (input.outcome) {
-    case "feature":
-      return verdict([...allPass("head", input.head), ...scopeReasons(input.review)]);
-    case "bug":
-      return verdict(bugReasons(input));
-    case "refactor":
-      return verdict([...allPass("base", input.base), ...allPass("head", input.head)]);
-    case "investigation":
-      return verdict(conclusionReasons(input.conclusion));
-    case "docs":
-      return verdict((input.documented ?? []).length === 0 ? ["No documented command was named"] : (input.documented ?? []).flatMap((name) => passesOnHead(input.head, name)));
-    case "migration":
-      return verdict(passesOnHead(input.head, input.rollback));
-    default:
-      return verdict(allPass("head", input.head));
-  }
-};
-
-// packages/sdk/src/loop/steps.ts
-class StepFailed extends TaggedError2()("StepFailed", {
-  step: String2,
-  reason: String2
-}) {
-  get message() {
-    return `Step "${this.step}" failed: ${this.reason}`;
-  }
-}
-
-class OutputInvalid extends TaggedError2()("OutputInvalid", {
-  step: String2,
-  message: String2
-}) {
-}
-
-class QuestionRefused extends TaggedError2()("QuestionRefused", {
-  step: String2,
-  answer: String2,
-  options: ArraySchema(String2)
-}) {
-}
-
-class WaitTimedOut extends TaggedError2()("WaitTimedOut", {
-  step: String2,
-  event: String2
-}) {
-}
-
-class ChildFailed extends TaggedError2()("ChildFailed", {
-  step: String2,
-  loop: String2,
-  reason: String2
-}) {
-  get message() {
-    return `Child Run of "${this.loop}" for Step "${this.step}" failed: ${this.reason}`;
-  }
-}
-
-class CapabilityDenied extends TaggedError2()("CapabilityDenied", {
-  step: String2,
-  capability: Literals(LoopCapabilities),
-  secret: optionalKey(String2)
-}) {
-  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: String2
-}) {
-}
-
-class InputInvalid extends TaggedError2()("InputInvalid", {
-  loop: String2,
-  message: String2
-}) {
-}
-var LoopEvent = Struct({ type: String2, payload: Record(String2, Json) });
-
-class LoopRun extends Service()("@kitman-sh/sdk/loop/LoopRun") {
-}
-
-class LoopHost extends Service()("@kitman-sh/sdk/loop/LoopHost") {
-}
-var agentWorkDeferred = (step) => make2(`agent_work/${step}`, { success: Json, error: StepFailed });
-var answerDeferred = (step) => make2(`ask/${step}`, { success: String2, error: StepFailed });
-var childDeferred = (step) => make2(`call/${step}`, { success: Json, error: ChildFailed });
-var eventDeferred = (step) => make2(`wait_for/${step}`, { success: LoopEvent, error: WaitTimedOut });
-var verifyDeferred = (step) => make2(`verify/${step}`, { success: VerifyResult, error: StepFailed });
-var recordStep = (name, kind, exit) => {
-  if (isSuccess2(exit))
-    return { name, kind, status: "succeeded", result: exit.value };
-  if (hasInterruptsOnly(exit.cause))
-    return;
-  return { name, kind, status: "failed", error: squash(exit.cause) };
-};
-var takeStep = (name, kind, capability, body) => gen(function* () {
-  const run = yield* LoopRun;
-  if (run.names.has(name))
-    return yield* new DuplicateStep({ step: name });
-  if (capability !== undefined && !run.granted.has(capability))
-    return yield* new CapabilityDenied({ step: name, capability });
-  run.names.add(name);
-  return yield* body.pipe(onExit((exit) => sync(() => {
-    const record = recordStep(name, kind, exit);
-    if (record !== undefined)
-      run.steps.push(record);
-  })));
-});
-var launch = (deferred, start) => make3({
-  name: deferred.name,
-  error: StepFailed,
-  execute: gen(function* () {
-    return yield* start(yield* LoopHost, yield* token(deferred));
-  })
-});
-var toJson = (step, schema, value) => encodeUnknownEffect(toCodecJson(schema))(value).pipe(flatMap2(decodeUnknownEffect(Json)), mapError((error) => new StepFailed({ step, reason: error.message })));
-var agentWork = (name, options) => takeStep(name, "agent_work", "agent_work", gen(function* () {
-  const run = yield* LoopRun;
-  const agent = run.agents[options.agent];
-  const undeclared = options.secrets?.find((secret) => !run.secrets.has(secret));
-  if (undeclared !== undefined)
-    return yield* new CapabilityDenied({ step: name, capability: "agent_work", secret: undeclared });
-  if (agent === undefined)
-    return yield* new StepFailed({ step: name, reason: `Agent role "${options.agent}" is not declared` });
-  const deferred = agentWorkDeferred(name);
-  const output = yield* jsonSchemaOf(run.loop, options.output).pipe(mapError((error) => new StepFailed({ step: name, reason: error.message })));
-  yield* launch(deferred, (host, token2) => host.startAgentWork({
-    step: name,
-    role: options.agent,
-    agent,
-    prompt: options.prompt,
-    output,
-    ...options.secrets === undefined ? undefined : { secrets: options.secrets },
-    token: token2
-  }));
-  const submitted = yield* await_(deferred);
-  return yield* decodeEffect(toCodecJson(options.output))(submitted).pipe(mapError((error) => new OutputInvalid({ step: name, message: error.message })));
-}));
-var ask = (name, question) => takeStep(name, "ask", "ask", gen(function* () {
-  const deferred = answerDeferred(name);
-  const options = "options" in question ? question.options : undefined;
-  yield* launch(deferred, (host, token2) => host.putQuestion({
-    step: name,
-    prompt: question.prompt,
-    ...options === undefined ? undefined : { options },
-    token: token2
-  }));
-  const answer = yield* await_(deferred);
-  if (options === undefined)
-    return answer;
-  const offered = options.find((option) => option === answer);
-  if (offered === undefined)
-    return yield* new QuestionRefused({ step: name, answer, options });
-  return offered;
-}));
-var call = (name, loop, input) => takeStep(name, "call", "call", gen(function* () {
-  const deferred = childDeferred(name);
-  const encoded = yield* toJson(name, loop.input, input);
-  yield* launch(deferred, (host, token2) => host.admitChild({ step: name, loop: loop.id, input: encoded, token: token2 }));
-  const result = yield* await_(deferred);
-  return yield* decodeEffect(toCodecJson(loop.output))(result).pipe(mapError((error) => new ChildFailed({ step: name, loop: loop.id, reason: error.message })));
-}));
-var waitFor = (name, wait) => takeStep(name, "wait_for", undefined, gen(function* () {
-  const deferred = eventDeferred(name);
-  const timeoutMillis = toMillis(fromInputUnsafe(wait.timeout));
-  yield* launch(deferred, (host, token2) => host.awaitEvent({
-    step: name,
-    event: wait.event,
-    ...wait.filter === undefined ? undefined : { filter: wait.filter },
-    timeoutMillis,
-    token: token2
-  }));
-  return yield* await_(deferred);
-}));
-var verify = (name, request) => takeStep(name, "verify", "verify", gen(function* () {
-  const deferred = verifyDeferred(name);
-  yield* launch(deferred, (host, token2) => host.startVerification({
-    step: name,
-    ...request.revision === undefined ? undefined : { revision: request.revision },
-    ...request.checks === undefined ? undefined : { checks: request.checks },
-    token: token2
-  }));
-  return yield* await_(deferred);
-}));
-// packages/sdk/src/loop/plan.ts
-var PlanTicket = Struct({
-  key: String2,
-  title: String2,
-  body: String2,
-  acceptanceCriteria: ArraySchema(String2),
-  repoBindingId: optional(String2),
-  blockedBy: ArraySchema(String2),
-  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(String2)
-}) {
-  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) };
-}
-var planWaves = (tickets) => suspend(() => {
-  const { waves, blocked } = wavesOf(tickets);
-  return blocked.length === 0 ? succeed5(waves) : fail4(new BlockingCycle({ tickets: blocked }));
-});
-
-// packages/sdk/src/loop/activities.ts
-var ChangeRequestRequest = Struct({
-  title: String2,
-  body: String2,
-  integration: optional(String2)
-});
-var ChangeRequestResult = Struct({ id: String2, number: String2, url: String2 });
-var WriteBackMilestones = ["started", "change_request_opened", "merged", "failed"];
-var WriteBackRequest = Struct({
-  milestone: optional(Literals(WriteBackMilestones)),
-  changeRequestUrl: optional(String2)
-});
-var RunFile = Struct({ runFile: String2 }).pipe(decodeTo(Struct({ id: String2 }), transform2({
-  decode: ({ runFile }) => ({ id: runFile }),
-  encode: ({ id }) => ({ runFile: id })
-})));
-var FileRequest = Struct({ path: String2, caption: optional(String2) });
-var ArtifactRequest = Struct({
-  kind: String2,
-  title: String2,
-  text: String2,
-  data: optional(Json),
-  files: optional(ArraySchema(RunFile))
-});
-var ArtifactResult = Struct({ artifactId: String2 });
-var NoteRequest = Struct({ text: String2, artifactId: optional(String2) });
-var CreateTasksRequest = Struct({ tickets: ArraySchema(PlanTicket) });
-var CreateTasksResult = Struct({
-  tasks: ArraySchema(Struct({ key: String2, taskId: String2 }))
-});
-var IntegrationBranchRequest = Struct({ repoBindingId: optional(String2) });
-var IntegrationBranch = Struct({
-  repoBindingId: String2,
-  branch: String2,
-  revision: String2
-});
-var MergeChangeRequestRequest = Struct({ changeRequestId: String2 });
-var MergeResult = Union([
-  Struct({ status: Literal("merged"), revision: String2 }),
-  Struct({ status: Literal("conflict") })
-]);
-var CommentRequest = Struct({ changeRequestId: String2, body: String2 });
-var ReleaseRequest = Struct({
-  tag: String2,
-  revision: optional(String2),
-  title: String2,
-  notes: String2
-});
-var ReleaseResult = Struct({ tag: String2, revision: String2, url: String2 });
-var TranscriptPoint = Struct({
-  runId: String2,
-  stepAttemptId: String2,
-  sequence: Int
-});
-var TranscriptsRequest = Struct({
-  days: Int.check(isGreaterThanOrEqualTo(1), isLessThanOrEqualTo2(31))
-});
-var TranscriptsResult = Struct({
-  runs: ArraySchema(Struct({
-    runId: String2,
-    loopId: String2,
-    teamId: optional(String2),
-    failure: optional(String2),
-    entries: ArraySchema(Struct({ stepAttemptId: String2, sequence: Int, kind: String2, text: String2 }))
-  }))
-});
-var Citations = NonEmptyArray(TranscriptPoint);
-var ProposeRequest = Union([
-  Struct({
-    kind: Literal("memory"),
-    teamId: String2,
-    content: String2,
-    citations: Citations
-  }),
-  Struct({
-    kind: Literal("task"),
-    title: String2,
-    description: String2,
-    teamId: optional(String2),
-    citations: Citations
-  })
-]);
-var ProposeResult = Struct({ kind: Literals(["memory", "task"]), id: String2 });
-var Health = Literals(["on_track", "at_risk", "off_track"]);
-var ProjectActivityRequest = Struct({ projectId: String2 });
-var ProjectActivityResult = Struct({
-  project: Struct({ id: String2, name: String2 }),
-  health: optional(Health),
-  since: optional(String2),
-  runs: ArraySchema(Struct({
-    runId: String2,
-    loopId: String2,
-    status: String2,
-    taskKey: optional(String2),
-    taskTitle: optional(String2),
-    summary: optional(String2),
-    entries: ArraySchema(Struct({ stepAttemptId: String2, sequence: Int, kind: String2, text: String2 }))
-  })),
-  taskChanges: ArraySchema(Struct({ taskKey: String2, title: String2, change: String2, at: String2 }))
-});
-var DraftUpdateRequest = Struct({
-  projectId: String2,
-  health: Health,
-  note: String2,
-  writtenFrom: Struct({
-    runs: Int,
-    taskChanges: Int,
-    since: optional(String2)
-  })
-});
-var DraftUpdateResult = Struct({ id: String2 });
-
-class ChangeRequestActivity extends Service()("@kitman-sh/sdk/loop/ChangeRequestActivity") {
-}
-
-class WriteBackActivity extends Service()("@kitman-sh/sdk/loop/WriteBackActivity") {
-}
-
-class ArtifactActivity extends Service()("@kitman-sh/sdk/loop/ArtifactActivity") {
-}
-
-class FileActivity extends Service()("@kitman-sh/sdk/loop/FileActivity") {
-}
-
-class NoteActivity extends Service()("@kitman-sh/sdk/loop/NoteActivity") {
-}
-
-class CommentActivity extends Service()("@kitman-sh/sdk/loop/CommentActivity") {
-}
-
-class CreateTasksActivity extends Service()("@kitman-sh/sdk/loop/CreateTasksActivity") {
-}
-
-class IntegrationBranchActivity extends Service()("@kitman-sh/sdk/loop/IntegrationBranchActivity") {
-}
-
-class MergeChangeRequestActivity extends Service()("@kitman-sh/sdk/loop/MergeChangeRequestActivity") {
-}
-
-class ReleaseActivity extends Service()("@kitman-sh/sdk/loop/ReleaseActivity") {
-}
-
-class TranscriptsActivity extends Service()("@kitman-sh/sdk/loop/TranscriptsActivity") {
-}
-
-class ProposeActivity extends Service()("@kitman-sh/sdk/loop/ProposeActivity") {
-}
-
-class ProjectActivityActivity extends Service()("@kitman-sh/sdk/loop/ProjectActivityActivity") {
-}
-
-class DraftUpdateActivity extends Service()("@kitman-sh/sdk/loop/DraftUpdateActivity") {
-}
-var hostActivity = (name, kind, capability, success, execute) => takeStep(name, kind, capability, make3({ name: `${kind}/${name}`, success, error: StepFailed, execute }));
-var changeRequest = (name, request) => hostActivity(name, "change_request", "change_request", ChangeRequestResult, gen(function* () {
-  return yield* (yield* ChangeRequestActivity).run(request, name);
-}));
-var writeBack = (name, request) => hostActivity(name, "write_back", "write_back", Void, gen(function* () {
-  return yield* (yield* WriteBackActivity).run(request, name);
-}));
-var artifact = (name, request) => hostActivity(name, "artifact", undefined, ArtifactResult, gen(function* () {
-  return yield* (yield* ArtifactActivity).run(request, name);
-}));
-var note = (name, request) => hostActivity(name, "note", undefined, Void, gen(function* () {
-  return yield* (yield* NoteActivity).run(request, name);
-}));
-var comment = (name, request) => hostActivity(name, "comment", "post_comment", Void, gen(function* () {
-  return yield* (yield* CommentActivity).run(request, name);
-}));
-var createTasks = (name, request) => hostActivity(name, "create_tasks", "create_tasks", CreateTasksResult, gen(function* () {
-  return yield* (yield* CreateTasksActivity).run(request, name);
-}));
-var integrationBranch = (name, request) => hostActivity(name, "integration_branch", "merge_change_request", IntegrationBranch, gen(function* () {
-  return yield* (yield* IntegrationBranchActivity).run(request, name);
-}));
-var mergeChangeRequest = (name, request) => hostActivity(name, "merge_change_request", "merge_change_request", MergeResult, gen(function* () {
-  return yield* (yield* MergeChangeRequestActivity).run(request, name);
-}));
-var release2 = (name, request) => hostActivity(name, "release", "publish_release", ReleaseResult, gen(function* () {
-  return yield* (yield* ReleaseActivity).run(request, name);
-}));
-var transcripts = (name, request) => hostActivity(name, "transcripts", "read_transcripts", TranscriptsResult, gen(function* () {
-  return yield* (yield* TranscriptsActivity).run(request, name);
-}));
-var propose = (name, request) => hostActivity(name, "propose", "propose", ProposeResult, gen(function* () {
-  return yield* (yield* ProposeActivity).run(request, name);
-}));
-var projectActivity = (name, request) => hostActivity(name, "project_activity", "read_project", ProjectActivityResult, gen(function* () {
-  return yield* (yield* ProjectActivityActivity).run(request, name);
-}));
-var draftUpdate = (name, request) => hostActivity(name, "draft_update", "draft_update", DraftUpdateResult, gen(function* () {
-  return yield* (yield* DraftUpdateActivity).run(request, name);
-}));
-// packages/sdk/src/loop/test-loop.ts
-var LoopJournal = Struct({
-  activities: Record(String2, Json),
-  deferreds: Record(String2, Json)
-});
-
-class ScriptedFailure extends TaggedClass("ScriptedFailure") {
-}
-// packages/sdk/src/loop/review.ts
-var Severity = Literals(["blocker", "major", "minor"]);
-var Finding = Struct({
-  severity: Severity,
-  file: String2,
-  line: Int,
-  detail: String2
-});
-var MergedFinding = Struct({
-  id: String2,
-  ...Finding.fields,
-  seats: ArraySchema(String2)
-});
-var Rebuttal = Struct({ findingId: String2, reason: String2 });
-var RebuttalVerdict = Struct({ findingId: String2, accepted: Boolean2 });
-var ScopeJudgement = Struct({ met: Boolean2, unmet: ArraySchema(String2) });
-var rank = { blocker: 0, major: 1, minor: 2 };
-var isBlocking = (finding) => finding.severity !== "minor";
-var mergeFindings = (bySeat) => {
-  const merged = new Map;
-  for (const [seat, findings] of Object.entries(bySeat))
-    for (const finding of findings) {
-      const id = `${finding.file}:${finding.line}`;
-      const known = merged.get(id);
-      const seats = [...new Set([...known?.seats ?? [], seat])];
-      const worst = known === undefined || rank[finding.severity] < rank[known.severity] ? finding : known;
-      merged.set(id, { id, severity: worst.severity, file: worst.file, line: worst.line, detail: worst.detail, seats });
-    }
-  return [...merged.values()].toSorted((left, right) => rank[left.severity] - rank[right.severity]);
-};
-var splitDisputed = (findings, rebuttals) => {
-  const disputed = [];
-  const undisputed = [];
-  for (const finding of findings) {
-    const rebuttal = rebuttals.find((entry) => entry.findingId === finding.id);
-    if (rebuttal === undefined)
-      undisputed.push(finding);
-    else
-      disputed.push({ finding, rebuttal });
-  }
-  return { disputed, undisputed };
-};
-var settleRound = (round) => {
-  const { disputed, undisputed } = splitDisputed(round.findings, round.rebuttals);
-  const accepted = (entry) => {
-    const verdicts = round.verdicts.filter((verdict) => verdict.findingId === entry.finding.id);
-    return verdicts.length > 0 && verdicts.every((verdict) => verdict.accepted);
-  };
-  return {
-    open: undisputed,
-    withdrawn: disputed.filter(accepted),
-    standing: disputed.filter((entry) => !accepted(entry))
-  };
-};
-var rallyStop = (input) => {
-  const open = input.settled.open.filter(isBlocking).map((finding) => finding.id);
-  const standing = input.settled.standing.flatMap((entry) => isBlocking(entry.finding) ? [entry.finding.id] : []);
-  const unsettled = [...open, ...standing];
-  const stop = (reason) => ({ stop: true, reason, unsettled });
-  if (unsettled.length === 0)
-    return stop("settled");
-  if (standing.length > 0)
-    return stop("dispute_stands");
-  if (input.previous !== undefined && sameIds(input.previous, unsettled))
-    return stop("findings_returned");
-  return input.round >= input.maxRounds ? stop("round_cap") : { stop: false };
-};
-var sameIds = (left, right) => left.length === right.length && left.every((id) => right.includes(id));
-// packages/sdk/src/loop/check.ts
-class CheckFailed extends TaggedError2()("CheckFailed", {
-  loop: String2,
-  check: String2,
-  reason: String2
-}) {
-  get detail() {
-    return `Check "${this.check}": ${this.reason}`;
-  }
-  get message() {
-    return `Loop "${this.loop}": ${this.detail}`;
-  }
-}
-
-class StepNamedTwice extends TaggedError2()("StepNamedTwice", {
-  loop: String2,
-  check: String2,
-  step: String2
-}) {
-  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: String2,
-  check: String2,
-  first: ArraySchema(String2),
-  replay: ArraySchema(String2),
-  rerun: ArraySchema(String2)
-}) {
-  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]);
-export { LoopManifest, AgentDeclaration, KitInstallationDeclaration, KitAssignmentDeclaration, PackageDeclarations, LoopOutcome, defineLoop, ManifestInvalid, make, Suspended, make2, await_, make3, evidenceGate, ChildFailed, agentWork, ask, call, waitFor, verify, PlanTickets, planWaves, ChangeRequestResult, CreateTasksResult, TranscriptPoint, changeRequest, writeBack, artifact, note, comment, createTasks, integrationBranch, mergeChangeRequest, release2, transcripts, propose, projectActivity, draftUpdate, Finding, MergedFinding, Rebuttal, RebuttalVerdict, ScopeJudgement, isBlocking, mergeFindings, settleRound, rallyStop, LoopCheckError };