@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-txwt6r25.js

@@ -0,0 +1,1731 @@
+// @bun
+import {
+  dual,
+  hasProperty,
+  Prototype,
+  isNone,
+  Service2,
+  empty3,
+  add,
+  getOrUndefined2,
+  get4,
+  merge3,
+  Reference,
+  fromInputUnsafe,
+  toMillis,
+  TaggedClass,
+  encode,
+  isSuccess2,
+  addFinalizerExit,
+  effectDiscard,
+  hasInterruptsOnly,
+  combine2,
+  squash,
+  hasInterrupts2,
+  min2,
+  exponential,
+  spaced,
+  while_,
+  setInputType,
+  promise,
+  succeed6,
+  suspend3,
+  sync2,
+  void_3,
+  callback3,
+  gen,
+  fail7,
+  failCause3,
+  die3,
+  try_2,
+  yieldNow,
+  flatMap3,
+  andThen2,
+  tap2,
+  map8,
+  catch_,
+  catchTag,
+  mapError2,
+  orDie,
+  retry,
+  sandbox,
+  matchEffect2,
+  context,
+  contextWith,
+  provideContext2,
+  provideService,
+  acquireUseRelease,
+  onExit,
+  interruptible,
+  uninterruptibleMask2,
+  annotateCurrentSpan,
+  withSpan,
+  fnUntraced,
+  encode3,
+  transform,
+  encodeBase64Url,
+  decodeBase64UrlString,
+  transform2,
+  declare,
+  decodeUnknownEffect2,
+  decodeEffect,
+  decodeSync,
+  encodeUnknownEffect,
+  encodeEffect,
+  encodeSync,
+  isSchema,
+  optionalKey,
+  optional,
+  Literal,
+  Never,
+  Unknown,
+  Null,
+  String4,
+  Boolean2,
+  Void,
+  Struct,
+  Record,
+  Tuple2,
+  ArraySchema,
+  NonEmptyArray,
+  Union,
+  Literals,
+  decodeTo2,
+  tag,
+  makeFilter,
+  isPattern,
+  Finite,
+  isGreaterThanOrEqualTo,
+  isLessThanOrEqualTo,
+  Int,
+  isMinLength,
+  isMaxLength,
+  Defect,
+  fromJsonString,
+  Cause,
+  Exit,
+  Class2,
+  TaggedError2,
+  toEquivalence,
+  toJsonSchemaDocument,
+  toCodecJson,
+  Json
+} from "./chunk-mbctzx7e.js";
+import {
+  WebCrypto,
+  SafeJson,
+  AgentSandboxNetwork,
+  AgentEfforts,
+  AgentCapabilities,
+  recommendedDefault,
+  LoopDataSchemaRef,
+  LoopVersion,
+  ProgramLoop,
+  AgentFallback,
+  MeasureEvidence,
+  CatchUp,
+  ClaimResult
+} from "./chunk-wh1pa2aa.js";
+import {
+  getCurrent
+} from "./chunk-11p4wf6n.js";
+import {
+  guard
+} from "./chunk-pp1p3g6e.js";
+import {
+  splitQuestionOptions,
+  recommendationProblem,
+  questionAdvice
+} from "./chunk-1mc9vgcr.js";
+import {
+  KitName,
+  KitDigest
+} from "./chunk-z821b2gp.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"
+]);
+var defineLoop = (definition) => definition;
+
+class ManifestInvalid extends TaggedError2()("ManifestInvalid", {
+  loop: String4,
+  message: String4
+}) {
+}
+var jsonSchemaOf = (loop, schema) => try_2({
+  try: () => toJsonSchemaDocument(schema),
+  catch: (error) => new ManifestInvalid({ loop, message: `Schema has no JSON Schema: ${String(error)}` })
+}).pipe(flatMap3((document) => decodeUnknownEffect2(JsonObjectSchema)({ ...document.schema, $defs: document.definitions }).pipe(mapError2((error) => new ManifestInvalid({ loop, message: error.message })))));
+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 make14 = (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";
+var isResult = (u) => hasProperty(u, ResultTypeId);
+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 wrapActivityResult = (effect, isSuspend) => contextWith((context) => {
+  const instance = get4(context, InstanceTag);
+  return acquireUseRelease(sync2(() => 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 ? combine2(instance.cause, exit.value.cause) : exit.value.cause;
+    }
+    return isSuspended && instance.activityState.count > 0 ? waitForZero(instance) : void_3;
+  });
+});
+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(sync2(() => registerActivityUnsafe(instance)), (registration) => provideService(effect, PendingActivityRegistration, registration), (registration) => sync2(() => 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_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)))));
+var suspend = (instance) => interruptible(callback3(() => {
+  instance.suspended = true;
+  const fiber = getCurrent();
+  fiber.interruptUnsafe(fiber.id);
+}));
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/workflow/DurableDeferred.js
+var TypeId2 = "~effect/workflow/DurableDeferred";
+var make = (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 make(`${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* suspend(instance);
+  }
+  return yield* exit.value;
+});
+class TokenParsed extends (/* @__PURE__ */ Class2("effect/workflow/DurableDeferred/TokenParsed")({
+  workflowName: String4,
+  executionId: String4,
+  deferredName: String4
+})) {
+  get asToken() {
+    return encode3(JSON.stringify([this.workflowName, this.executionId, this.deferredName]));
+  }
+  static FromString = /* @__PURE__ */ String4.pipe(/* @__PURE__ */ decodeTo2(/* @__PURE__ */ fromJsonString(/* @__PURE__ */ Tuple2([String4, String4, String4])), {
+    decode: /* @__PURE__ */ decodeBase64UrlString(),
+    encode: /* @__PURE__ */ encodeBase64Url()
+  }), /* @__PURE__ */ decodeTo2(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.1.2/node_modules/effect/dist/workflow/Activity.js
+var TypeId3 = "~effect/workflow/Activity";
+var make2 = (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 ?? empty3(),
+    annotate(tag, value) {
+      return make2({
+        ...options,
+        annotations: add(self.annotations, tag, value)
+      });
+    },
+    annotateMerge(context) {
+      return make2({
+        ...options,
+        annotations: merge3(self.annotations, context)
+      });
+    },
+    execute: executeWithoutInterrupt,
+    executeEncoded: matchEffect2(executeWithoutInterrupt, {
+      onFailure: (error) => flatMap3(orDie(encodeEffect(errorSchemaJson)(error)), fail7),
+      onSuccess: (value) => orDie(encodeEffect(successSchemaJson)(value))
+    })
+  };
+  execute = makeExecute(self);
+  return self;
+};
+var interruptRetryPolicy = /* @__PURE__ */ min2([exponential(400, 1.5), spaced("10 seconds")]).pipe(/* @__PURE__ */ setInputType(), /* @__PURE__ */ while_((meta) => meta.attempt <= 10 && hasInterrupts2(meta.input)));
+var retryOnInterrupt = (name, policy = interruptRetryPolicy) => (effect) => flatMap3(InstanceTag3, (instance) => effect.pipe(sandbox, retry({
+  schedule: policy,
+  while: () => !instance.suspended
+}), catch_((cause) => hasInterrupts2(cause) && !instance.suspended ? die3(`Activity "${name}" interrupted and retry attempts exhausted`) : failCause3(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") {
+    if (result.failed)
+      instance.failed = true;
+    return yield* suspend(instance);
+  }
+  return yield* result.exit;
+}, (effect, activity) => withSpan(effect, activity.name, {
+  captureStackTrace: false
+}));
+// 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)
+});
+var verdict = (reasons) => reasons.length === 0 ? { settled: true } : { settled: false, reasons };
+var missing = (side) => `No verification evidence for the ${side}`;
+var failsOn = (side, name, tree) => `${name} fails on the ${side} tree ${tree}`;
+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) => failsOn(side, check.name, 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" ? [] : [failsOn("head", found.name, 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" ? [] : [failsOn("head", head.found.name, 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));
+    case "performance":
+      return verdict([
+        ...input.measurement === undefined ? ["No final measurement against the merge base was kept"] : input.measurement.verdict === "gain" ? [] : [`The final measurement is ${input.measurement.verdict}: ${input.measurement.reason}`],
+        ...allPass("head", input.head)
+      ]);
+    default:
+      return verdict(allPass("head", input.head));
+  }
+};
+
+// 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") {
+}
+var agentDeferredNamed = (deferredName) => make(deferredName, { success: Json, error: StepFailed });
+var agentWorkDeferred = (step) => agentDeferredNamed(`agent_work/${step}`);
+var syncDeferred = (step) => agentDeferredNamed(`sync/${step}`);
+var answerDeferred = (step) => make(`ask/${step}`, { success: String4, error: StepFailed });
+var childDeferred = (step) => make(`call/${step}`, { success: Json, error: ChildFailed });
+var eventDeferred = (step) => make(`wait_for/${step}`, { success: LoopEvent, error: WaitTimedOut });
+var verifyDeferred = (step) => make(`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) => sync2(() => {
+    const record = recordStep(name, kind, exit);
+    if (record !== undefined)
+      run.steps.push(record);
+  })));
+});
+var launch = (deferred, start) => make2({
+  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(flatMap3(decodeUnknownEffect2(Json)), mapError2((error) => new StepFailed({ step, reason: error.message })));
+var agentWork = (name, options) => agentWorkAs(agentWorkDeferred, name, options);
+var agentWorkAs = (deferredOf, 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 = deferredOf(name);
+  const output = yield* jsonSchemaOf(run.loop, options.answer ?? options.output).pipe(mapError2((error) => new StepFailed({ step: name, reason: error.message })));
+  yield* launch(deferred, (host, token2) => host.startAgentWork({
+    step: name,
+    deferredName: deferred.name,
+    role: options.agent,
+    agent,
+    prompt: options.prompt,
+    ...options.skill === undefined ? undefined : { skill: options.skill },
+    output,
+    ...options.secrets === undefined ? undefined : { secrets: options.secrets },
+    ...options.timeout === undefined ? undefined : { timeoutMillis: toMillis(fromInputUnsafe(options.timeout)) },
+    ...options.mergeTarget === undefined ? undefined : { mergeTarget: options.mergeTarget },
+    token: token2
+  }));
+  const submitted = yield* await_(deferred);
+  return yield* decodeEffect(toCodecJson(options.output))(submitted).pipe(mapError2((error) => new OutputInvalid({ step: name, message: error.message })));
+}));
+var agentWorkOnce = (name, options) => agentWork(name, options).pipe(catchTag("OutputInvalid", (invalid) => agentWork(`${name}:again`, {
+  ...options,
+  prompt: `${options.prompt}
+
+Your last Output was refused: ${invalid.message}. Give it again in the right shape.`
+})));
+var ask = (name, question) => takeStep(name, "ask", "ask", gen(function* () {
+  const deferred = answerDeferred(name);
+  const offered = "options" in question ? splitQuestionOptions(question.options) : undefined;
+  const options = offered?.options;
+  const recommended = "recommended" in question ? question.recommended : undefined;
+  const informationOnly = "informationOnly" in question ? question.informationOnly : undefined;
+  const advice = questionAdvice({
+    ...offered,
+    ...recommended === undefined ? undefined : { recommended },
+    recommendationReason: question.recommendationReason,
+    ...informationOnly === undefined ? undefined : { informationOnly }
+  });
+  const refused = recommendationProblem({ ...advice, ...options === undefined ? undefined : { options } });
+  if (refused !== undefined)
+    return yield* new StepFailed({ step: name, reason: refused });
+  const fallback = question.default === undefined ? recommendedDefault(recommended) : question.default ?? undefined;
+  if (fallback !== undefined && options !== undefined && !options.includes(fallback))
+    return yield* new QuestionRefused({ step: name, answer: fallback, options });
+  yield* launch(deferred, (host, token2) => host.putQuestion({
+    step: name,
+    prompt: question.prompt,
+    ...options === undefined ? undefined : { options },
+    ...advice,
+    ...fallback === undefined ? undefined : { default: fallback },
+    ...question.timeout === undefined ? undefined : { timeoutMillis: toMillis(fromInputUnsafe(question.timeout)) },
+    token: token2
+  }));
+  const answer = yield* await_(deferred);
+  if (options === undefined) {
+    return answer;
+  }
+  const offeredAnswer = options.find((option) => option === answer);
+  if (offeredAnswer === undefined)
+    return yield* new QuestionRefused({ step: name, answer, options });
+  return offeredAnswer;
+}));
+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(mapError2((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 },
+    ...wait.since === undefined ? undefined : { since: wait.since },
+    ...wait.or === undefined ? undefined : { or: wait.or },
+    timeoutMillis,
+    token: token2
+  }));
+  const event = yield* await_(deferred);
+  if (event.type === "change_request.closed" && wait.event !== event.type && wait.or?.some((other) => other.event === event.type) !== true)
+    return yield* new ChangeRequestClosed({
+      step: name,
+      merged: event.payload.merged === true
+    });
+  return event;
+}));
+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 },
+    ...request.suggested === undefined || request.suggested.length === 0 ? undefined : { suggested: request.suggested },
+    token: token2
+  }));
+  return yield* await_(deferred);
+}));
+// 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) };
+}
+var planWaves = (tickets) => suspend3(() => {
+  const { waves, blocked } = wavesOf(tickets);
+  return blocked.length === 0 ? succeed6(waves) : fail7(new BlockingCycle({ tickets: blocked }));
+});
+
+// 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 }), transform2({
+  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") {
+}
+var hostActivity = (name, kind, capability, success, execute) => takeStep(name, kind, capability, make2({ 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 alertTask = (name, request) => hostActivity(name, "create_tasks", "create_tasks", AlertTaskResult, gen(function* () {
+  return yield* (yield* AlertTaskActivity).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 approveChangeRequest = (name, request) => hostActivity(name, "approve_change_request", "approve_change_request", ApproveChangeRequestResult, gen(function* () {
+  return yield* (yield* MergeChangeRequestActivity).approve(request, name);
+}));
+var closeChangeRequest = (name, request) => hostActivity(name, "close_change_request", "merge_change_request", CloseChangeRequestResult, gen(function* () {
+  return yield* (yield* MergeChangeRequestActivity).close(request, name);
+}));
+var pipelineMoved = (name, changeRequestId, read, timeout = "6 hours") => waitFor(name, {
+  event: "change_request.pipeline",
+  filter: read.readAt === undefined ? { changeRequestId, head: read.head } : { changeRequestId },
+  timeout,
+  ...read.readAt === undefined ? undefined : { since: read.readAt }
+});
+var rerunPipeline = (name, request) => hostActivity(name, "rerun_pipeline", "merge_change_request", RerunPipelineResult, gen(function* () {
+  return yield* (yield* MergeChangeRequestActivity).rerun(request, name);
+}));
+var reportPipeline = (name, request) => hostActivity(name, "report_pipeline", "verify", ReportPipelineResult, gen(function* () {
+  return yield* (yield* MergeChangeRequestActivity).report(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 pipelineStatus = (name, request) => hostActivity(name, "pipeline_status", "read_change_request", PipelineStatus, gen(function* () {
+  return yield* (yield* ChangeRequestReadActivity).pipeline(request, name);
+}));
+var reviewThreads = (name, request) => hostActivity(name, "review_threads", "read_change_request", ReviewThreads, gen(function* () {
+  return yield* (yield* ChangeRequestReadActivity).reviewThreads(request, name);
+}));
+var openChangeRequests = (name, request) => hostActivity(name, "open_change_requests", "read_change_request", OpenChangeRequests, gen(function* () {
+  return yield* (yield* ChangeRequestReadActivity).opened(request, name);
+}));
+var ownChangeRequests = (name) => hostActivity(name, "own_change_requests", "read_change_request", OwnChangeRequests, gen(function* () {
+  return yield* (yield* ChangeRequestReadActivity).own(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/claims.ts
+var claimDeferred = (step) => make(`claim/${step}`, { success: ClaimResult, error: StepFailed });
+var claimOnce = (name, resource, action) => takeStep(name, "claim", "claim", gen(function* () {
+  const deferred = claimDeferred(name);
+  yield* launch(deferred, (host, token) => host.claimResource({ step: name, resource, action, token }));
+  return yield* await_(deferred);
+}));
+var takeOver = "Take it over";
+var holderName = (holder) => holder.private === true ? "a Run of a private Team you are not in" : `Run ${holder.runId} of ${holder.loopId}`;
+var claim = (name, request) => gen(function* () {
+  const first = yield* claimOnce(name, request.resource, "claim");
+  if (first.status === "granted")
+    return first;
+  const { holder } = first;
+  const fallback = holder.sameLoop ? takeOver : "Leave it";
+  const answer = (yield* LoopRun).granted.has("ask") ? yield* ask(`${name}-offer`, {
+    prompt: `${request.resource} is still held by ${holderName(holder)}${holder.status === undefined ? "" : `, which ${holder.status}`}${holder.reason === undefined ? "" : `: ${holder.reason}`}. Take it over?`,
+    options: [takeOver, "Leave it"],
+    recommended: fallback,
+    recommendationReason: holder.sameLoop ? "The holder is this Loop on the same repository and settled without completing, so nothing else is using it." : "Another Loop holds it and may still need it; waiting is safer than taking it from under that Run.",
+    timeout: request.timeout ?? "10 minutes"
+  }) : fallback;
+  if (answer !== takeOver)
+    return yield* new StepFailed({ step: name, reason: `${request.resource} was left to ${holderName(holder)}` });
+  const taken = yield* claimOnce(`${name}-take-over`, request.resource, "take_over");
+  if (taken.status === "granted")
+    return taken;
+  return yield* new StepFailed({ step: name, reason: `${request.resource} is kept by ${holderName(taken.holder)}` });
+});
+
+// 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 measureDeferred = (step) => make(`measure/${step}`, { success: MeasureEvidence, error: StepFailed });
+var stats = (values) => {
+  if (values.length === 0)
+    return { samples: 0, median: 0, mean: 0, min: 0, max: 0, stdev: 0 };
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+  return {
+    samples: values.length,
+    median: sorted.length % 2 === 0 ? ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2 : sorted[middle] ?? 0,
+    mean,
+    min: sorted[0] ?? 0,
+    max: sorted.at(-1) ?? 0,
+    stdev: Math.sqrt(values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length)
+  };
+};
+var valuesOf = (samples, metric) => samples.flatMap((sample) => sample[metric] === undefined ? [] : [sample[metric]]);
+var incomplete = (plan, evidence) => plan.metrics.map((metric) => metric.name).filter((metric) => evidence.base.length === 0 || evidence.head.length === 0 || [...evidence.base, ...evidence.head, ...evidence.baseAgain ?? []].some((sample) => sample[metric] === undefined));
+var relative = (delta, of) => of === 0 ? Math.sign(delta) : delta / Math.abs(of);
+var noiseFloor = (plan, evidence) => Object.fromEntries(plan.metrics.map((metric) => {
+  const base = stats(valuesOf(evidence.base, metric.name));
+  const again = stats(valuesOf(evidence.baseAgain ?? [], metric.name));
+  const spread = relative(base.stdev, base.median);
+  const gap = again.samples === 0 ? 0 : relative(Math.abs(again.median - base.median), base.median);
+  return [metric.name, Math.max(spread, gap)];
+}));
+var judgeMeasurement = (plan, evidence, noise, limits) => {
+  const metrics = plan.metrics.map((metric) => {
+    const base = stats(valuesOf(evidence.base, metric.name));
+    const head = stats(valuesOf(evidence.head, metric.name));
+    const delta = metric.direction === "lower" ? base.median - head.median : head.median - base.median;
+    const change = base.samples === 0 || head.samples === 0 ? 0 : relative(delta, base.median);
+    return { ...metric, base, head, change, noise: noise[metric.name] ?? 0 };
+  });
+  const percent = (fraction) => `${(fraction * 100).toFixed(1)}%`;
+  const primary = metrics.find((metric) => metric.role === "primary");
+  const judged = { metrics, evidence };
+  if (primary === undefined)
+    return { ...judged, verdict: "too_noisy", reason: "The plan names no primary metric" };
+  const missing = incomplete(plan, evidence);
+  if (missing.length > 0)
+    return { ...judged, verdict: "too_noisy", reason: `${missing.join(", ")} is missing from some samples` };
+  if (!Number.isFinite(primary.noise) || primary.noise > limits.threshold) {
+    const steadier = plan.metrics.find((metric) => metric.lowVariance === true && metric.name !== primary.name);
+    return {
+      ...judged,
+      verdict: "too_noisy",
+      reason: `${primary.name} strays ${percent(primary.noise)} from itself, more than the ${percent(limits.threshold)} threshold`,
+      suggestion: steadier === undefined ? "Measure a low-variance counter (instructions, allocations, queries) and make it the primary metric" : `Make ${steadier.name}, which varies less, the primary metric`
+    };
+  }
+  const regressed = metrics.filter((metric) => metric.role === "guardrail" && metric.change < -(limits.tolerance + metric.noise));
+  if (regressed.length > 0)
+    return {
+      ...judged,
+      verdict: "guardrail_regressed",
+      reason: regressed.map((metric) => `${metric.name} got ${percent(-metric.change)} worse, beyond the ${percent(limits.tolerance)} tolerance`).join("; ")
+    };
+  return primary.change > limits.threshold + primary.noise ? {
+    ...judged,
+    verdict: "gain",
+    reason: `${primary.name} improved ${percent(primary.change)}, past the ${percent(limits.threshold)} threshold and ${percent(primary.noise)} of noise`
+  } : {
+    ...judged,
+    verdict: "no_gain",
+    reason: `${primary.name} changed ${percent(primary.change)}, within the ${percent(limits.threshold)} threshold and ${percent(primary.noise)} of noise`
+  };
+};
+var floors = new WeakMap;
+var measure = (name, request) => takeStep(name, "measure", "measure", gen(function* () {
+  const run = yield* LoopRun;
+  const known = floors.get(run);
+  const deferred = measureDeferred(name);
+  yield* launch(deferred, (host, token) => host.startVerification({
+    step: name,
+    ...request.head === undefined ? undefined : { revision: request.head },
+    measure: {
+      ...request.base === undefined ? undefined : { base: request.base },
+      plan: request.plan,
+      samples: request.samples ?? 5,
+      calibrate: known === undefined
+    },
+    token
+  }));
+  const evidence = yield* await_(deferred);
+  const noise = known ?? noiseFloor(request.plan, evidence);
+  if (known === undefined && incomplete(request.plan, evidence).length === 0)
+    floors.set(run, noise);
+  return judgeMeasurement(request.plan, evidence, noise, {
+    threshold: request.threshold ?? 0.05,
+    tolerance: request.tolerance ?? 0.02
+  });
+}));
+
+// 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) });
+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: 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
+]);
+var afterMerge = "One thing comes before any answer of merged, a clean merge included, and stopping above means stopping after it: before you answer merged, do what the repository's agent instructions say to do once the target branch is merged in, such as regenerating this branch's database migrations on top of the target's. Leave what that changes in the workspace: Kitman commits it.";
+var prompt = (target) => [
+  `Kitman merged \`origin/${target}\` into this branch before you started, outside your sandbox, and says what came of it in a note after this brief. Do not fetch, as this workspace has no credential for the forge, and do not run git commands that write, such as \`git add\`, \`git commit\` or \`git merge --abort\`: Kitman finishes the merge itself from your answer.`,
+  "If it was already up to date, change nothing and answer up_to_date. If it merged cleanly, answer merged with no settled files and stop: do not review or test anything else.",
+  "If it conflicts, settle each file the note names so both sides' intent survives: leave no conflict marker, and for a file one side deleted or git could not mark, leave it as the version you want or delete it. Run the tests of the files you touched, and answer merged with those files under settled. Kitman then commits the files as you left them.",
+  "If you cannot settle a file, answer conflict with the files and why: Kitman then aborts the whole merge.",
+  "Never rebase, reset or force-push: this branch's history only grows."
+].concat(afterMerge).join(`
+
+`);
+var syncBase = (name, options) => agentWorkAs(syncDeferred, name, {
+  agent: options.agent,
+  prompt: prompt(options.target ?? "HEAD"),
+  output: BaseSync,
+  answer: SyncAnswer,
+  mergeTarget: options.target ?? "HEAD"
+});
+// 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)
+});
+var continuingBrief = (continuing) => [
+  `This continues the work on ${continuing.branch}, whose ChangeRequest is ${continuing.url}. Build on what is there; do not start over.`,
+  ...continuing.lastRunId === undefined ? [] : [
+    `The last Run on it, ${continuing.lastRunId}, ended ${continuing.lastRunStatus ?? "unfinished"}${continuing.lastRunSummary === undefined ? "" : `: ${continuing.lastRunSummary}`}.`
+  ],
+  ...continuing.revision === undefined ? [] : [
+    `It last pushed ${continuing.revision}. If the branch head is newer, someone pushed since: read \`git log ${continuing.revision}..HEAD\` first and keep their work.`
+  ],
+  "The ChangeRequest's description lists what was left unsettled; settle those first."
+].join(`
+`);
+export { LoopManifest, AgentDeclaration, KitDeclarations, LoopOutcome, defineLoop, ManifestInvalid, make14, Suspended, failsOn, evidenceGate, ChildFailed, agentWork, agentWorkOnce, ask, call, waitFor, verify, PlanTickets, planWaves, ChangeRequestResult, RunFile, CreateTasksResult, ApproveChangeRequestResult, TranscriptPoint, changeRequest, writeBack, artifact, note, comment, createTasks, alertTask, integrationBranch, mergeChangeRequest, approveChangeRequest, closeChangeRequest, pipelineMoved, rerunPipeline, reportPipeline, release2, transcripts, propose, projectActivity, pipelineStatus, reviewThreads, openChangeRequests, ownChangeRequests, draftUpdate, claim, measure, Finding, MergedFinding, Rebuttal, RebuttalVerdict, ScopeJudgement, isBlocking, mergeFindings, settleRound, rallyStop, LoopCheckError, syncBase, Continuing, continuingBrief };