@kitman-sh/cli 0.0.0-stage → 0.6.0

package/dist/chunk-n32jhswz.js

@@ -0,0 +1,964 @@
+// @bun
+import {
+  dual,
+  hasProperty,
+  Prototype,
+  isNone,
+  Service2,
+  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,
+  flatMap,
+  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,
+  decodeUnknownEffect,
+  decodeEffect,
+  decodeSync,
+  encodeUnknownEffect,
+  encodeEffect,
+  encodeSync,
+  isSchema,
+  optionalKey,
+  optional,
+  Literal,
+  Never,
+  Unknown,
+  String2,
+  Boolean2,
+  Void,
+  Struct,
+  Record,
+  Tuple,
+  ArraySchema,
+  Union,
+  Literals,
+  decodeTo,
+  tag,
+  makeFilter,
+  Finite,
+  Int,
+  Defect,
+  fromJsonString,
+  Cause,
+  Exit,
+  Class,
+  TaggedError2,
+  toJsonSchemaDocument,
+  toCodecJson,
+  Json
+} from "./chunk-txyq8r41.js";
+import {
+  LoopCapabilities
+} from "./chunk-hrvcz0m4.js";
+
+// 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(flatMap((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__ */ 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: merge(this.annotations, context),
+      idempotencyKey: this.idempotencyKey,
+      suspendedRetrySchedule: this.suspendedRetrySchedule
+    });
+  },
+  execute(fields, opts) {
+    return suspend(() => {
+      const payload = this.payloadSchema.make(fields);
+      const run = flatMap(EngineTag, (engine) => flatMap(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 flatMap(EngineTag, (engine) => engine.poll(this, executionId)).pipe(withSpan(`${this._tag}.poll`, {
+      attributes: {
+        executionId
+      }
+    }, {
+      captureStackTrace: false
+    }));
+  },
+  interrupt(executionId) {
+    return flatMap(EngineTag, (engine) => engine.interrupt(this, executionId)).pipe(withSpan(`${this._tag}.interrupt`, {
+      attributes: {
+        executionId
+      }
+    }, {
+      captureStackTrace: false
+    }));
+  },
+  resume(executionId) {
+    return flatMap(EngineTag, (engine) => engine.resume(this, executionId)).pipe(withSpan(`${this._tag}.resume`, {
+      attributes: {
+        executionId
+      }
+    }, {
+      captureStackTrace: false
+    }));
+  },
+  toLayer(execute) {
+    return effectDiscard(flatMap(EngineTag, (engine) => engine.register(this, execute)));
+  },
+  executionId(payload) {
+    return flatMap(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__ */ 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 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__ */ Service2("effect/workflow/WorkflowEngine");
+var InstanceTag2 = /* @__PURE__ */ Service2("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) => flatMap(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) => flatMap(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__ */ Service2("effect/workflow/WorkflowEngine");
+var InstanceTag3 = /* @__PURE__ */ Service2("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 Service2()("@kitman-sh/sdk/loop/LoopRun") {
+}
+
+class LoopHost extends Service2()("@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(flatMap(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 ArtifactRequest = Struct({
+  kind: String2,
+  title: String2,
+  text: String2,
+  data: optional(Json)
+});
+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 });
+
+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 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 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") {
+}
+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);
+}));
+// 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 { LoopOutcome, defineLoop, ManifestInvalid, make, Suspended, 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, LoopCheckError };