@kitman-sh/sdk 0.10.70 → 0.10.72

package/dist/{chunk-kjkn6d60.js → chunk-stw541tr.js}

@@ -1888,6 +1888,8 @@ var RunEvidence = Schema12.Struct({
   durationMs: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(0)),
   outputTail: Schema12.String,
   fileIds: Schema12.optionalKey(Schema12.Array(Schema12.String)),
+  skippedSinceBaseline: Schema12.optionalKey(Schema12.Array(Schema12.String)),
+  newNotRun: Schema12.optionalKey(Schema12.Array(Schema12.String)),
   recordedAt: Timestamp
 });
 var ApprovedVerification = Schema12.Struct({
@@ -2740,7 +2742,9 @@ var EvidenceCheck2 = Schema16.Struct({
   durationMs: Schema16.Finite,
   evidenceId: Schema16.String,
   outputTail: Schema16.optionalKey(Schema16.String),
-  suggested: Schema16.optionalKey(Schema16.Boolean)
+  suggested: Schema16.optionalKey(Schema16.Boolean),
+  skippedSinceBaseline: Schema16.optionalKey(Schema16.Array(Schema16.String)),
+  newNotRun: Schema16.optionalKey(Schema16.Array(Schema16.String))
 });
 var VerifyResult2 = Schema16.Struct({
   revision: Schema16.String,
@@ -2762,6 +2766,16 @@ var OutcomeTable2 = {
 var verdict = (reasons) => reasons.length === 0 ? { settled: true } : { settled: false, reasons };
 var missing = (side) => `No verification evidence for the ${side}`;
 var failsOn2 = (side, name, tree) => `${name} fails on the ${side} tree ${tree}`;
+var shownTests = 10;
+var testList = (tests) => [...tests.slice(0, shownTests), ...tests.length > shownTests ? [`and ${tests.length - shownTests} more`] : []].join("; ");
+var testsNotRunReasons2 = (result) => result.checks.flatMap((check) => [
+  ...check.newNotRun === undefined || check.newNotRun.length === 0 ? [] : [
+    `${check.name} skipped ${check.newNotRun.length} new test${check.newNotRun.length === 1 ? "" : "s"} on the tree ${result.tree}, so verify never ran them: ${testList(check.newNotRun)}`
+  ],
+  ...check.skippedSinceBaseline === undefined || check.skippedSinceBaseline.length === 0 ? [] : [
+    `${check.name} skipped ${check.skippedSinceBaseline.length} test${check.skippedSinceBaseline.length === 1 ? "" : "s"} on the tree ${result.tree} that ran on the baseline: ${testList(check.skippedSinceBaseline)}`
+  ]
+]);
 var allPass = (side, result) => {
   if (result === undefined)
     return [missing(side)];
@@ -2804,6 +2818,11 @@ var scopeReasons = (scope) => {
   return scope.unmet.length === 0 ? ["Review found the scope unmet"] : scope.unmet.map((item) => `Review found the scope unmet: ${item}`);
 };
 var evidenceGate2 = (input) => {
+  const gated = outcomeGate(input);
+  const notRun = input.outcome === "investigation" || input.head === undefined ? [] : testsNotRunReasons2(input.head);
+  return verdict([...gated.settled ? [] : gated.reasons, ...notRun]);
+};
+var outcomeGate = (input) => {
   switch (input.outcome) {
     case "feature":
       return verdict([...allPass("head", input.head), ...scopeReasons(input.review)]);
@@ -3484,7 +3503,7 @@ import * as Exit3 from "effect/Exit";
 import * as Layer from "effect/Layer";
 import * as Option2 from "effect/Option";
 import * as Record12 from "effect/Record";
-import * as Schema27 from "effect/Schema";
+import * as Schema28 from "effect/Schema";
 import { DurableDeferred as DurableDeferred4, Workflow, WorkflowEngine } from "effect/workflow";
 
 // packages/core/src/resource-claim.ts
@@ -3561,8 +3580,8 @@ var letGo2 = (name, held) => takeStep2(name, "let_go", "claim", Effect6.gen(func
 }));
 
 // packages/core/src/work-unit.ts
-import * as Schema25 from "effect/Schema";
-import * as Struct23 from "effect/Struct";
+import * as Schema26 from "effect/Schema";
+import * as Struct24 from "effect/Struct";
 
 // packages/core/src/repo-binding.ts
 import * as Schema22 from "effect/Schema";
@@ -3661,303 +3680,325 @@ var NetworkHostQuery = Schema23.Struct({
   repoBindingId: Schema23.optionalKey(Id)
 });
 
-// packages/core/src/secret.ts
+// packages/core/src/test-report.ts
 import * as Schema24 from "effect/Schema";
-var SecretName2 = Schema24.String.check(Schema24.isPattern(new RegExp("^[A-Za-z_][A-Za-z0-9_]*$", "u")), Schema24.isMinLength(1), Schema24.isMaxLength(128));
-var SecretScope = Schema24.Union([Schema24.Literal("workspace"), Schema24.Literal("team")]);
-var SecretHost = Schema24.String.check(Schema24.isPattern(new RegExp("^(\\*\\.)?[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*(?::[0-9]{1,5})?$", "u")), Schema24.isMaxLength(260));
-var SecretHosts = Schema24.Array(SecretHost).check(Schema24.isMaxLength(32));
-var SecretSummary = Schema24.Struct({
+var maxSkippedTests = 1e4;
+var maxRanDigests = 1e5;
+var TestId = Schema24.String.check(Schema24.isMinLength(1), Schema24.isMaxLength(1000));
+var CheckTests = Schema24.Struct({
+  reports: Schema24.Int.check(Schema24.isGreaterThanOrEqualTo(0)),
+  passed: Schema24.Int.check(Schema24.isGreaterThanOrEqualTo(0)),
+  failed: Schema24.Int.check(Schema24.isGreaterThanOrEqualTo(0)),
+  skipped: Schema24.Int.check(Schema24.isGreaterThanOrEqualTo(0)),
+  skippedTests: Schema24.Array(TestId).check(Schema24.isMaxLength(maxSkippedTests)),
+  ranDigests: Schema24.Array(Schema24.String.check(Schema24.isMaxLength(16))).check(Schema24.isMaxLength(maxRanDigests))
+});
+var entities = new Map([
+  ["amp", "&"],
+  ["lt", "<"],
+  ["gt", ">"],
+  ["quot", '"'],
+  ["apos", "'"]
+]);
+
+// packages/core/src/secret.ts
+import * as Schema25 from "effect/Schema";
+var SecretName2 = Schema25.String.check(Schema25.isPattern(new RegExp("^[A-Za-z_][A-Za-z0-9_]*$", "u")), Schema25.isMinLength(1), Schema25.isMaxLength(128));
+var SecretScope = Schema25.Union([Schema25.Literal("workspace"), Schema25.Literal("team")]);
+var SecretHost = Schema25.String.check(Schema25.isPattern(new RegExp("^(\\*\\.)?[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*(?::[0-9]{1,5})?$", "u")), Schema25.isMaxLength(260));
+var SecretHosts = Schema25.Array(SecretHost).check(Schema25.isMaxLength(32));
+var SecretSummary = Schema25.Struct({
   name: SecretName2,
   scope: SecretScope,
-  teamId: Schema24.optionalKey(Id),
+  teamId: Schema25.optionalKey(Id),
   hosts: SecretHosts,
   setByActorType: ActorType,
-  setByActorId: Schema24.String,
+  setByActorId: Schema25.String,
   setAt: Timestamp
 });
-var SecretList = Schema24.Struct({ items: Schema24.Array(SecretSummary) });
-var SecretSet = Schema24.Struct({
-  value: Schema24.String.check(Schema24.isMinLength(1), Schema24.isMaxLength(65536)),
-  teamId: Schema24.optionalKey(Schema24.String.check(Schema24.isMinLength(1))),
-  hosts: Schema24.optionalKey(SecretHosts)
+var SecretList = Schema25.Struct({ items: Schema25.Array(SecretSummary) });
+var SecretSet = Schema25.Struct({
+  value: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(65536)),
+  teamId: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
+  hosts: Schema25.optionalKey(SecretHosts)
 });
-var SecretScopeQuery = Schema24.Struct({ teamId: Schema24.optionalKey(Id) });
+var SecretScopeQuery = Schema25.Struct({ teamId: Schema25.optionalKey(Id) });
 
 // packages/core/src/work-unit.ts
-var WorkUnitLease = Schema25.Struct({
+var WorkUnitLease = Schema26.Struct({
   leaseOwnerId: Id,
   runnerReplicaId: Id,
   leaseId: Id,
-  attempt: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1)),
-  fencingToken: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240), Schema25.isPattern(new RegExp("^[A-Za-z0-9._:-]+$", "u"))),
-  capacitySlot: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
+  attempt: Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1)),
+  fencingToken: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240), Schema26.isPattern(new RegExp("^[A-Za-z0-9._:-]+$", "u"))),
+  capacitySlot: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
   leaseExpiresAt: Timestamp,
   lastHeartbeatAt: Timestamp
 });
-var WorkUnitLeaseProjection = Schema25.Struct(Struct23.map(WorkUnitLease.fields, Schema25.optionalKey));
-var WorkUnitRepoBinding = Schema25.Struct({
+var WorkUnitLeaseProjection = Schema26.Struct(Struct24.map(WorkUnitLease.fields, Schema26.optionalKey));
+var WorkUnitRepoBinding = Schema26.Struct({
   id: Id,
   provider: RepoBindingProvider,
-  host: Schema25.String.check(Schema25.isMinLength(1)),
-  owner: Schema25.String.check(Schema25.isMinLength(1)),
-  name: Schema25.String.check(Schema25.isMinLength(1)),
-  repositoryUrl: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  pathPrefix: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  defaultTargetBranch: Schema25.String.check(Schema25.isMinLength(1)),
-  expectedBranch: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  expectedCommitSha: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1)))
-});
-var WorkUnitLeaseInput = Schema25.Struct({
+  host: Schema26.String.check(Schema26.isMinLength(1)),
+  owner: Schema26.String.check(Schema26.isMinLength(1)),
+  name: Schema26.String.check(Schema26.isMinLength(1)),
+  repositoryUrl: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  pathPrefix: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  defaultTargetBranch: Schema26.String.check(Schema26.isMinLength(1)),
+  expectedBranch: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  expectedCommitSha: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1)))
+});
+var WorkUnitLeaseInput = Schema26.Struct({
   leaseOwnerId: Id,
   runnerReplicaId: Id,
   leaseId: Id,
-  attempt: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1)),
-  fencingToken: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240), Schema25.isPattern(new RegExp("^[A-Za-z0-9._:-]+$", "u"))),
-  capacitySlot: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240))
-});
-var WorkUnitStatus = Schema25.Union([
-  Schema25.Literal("pending"),
-  Schema25.Literal("claimed"),
-  Schema25.Literal("running"),
-  Schema25.Literal("waiting"),
-  Schema25.Literal("blocked"),
-  Schema25.Literal("completed"),
-  Schema25.Literal("failed"),
-  Schema25.Literal("canceled"),
-  Schema25.Literal("expired")
+  attempt: Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1)),
+  fencingToken: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240), Schema26.isPattern(new RegExp("^[A-Za-z0-9._:-]+$", "u"))),
+  capacitySlot: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240))
+});
+var WorkUnitStatus = Schema26.Union([
+  Schema26.Literal("pending"),
+  Schema26.Literal("claimed"),
+  Schema26.Literal("running"),
+  Schema26.Literal("waiting"),
+  Schema26.Literal("blocked"),
+  Schema26.Literal("completed"),
+  Schema26.Literal("failed"),
+  Schema26.Literal("canceled"),
+  Schema26.Literal("expired")
 ]);
-var LoopCheckout = Schema25.Union([Schema25.Literal("none"), Schema25.Literal("read"), Schema25.Literal("write")]);
-var StorageOrigin = Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(2048)));
-var SecretDestination = Schema25.Struct({
+var LoopCheckout = Schema26.Union([Schema26.Literal("none"), Schema26.Literal("read"), Schema26.Literal("write")]);
+var StorageOrigin = Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(2048)));
+var SecretDestination = Schema26.Struct({
   scope: SecretScope,
   hosts: SecretHosts,
-  version: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(128))
+  version: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(128))
 });
-var AgentStepWorkUnit = Schema25.Struct({
-  kind: Schema25.Literal("agent_step"),
+var AgentStepWorkUnit = Schema26.Struct({
+  kind: Schema26.Literal("agent_step"),
   id: Id,
-  teamId: Schema25.optionalKey(Id),
+  teamId: Schema26.optionalKey(Id),
   runId: Id,
-  stepKey: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
-  attempt: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1)),
+  stepKey: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
+  attempt: Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1)),
   lease: WorkUnitLease,
-  deadlineAt: Schema25.optionalKey(Timestamp),
+  deadlineAt: Schema26.optionalKey(Timestamp),
   brief: StepBrief,
-  stepCredential: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(512)),
+  stepCredential: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(512)),
   checkout: LoopCheckout,
-  repoBinding: Schema25.optionalKey(WorkUnitRepoBinding),
-  branch: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  baseRevision: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  network: Schema25.optionalKey(AgentSandboxNetwork),
-  hosts: Schema25.optionalKey(Schema25.Array(NetworkHost)),
-  sandbox: Schema25.optionalKey(Schema25.Literal("docker")),
-  secrets: Schema25.optionalKey(Schema25.Record(Schema25.String, Schema25.String)),
-  secretDestinations: Schema25.optionalKey(Schema25.Record(Schema25.String, SecretDestination)),
-  runBaseRevision: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  mergeTarget: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1))),
-  resumeNotes: Schema25.optionalKey(Schema25.Array(Schema25.String)),
-  transcriptSequence: Schema25.optionalKey(Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1))),
+  repoBinding: Schema26.optionalKey(WorkUnitRepoBinding),
+  branch: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  baseRevision: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  network: Schema26.optionalKey(AgentSandboxNetwork),
+  hosts: Schema26.optionalKey(Schema26.Array(NetworkHost)),
+  sandbox: Schema26.optionalKey(Schema26.Literal("docker")),
+  secrets: Schema26.optionalKey(Schema26.Record(Schema26.String, Schema26.String)),
+  secretDestinations: Schema26.optionalKey(Schema26.Record(Schema26.String, SecretDestination)),
+  runBaseRevision: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  mergeTarget: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1))),
+  resumeNotes: Schema26.optionalKey(Schema26.Array(Schema26.String)),
+  transcriptSequence: Schema26.optionalKey(Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1))),
   storageOrigin: StorageOrigin
 });
-var RunJournal = Schema25.Struct({
-  activities: Schema25.Record(Schema25.String, Schema25.Unknown),
-  deferreds: Schema25.Record(Schema25.String, Schema25.Unknown)
+var RunJournal = Schema26.Struct({
+  activities: Schema26.Record(Schema26.String, Schema26.Unknown),
+  deferreds: Schema26.Record(Schema26.String, Schema26.Unknown)
 });
-var OrchestrationWorkUnit = Schema25.Struct({
-  kind: Schema25.Literal("orchestration"),
+var OrchestrationWorkUnit = Schema26.Struct({
+  kind: Schema26.Literal("orchestration"),
   id: Id,
-  teamId: Schema25.optionalKey(Id),
+  teamId: Schema26.optionalKey(Id),
   runId: Id,
-  loopDigest: Schema25.String.check(Schema25.isMinLength(64), Schema25.isMaxLength(64), Schema25.isPattern(new RegExp("^[a-f0-9]{64}$", "u"))),
-  input: Schema25.Unknown,
-  granted: Schema25.Array(Schema25.String),
+  loopDigest: Schema26.String.check(Schema26.isMinLength(64), Schema26.isMaxLength(64), Schema26.isPattern(new RegExp("^[a-f0-9]{64}$", "u"))),
+  input: Schema26.Unknown,
+  granted: Schema26.Array(Schema26.String),
   lease: WorkUnitLease,
   journal: RunJournal,
-  network: Schema25.optionalKey(AgentSandboxNetwork),
+  network: Schema26.optionalKey(AgentSandboxNetwork),
   storageOrigin: StorageOrigin,
-  program: Schema25.Struct({
-    loopId: Schema25.String.check(Schema25.isMinLength(1)),
-    credential: Schema25.String.check(Schema25.isMinLength(1))
+  program: Schema26.Struct({
+    loopId: Schema26.String.check(Schema26.isMinLength(1)),
+    credential: Schema26.String.check(Schema26.isMinLength(1))
   })
 });
-var ProgramWorkUnit = OrchestrationWorkUnit.mapFields(Struct23.omit(["program"]));
-var CheckName2 = Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(120), Schema25.isPattern(new RegExp("^[A-Za-z0-9][A-Za-z0-9._:-]*$", "u")));
-var ApprovedCheck = Schema25.Struct({
+var ProgramWorkUnit = OrchestrationWorkUnit.mapFields(Struct24.omit(["program"]));
+var CheckName2 = Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(120), Schema26.isPattern(new RegExp("^[A-Za-z0-9][A-Za-z0-9._:-]*$", "u")));
+var ApprovedCheck = Schema26.Struct({
   name: CheckName2,
-  command: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(2000)),
-  workingDirectory: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(500))),
-  suggested: Schema25.optionalKey(Schema25.Boolean)
+  command: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(2000)),
+  workingDirectory: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(500))),
+  suggested: Schema26.optionalKey(Schema26.Boolean)
 });
-var RepositoryCheck = Schema25.Struct({
+var RepositoryCheck = Schema26.Struct({
   ...ApprovedCheck.fields,
-  pipeline: Schema25.optionalKey(Schema25.Boolean)
-});
-var MetricName = Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(80), Schema25.isPattern(new RegExp("^[A-Za-z0-9][A-Za-z0-9._:-]*$", "u")));
-var MeasurePlan2 = Schema25.Struct({
-  command: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(2000)),
-  prepare: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(2000))),
-  workingDirectory: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(500))),
-  warmup: Schema25.optionalKey(Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0), Schema25.isLessThanOrEqualTo(10))),
-  metrics: Schema25.Array(Schema25.Struct({
+  pipeline: Schema26.optionalKey(Schema26.Boolean)
+});
+var MetricName = Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(80), Schema26.isPattern(new RegExp("^[A-Za-z0-9][A-Za-z0-9._:-]*$", "u")));
+var MeasurePlan2 = Schema26.Struct({
+  command: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(2000)),
+  prepare: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(2000))),
+  workingDirectory: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(500))),
+  warmup: Schema26.optionalKey(Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(0), Schema26.isLessThanOrEqualTo(10))),
+  metrics: Schema26.Array(Schema26.Struct({
     name: MetricName,
-    direction: Schema25.Literals(["lower", "higher"]),
-    role: Schema25.Literals(["primary", "guardrail"]),
-    lowVariance: Schema25.optionalKey(Schema25.Boolean)
-  })).check(Schema25.isMinLength(1), Schema25.isMaxLength(20))
+    direction: Schema26.Literals(["lower", "higher"]),
+    role: Schema26.Literals(["primary", "guardrail"]),
+    lowVariance: Schema26.optionalKey(Schema26.Boolean)
+  })).check(Schema26.isMinLength(1), Schema26.isMaxLength(20))
 });
-var MeasureSpec = Schema25.Struct({
-  base: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
+var MeasureSpec = Schema26.Struct({
+  base: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
   plan: MeasurePlan2,
-  samples: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1), Schema25.isLessThanOrEqualTo(50)),
-  calibrate: Schema25.Boolean
+  samples: Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1), Schema26.isLessThanOrEqualTo(50)),
+  calibrate: Schema26.Boolean
 });
-var MeasureSample = Schema25.Record(MetricName, Schema25.Finite);
-var MeasureSamples = Schema25.Array(MeasureSample).check(Schema25.isMaxLength(50));
-var MeasureEvidence = Schema25.Struct({
+var MeasureSample = Schema26.Record(MetricName, Schema26.Finite);
+var MeasureSamples = Schema26.Array(MeasureSample).check(Schema26.isMaxLength(50));
+var MeasureEvidence = Schema26.Struct({
   base: MeasureSamples,
   head: MeasureSamples,
-  baseAgain: Schema25.optionalKey(MeasureSamples)
+  baseAgain: Schema26.optionalKey(MeasureSamples)
 });
-var VerificationWorkUnit = Schema25.Struct({
-  kind: Schema25.Literal("verification"),
+var VerificationWorkUnit = Schema26.Struct({
+  kind: Schema26.Literal("verification"),
   id: Id,
-  teamId: Schema25.optionalKey(Id),
+  teamId: Schema26.optionalKey(Id),
   runId: Id,
-  stepKey: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
+  stepKey: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
   lease: WorkUnitLease,
   repoBinding: WorkUnitRepoBinding,
-  revision: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
-  baseline: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(300))),
-  checks: Schema25.Array(RepositoryCheck).check(Schema25.isMaxLength(50)),
-  measure: Schema25.optionalKey(MeasureSpec),
-  hosts: Schema25.optionalKey(Schema25.Array(NetworkHost)),
+  revision: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
+  baseline: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(300))),
+  checks: Schema26.Array(RepositoryCheck).check(Schema26.isMaxLength(50)),
+  measure: Schema26.optionalKey(MeasureSpec),
+  hosts: Schema26.optionalKey(Schema26.Array(NetworkHost)),
   storageOrigin: StorageOrigin
 });
-var WorkUnit = Schema25.Union([OrchestrationWorkUnit, AgentStepWorkUnit, VerificationWorkUnit]);
-var WorkUnitClaimResult = Schema25.Struct({ workUnit: Schema25.optionalKey(WorkUnit) });
-var WorkUnitClaimInput = Schema25.Struct({
-  teamId: Schema25.optionalKey(Id),
+var WorkUnit = Schema26.Union([OrchestrationWorkUnit, AgentStepWorkUnit, VerificationWorkUnit]);
+var WorkUnitClaimResult = Schema26.Struct({ workUnit: Schema26.optionalKey(WorkUnit) });
+var WorkUnitClaimInput = Schema26.Struct({
+  teamId: Schema26.optionalKey(Id),
   runnerReplicaId: Id,
-  capacitySlot: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
-  idempotencyKey: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
-  leaseDurationSeconds: Schema25.optionalKey(Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1), Schema25.isLessThanOrEqualTo(3600)))
+  capacitySlot: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
+  idempotencyKey: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
+  leaseDurationSeconds: Schema26.optionalKey(Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1), Schema26.isLessThanOrEqualTo(3600)))
 });
-var WorkUnitHeartbeatInput = Schema25.Struct({
+var WorkUnitHeartbeatInput = Schema26.Struct({
   workUnitId: Id,
   lease: WorkUnitLeaseInput,
-  leaseDurationSeconds: Schema25.optionalKey(Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(1), Schema25.isLessThanOrEqualTo(3600))),
-  secrets: Schema25.optionalKey(Schema25.Array(Schema25.Struct({ name: SecretName2, version: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(128)) })).check(Schema25.isMaxLength(256)))
+  leaseDurationSeconds: Schema26.optionalKey(Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(1), Schema26.isLessThanOrEqualTo(3600))),
+  secrets: Schema26.optionalKey(Schema26.Array(Schema26.Struct({ name: SecretName2, version: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(128)) })).check(Schema26.isMaxLength(256)))
 });
-var WorkUnitHeartbeatResult = Schema25.Struct({
-  settled: Schema25.Boolean,
-  outputSubmitted: Schema25.optionalKey(Schema25.Boolean),
-  outputMerged: Schema25.optionalKey(Schema25.Boolean),
-  questionOpen: Schema25.optionalKey(Schema25.Boolean),
-  revokedSecrets: Schema25.optionalKey(Schema25.Array(SecretName2))
+var WorkUnitHeartbeatResult = Schema26.Struct({
+  settled: Schema26.Boolean,
+  outputSubmitted: Schema26.optionalKey(Schema26.Boolean),
+  outputMerged: Schema26.optionalKey(Schema26.Boolean),
+  questionOpen: Schema26.optionalKey(Schema26.Boolean),
+  revokedSecrets: Schema26.optionalKey(Schema26.Array(SecretName2))
 });
-var WorkUnitReleaseInput = Schema25.Struct({
+var WorkUnitReleaseInput = Schema26.Struct({
   workUnitId: Id,
   lease: WorkUnitLeaseInput,
-  crashed: Schema25.optionalKey(Schema25.Struct({ reason: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(500)) }))
-});
-var CheckEvidence = Schema25.Struct({
-  name: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(120)),
-  command: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(2000)),
-  status: Schema25.Union([Schema25.Literal("passed"), Schema25.Literal("failed")]),
-  exitCode: Schema25.optionalKey(Schema25.Int),
-  durationMs: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0)),
-  outputTail: Schema25.String.check(Schema25.isMaxLength(8000)),
-  fileIds: Schema25.optionalKey(Schema25.Array(Schema25.String).check(Schema25.isMaxLength(51)))
-});
-var TreeEvidence = Schema25.Struct({
-  revision: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
-  tree: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(120)),
-  checks: Schema25.Array(CheckEvidence).check(Schema25.isMaxLength(50))
-});
-var VerificationEvidence = Schema25.Struct({
+  crashed: Schema26.optionalKey(Schema26.Struct({ reason: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(500)) }))
+});
+var CheckEvidence = Schema26.Struct({
+  name: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(120)),
+  command: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(2000)),
+  status: Schema26.Union([Schema26.Literal("passed"), Schema26.Literal("failed")]),
+  exitCode: Schema26.optionalKey(Schema26.Int),
+  durationMs: Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(0)),
+  outputTail: Schema26.String.check(Schema26.isMaxLength(8000)),
+  fileIds: Schema26.optionalKey(Schema26.Array(Schema26.String).check(Schema26.isMaxLength(51))),
+  tests: Schema26.optionalKey(CheckTests)
+});
+var TreeEvidence = Schema26.Struct({
+  revision: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
+  tree: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(120)),
+  checks: Schema26.Array(CheckEvidence).check(Schema26.isMaxLength(50))
+});
+var VerificationEvidence = Schema26.Struct({
   head: TreeEvidence,
-  baseline: Schema25.optionalKey(TreeEvidence),
-  measurement: Schema25.optionalKey(MeasureEvidence)
-});
-var BoundaryChange = Schema25.Struct({
-  kind: Schema25.Literal("change"),
-  changedPaths: Schema25.Array(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(4096))).check(Schema25.isMaxLength(1000)),
-  omittedPaths: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0)),
-  files: Schema25.Array(Schema25.Struct({
-    path: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(4096)),
-    excerpt: Schema25.String.check(Schema25.isMaxLength(250000)),
-    redacted: Schema25.Boolean,
-    truncated: Schema25.Boolean
-  })).check(Schema25.isMaxLength(20)),
-  truncated: Schema25.Boolean
+  baseline: Schema26.optionalKey(TreeEvidence),
+  measurement: Schema26.optionalKey(MeasureEvidence)
+});
+var BoundaryChange = Schema26.Struct({
+  kind: Schema26.Literal("change"),
+  changedPaths: Schema26.Array(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(4096))).check(Schema26.isMaxLength(1000)),
+  omittedPaths: Schema26.Int.check(Schema26.isGreaterThanOrEqualTo(0)),
+  files: Schema26.Array(Schema26.Struct({
+    path: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(4096)),
+    excerpt: Schema26.String.check(Schema26.isMaxLength(250000)),
+    redacted: Schema26.Boolean,
+    truncated: Schema26.Boolean
+  })).check(Schema26.isMaxLength(20)),
+  truncated: Schema26.Boolean
 });
 var catchUpPathLimit = 200;
-var CatchUpPaths = Schema25.Array(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(1000))).check(Schema25.isMaxLength(catchUpPathLimit));
-var Revision = Schema25.String.check(Schema25.isPattern(/^[0-9a-f]{40,64}$/));
-var CatchUp = Schema25.Struct({
+var CatchUpPaths = Schema26.Array(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(1000))).check(Schema26.isMaxLength(catchUpPathLimit));
+var Revision = Schema26.String.check(Schema26.isPattern(/^[0-9a-f]{40,64}$/));
+var CatchUp = Schema26.Struct({
   from: Revision,
   head: Revision,
   conflicted: CatchUpPaths,
   rewritten: CatchUpPaths,
   changed: CatchUpPaths,
-  truncated: Schema25.Boolean
-});
-var HarnessHold = Schema25.Struct({
-  reason: Schema25.Literals(HarnessHoldReasons),
-  until: Schema25.optionalKey(Timestamp),
-  scope: Schema25.optionalKey(Schema25.Literal("step"))
-});
-var StepRestart = Schema25.Struct({ reason: Schema25.Literal("login_revoked") });
-var WorkUnitOutcome = Schema25.Struct({
-  status: Schema25.Union([
-    Schema25.Literal("completed"),
-    Schema25.Literal("failed"),
-    Schema25.Literal("blocked"),
-    Schema25.Literal("canceled")
+  truncated: Schema26.Boolean
+});
+var HarnessHold = Schema26.Struct({
+  reason: Schema26.Literals(HarnessHoldReasons),
+  until: Schema26.optionalKey(Timestamp),
+  scope: Schema26.optionalKey(Schema26.Literal("step"))
+});
+var StepRestart = Schema26.Struct({ reason: Schema26.Literal("login_revoked") });
+var WorkUnitOutcome = Schema26.Struct({
+  status: Schema26.Union([
+    Schema26.Literal("completed"),
+    Schema26.Literal("failed"),
+    Schema26.Literal("blocked"),
+    Schema26.Literal("canceled")
   ]),
-  result: Schema25.optionalKey(LoopStepOutput),
-  revision: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(120))),
-  evidence: Schema25.optionalKey(VerificationEvidence),
-  boundary: Schema25.optionalKey(BoundaryChange),
-  catchUp: Schema25.optionalKey(CatchUp),
-  harnessHold: Schema25.optionalKey(HarnessHold),
-  restart: Schema25.optionalKey(StepRestart),
-  failureSummary: Schema25.optionalKey(Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(4000)))
-});
-var WorkUnitCompletion = Schema25.Struct({
+  result: Schema26.optionalKey(LoopStepOutput),
+  revision: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(120))),
+  evidence: Schema26.optionalKey(VerificationEvidence),
+  boundary: Schema26.optionalKey(BoundaryChange),
+  catchUp: Schema26.optionalKey(CatchUp),
+  harnessHold: Schema26.optionalKey(HarnessHold),
+  restart: Schema26.optionalKey(StepRestart),
+  failureSummary: Schema26.optionalKey(Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(4000)))
+});
+var WorkUnitCompletion = Schema26.Struct({
   workUnitId: Id,
   lease: WorkUnitLeaseInput,
-  idempotencyKey: Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(240)),
+  idempotencyKey: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(240)),
   outcome: WorkUnitOutcome
 });
 
 // packages/sdk/src/loop/measure.ts
 import * as Effect7 from "effect/Effect";
-import * as Schema26 from "effect/Schema";
+import * as Schema27 from "effect/Schema";
 import { DurableDeferred as DurableDeferred3 } from "effect/workflow";
-var MetricStats2 = Schema26.Struct({
-  samples: Schema26.Finite,
-  median: Schema26.Finite,
-  mean: Schema26.Finite,
-  min: Schema26.Finite,
-  max: Schema26.Finite,
-  stdev: Schema26.Finite
-});
-var MeasureVerdict2 = Schema26.Literals(["gain", "no_gain", "guardrail_regressed", "too_noisy"]);
-var Measurement2 = Schema26.Struct({
+var MetricStats2 = Schema27.Struct({
+  samples: Schema27.Finite,
+  median: Schema27.Finite,
+  mean: Schema27.Finite,
+  min: Schema27.Finite,
+  max: Schema27.Finite,
+  stdev: Schema27.Finite
+});
+var MeasureVerdict2 = Schema27.Literals(["gain", "no_gain", "guardrail_regressed", "too_noisy"]);
+var Measurement2 = Schema27.Struct({
   verdict: MeasureVerdict2,
-  reason: Schema26.String,
-  metrics: Schema26.Array(Schema26.Struct({
-    name: Schema26.String,
-    role: Schema26.Literals(["primary", "guardrail"]),
-    direction: Schema26.Literals(["lower", "higher"]),
+  reason: Schema27.String,
+  metrics: Schema27.Array(Schema27.Struct({
+    name: Schema27.String,
+    role: Schema27.Literals(["primary", "guardrail"]),
+    direction: Schema27.Literals(["lower", "higher"]),
     base: MetricStats2,
     head: MetricStats2,
-    change: Schema26.Finite,
-    noise: Schema26.Finite
+    change: Schema27.Finite,
+    noise: Schema27.Finite
   })),
-  suggestion: Schema26.optional(Schema26.String),
+  suggestion: Schema27.optional(Schema27.String),
   evidence: MeasureEvidence
 });
 var measureDeferred2 = (step) => DurableDeferred3.make(`measure/${step}`, { success: MeasureEvidence, error: StepFailed2 });
@@ -4055,9 +4096,9 @@ var measure2 = (name, request) => takeStep2(name, "measure", "measure", Effect7.
 }));
 
 // packages/sdk/src/loop/test-loop.ts
-var LoopJournal2 = Schema27.Struct({
-  activities: Schema27.Record(Schema27.String, Schema27.Json),
-  deferreds: Schema27.Record(Schema27.String, Schema27.Json)
+var LoopJournal2 = Schema28.Struct({
+  activities: Schema28.Record(Schema28.String, Schema28.Json),
+  deferreds: Schema28.Record(Schema28.String, Schema28.Json)
 });
 
 class ScriptedFailure2 extends Data2.TaggedClass("ScriptedFailure") {
@@ -4111,7 +4152,7 @@ var defaultActivities = {
   draftUpdate: { run: (_, step) => Effect8.succeed({ id: `draft-${step}` }) }
 };
 var withoutServices = (effect) => Effect8.orDie(Effect8.provide(effect, Context3.empty()));
-var deferredExit = (deferred) => Schema27.Exit(Schema27.toCodecJson(deferred.successSchema), Schema27.toCodecJson(deferred.errorSchema), Schema27.toCodecJson(Schema27.Defect()));
+var deferredExit = (deferred) => Schema28.Exit(Schema28.toCodecJson(deferred.successSchema), Schema28.toCodecJson(deferred.errorSchema), Schema28.toCodecJson(Schema28.Defect()));
 var journaled = (engine, journal, ran) => ({
   ...engine,
   activityExecute: (activity, attempt) => Effect8.gen(function* () {
@@ -4119,22 +4160,22 @@ var journaled = (engine, journal, ran) => ({
     const recorded = journal.activities[key];
     if (recorded !== undefined)
       return new Workflow.Complete({
-        exit: yield* withoutServices(Schema27.decodeEffect(Schema27.toCodecJson(activity.exitSchema))(recorded))
+        exit: yield* withoutServices(Schema28.decodeEffect(Schema28.toCodecJson(activity.exitSchema))(recorded))
       });
     const result = yield* engine.activityExecute(activity, attempt);
     if (result instanceof Workflow.Complete) {
       ran.push(activity.name);
-      journal.activities[key] = yield* withoutServices(Schema27.encodeEffect(Schema27.toCodecJson(activity.exitSchema))(result.exit));
+      journal.activities[key] = yield* withoutServices(Schema28.encodeEffect(Schema28.toCodecJson(activity.exitSchema))(result.exit));
     }
     return result;
   }),
   deferredResult: (deferred) => Effect8.gen(function* () {
     const recorded = journal.deferreds[deferred.name];
     if (recorded !== undefined)
-      return Option2.some(yield* withoutServices(Schema27.decodeEffect(Schema27.toCodecJson(deferredExit(deferred)))(recorded)));
+      return Option2.some(yield* withoutServices(Schema28.decodeEffect(Schema28.toCodecJson(deferredExit(deferred)))(recorded)));
     const result = yield* engine.deferredResult(deferred);
     if (Option2.isSome(result))
-      journal.deferreds[deferred.name] = yield* withoutServices(Schema27.encodeEffect(Schema27.toCodecJson(deferredExit(deferred)))(result.value));
+      journal.deferreds[deferred.name] = yield* withoutServices(Schema28.encodeEffect(Schema28.toCodecJson(deferredExit(deferred)))(result.value));
     return result;
   })
 });
@@ -4199,13 +4240,13 @@ var scriptedHost = (script, engine, agentLaunches, childLaunches, waits, verifyL
   };
 };
 var loopWorkflow2 = (loop) => Workflow.make(`kitman-loop/${loop.id}`, {
-  payload: { input: Schema27.Json },
+  payload: { input: Schema28.Json },
   idempotencyKey: () => loop.id,
   success: loop.output,
-  error: Schema27.declare((_error) => true)
+  error: Schema28.declare((_error) => true)
 });
 var executeLoop2 = (loop, runtime) => ({ input }) => Effect8.gen(function* () {
-  const decoded = yield* Schema27.decodeEffect(Schema27.toCodecJson(loop.input))(input).pipe(Effect8.mapError((error) => new InputInvalid2({ loop: loop.id, message: error.message })));
+  const decoded = yield* Schema28.decodeEffect(Schema28.toCodecJson(loop.input))(input).pipe(Effect8.mapError((error) => new InputInvalid2({ loop: loop.id, message: error.message })));
   const run = LoopRun2.of({
     loop: loop.id,
     agents: loop.agents,
@@ -4253,22 +4294,22 @@ var testLoop2 = (loop, script) => {
   }).pipe(Effect8.provide(workflow.toLayer(execute).pipe(Layer.provideMerge(WorkflowEngine.layerMemory))));
 };
 // packages/sdk/src/loop/review.ts
-import * as Schema28 from "effect/Schema";
-var Severity2 = Schema28.Literals(["blocker", "major", "minor"]);
-var Finding2 = Schema28.Struct({
+import * as Schema29 from "effect/Schema";
+var Severity2 = Schema29.Literals(["blocker", "major", "minor"]);
+var Finding2 = Schema29.Struct({
   severity: Severity2,
-  file: Schema28.String,
-  line: Schema28.Int,
-  detail: Schema28.String
+  file: Schema29.String,
+  line: Schema29.Int,
+  detail: Schema29.String
 });
-var MergedFinding2 = Schema28.Struct({
-  id: Schema28.String,
+var MergedFinding2 = Schema29.Struct({
+  id: Schema29.String,
   ...Finding2.fields,
-  seats: Schema28.Array(Schema28.String)
+  seats: Schema29.Array(Schema29.String)
 });
-var Rebuttal2 = Schema28.Struct({ findingId: Schema28.String, reason: Schema28.String });
-var RebuttalVerdict2 = Schema28.Struct({ findingId: Schema28.String, accepted: Schema28.Boolean });
-var ScopeJudgement2 = Schema28.Struct({ met: Schema28.Boolean, unmet: Schema28.Array(Schema28.String) });
+var Rebuttal2 = Schema29.Struct({ findingId: Schema29.String, reason: Schema29.String });
+var RebuttalVerdict2 = Schema29.Struct({ findingId: Schema29.String, accepted: Schema29.Boolean });
+var ScopeJudgement2 = Schema29.Struct({ met: Schema29.Boolean, unmet: Schema29.Array(Schema29.String) });
 var rank = { blocker: 0, major: 1, minor: 2 };
 var isBlocking2 = (finding) => finding.severity !== "minor";
 var mergeFindings2 = (bySeat) => {
@@ -4326,11 +4367,11 @@ import * as Cause2 from "effect/Cause";
 import * as Effect9 from "effect/Effect";
 import * as Exit5 from "effect/Exit";
 import * as Predicate3 from "effect/Predicate";
-import * as Schema29 from "effect/Schema";
-class CheckFailed2 extends Schema29.TaggedError()("CheckFailed", {
-  loop: Schema29.String,
-  check: Schema29.String,
-  reason: Schema29.String
+import * as Schema30 from "effect/Schema";
+class CheckFailed2 extends Schema30.TaggedError()("CheckFailed", {
+  loop: Schema30.String,
+  check: Schema30.String,
+  reason: Schema30.String
 }) {
   get detail() {
     return `Check "${this.check}": ${this.reason}`;
@@ -4340,10 +4381,10 @@ class CheckFailed2 extends Schema29.TaggedError()("CheckFailed", {
   }
 }
 
-class StepNamedTwice2 extends Schema29.TaggedError()("StepNamedTwice", {
-  loop: Schema29.String,
-  check: Schema29.String,
-  step: Schema29.String
+class StepNamedTwice2 extends Schema30.TaggedError()("StepNamedTwice", {
+  loop: Schema30.String,
+  check: Schema30.String,
+  step: Schema30.String
 }) {
   get detail() {
     return `Check "${this.check}": Step "${this.step}" is named twice`;
@@ -4353,12 +4394,12 @@ class StepNamedTwice2 extends Schema29.TaggedError()("StepNamedTwice", {
   }
 }
 
-class ReplayDiverged2 extends Schema29.TaggedError()("ReplayDiverged", {
-  loop: Schema29.String,
-  check: Schema29.String,
-  first: Schema29.Array(Schema29.String),
-  replay: Schema29.Array(Schema29.String),
-  rerun: Schema29.Array(Schema29.String)
+class ReplayDiverged2 extends Schema30.TaggedError()("ReplayDiverged", {
+  loop: Schema30.String,
+  check: Schema30.String,
+  first: Schema30.Array(Schema30.String),
+  replay: Schema30.Array(Schema30.String),
+  rerun: Schema30.Array(Schema30.String)
 }) {
   get detail() {
     const steps = (names) => names.join(", ") || "no Steps";
@@ -4368,7 +4409,7 @@ class ReplayDiverged2 extends Schema29.TaggedError()("ReplayDiverged", {
     return `Loop "${this.loop}": ${this.detail}`;
   }
 }
-var LoopCheckError2 = Schema29.Union([CheckFailed2, StepNamedTwice2, ReplayDiverged2]);
+var LoopCheckError2 = Schema30.Union([CheckFailed2, StepNamedTwice2, ReplayDiverged2]);
 var checkLoop2 = (loop, check) => Effect9.gen(function* () {
   const first = yield* testLoop2(loop, check.script);
   if (Exit5.isFailure(first.result)) {
@@ -4395,21 +4436,21 @@ var checkLoop2 = (loop, check) => Effect9.gen(function* () {
 // packages/sdk/src/loop/config.ts
 var defineKit2 = (config) => ({ ...config, loops: config.loops ?? [] });
 // packages/sdk/src/loop/sync.ts
-import * as Schema30 from "effect/Schema";
-var UpToDate = Schema30.Struct({ status: Schema30.Literal("up_to_date") });
-var Conflict = Schema30.Struct({
-  status: Schema30.Literal("conflict"),
-  files: Schema30.NonEmptyArray(Schema30.String),
-  reason: Schema30.String
+import * as Schema31 from "effect/Schema";
+var UpToDate = Schema31.Struct({ status: Schema31.Literal("up_to_date") });
+var Conflict = Schema31.Struct({
+  status: Schema31.Literal("conflict"),
+  files: Schema31.NonEmptyArray(Schema31.String),
+  reason: Schema31.String
 });
 var merged = {
-  status: Schema30.Literal("merged"),
-  settled: Schema30.Array(Schema30.String)
+  status: Schema31.Literal("merged"),
+  settled: Schema31.Array(Schema31.String)
 };
-var SyncAnswer = Schema30.Union([UpToDate, Schema30.Struct(merged), Conflict]);
-var BaseSync2 = Schema30.Union([
+var SyncAnswer = Schema31.Union([UpToDate, Schema31.Struct(merged), Conflict]);
+var BaseSync2 = Schema31.Union([
   UpToDate,
-  Schema30.Struct({ ...merged, catchUp: Schema30.optionalKey(CatchUp) }),
+  Schema31.Struct({ ...merged, catchUp: Schema31.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.";
@@ -4430,17 +4471,17 @@ var syncBase2 = (name, options) => agentWorkAs2(syncDeferred2, name, {
   mergeTarget: options.target ?? "HEAD"
 });
 // packages/sdk/src/loop/continuing.ts
-import * as Schema31 from "effect/Schema";
-var Continuing2 = Schema31.Struct({
-  changeRequestId: Schema31.String,
-  number: Schema31.String,
-  url: Schema31.String,
-  branch: Schema31.String,
-  targetBranch: Schema31.String,
-  revision: Schema31.optional(Schema31.String),
-  lastRunId: Schema31.optional(Schema31.String),
-  lastRunStatus: Schema31.optional(Schema31.String),
-  lastRunSummary: Schema31.optional(Schema31.String)
+import * as Schema32 from "effect/Schema";
+var Continuing2 = Schema32.Struct({
+  changeRequestId: Schema32.String,
+  number: Schema32.String,
+  url: Schema32.String,
+  branch: Schema32.String,
+  targetBranch: Schema32.String,
+  revision: Schema32.optional(Schema32.String),
+  lastRunId: Schema32.optional(Schema32.String),
+  lastRunStatus: Schema32.optional(Schema32.String),
+  lastRunSummary: Schema32.optional(Schema32.String)
 });
 var continuingBrief2 = (continuing) => [
   `This continues the work on ${continuing.branch}, whose ChangeRequest is ${continuing.url}. Build on what is there; do not start over.`,
@@ -4453,4 +4494,4 @@ var continuingBrief2 = (continuing) => [
   "The ChangeRequest's description lists what was left unsettled; settle those first."
 ].join(`
 `);
-export { Numeric, isWholeNumber, guard, Id, Timestamp, canonicalJson, KitDigest, LoopCapabilities2, LoopManifest, AgentDeclaration, KitDeclarations, LoopOutcome2, capabilitiesOf2, defineLoop2, ManifestInvalid2, jsonSchemaOf2, loopManifest2, questionAdvice, EvidenceCheck2, VerifyResult2, OutcomeTable2, failsOn2, evidenceGate2, StepFailed2, OutputInvalid2, QuestionRefused2, WaitTimedOut2, ChangeRequestClosed2, ChildFailed2, CapabilityDenied2, DuplicateStep2, InputInvalid2, LoopEvent2, LoopRun2, LoopHost2, agentDeferredNamed2, agentWorkDeferred2, syncDeferred2, answerDeferred2, childDeferred2, eventDeferred2, verifyDeferred2, takeStep2, launch2, agentWork2, agentWorkAs2, agentWorkOnce2, ask2, call2, waitFor2, verify2, suggestVerification2, PlanTicket2, PlanTickets2, BlockingCycle2, planWaves2, ChangeRequestRequest2, ChangeRequestResult2, WriteBackMilestones2, WriteBackRequest2, RunFile2, FileRequest2, ArtifactRequest2, ArtifactResult2, NoteRequest2, CreateTasksRequest2, CreateTasksResult2, AlertTaskRequest2, AlertTaskResult2, IntegrationBranchRequest2, IntegrationBranch2, MergeChangeRequestRequest2, MergeResult2, ApproveChangeRequestRequest2, ApproveChangeRequestResult2, CloseChangeRequestRequest2, CloseChangeRequestResult2, RerunPipelineRequest2, RerunPipelineResult2, ReportPipelineRequest2, ReportPipelineResult2, CommentRequest2, ReleaseRequest2, ReleaseResult2, ChangeRequestReadRequest2, PipelineJob2, PipelineStatus2, ReviewThread2, ReviewThreads2, OpenChangeRequestsRequest2, OpenChangeRequest2, OpenChangeRequests2, OwnChangeRequest2, OwnChangeRequests2, TranscriptPoint2, TranscriptsRequest2, TranscriptsResult2, ProposeRequest2, ProposeResult2, ProjectActivityRequest2, ProjectActivityResult2, DraftUpdateRequest2, DraftUpdateResult2, ChangeRequestActivity2, WriteBackActivity2, ArtifactActivity2, FileActivity2, NoteActivity2, CommentActivity2, CreateTasksActivity2, AlertTaskActivity2, IntegrationBranchActivity2, MergeChangeRequestActivity2, ReleaseActivity2, TranscriptsActivity2, ProposeActivity2, ProjectActivityActivity2, DraftUpdateActivity2, ChangeRequestReadActivity2, changeRequest2, writeBack2, artifact2, file2, note2, comment2, createTasks2, alertTask2, integrationBranch2, mergeChangeRequest2, approveChangeRequest2, closeChangeRequest2, pipelineMoved2, rerunPipeline2, reportPipeline2, release2, transcripts2, propose2, projectActivity2, pipelineStatus2, reviewThreads2, openChangeRequests2, ownChangeRequests2, draftUpdate2, ResourceName, ClaimResult2, claimDeferred2, letGoDeferred2, claim2, letGo2, WorkUnitRepoBinding, ProgramWorkUnit, CheckName2, ApprovedCheck, MeasurePlan2, WorkUnitClaimResult, WorkUnitClaimInput, WorkUnitHeartbeatInput, WorkUnitHeartbeatResult, WorkUnitReleaseInput, WorkUnitCompletion, MetricStats2, MeasureVerdict2, Measurement2, measureDeferred2, noiseFloor2, judgeMeasurement2, measure2, LoopJournal2, ScriptedFailure2, scriptedFailure2, loopWorkflow2, executeLoop2, testLoop2, Severity2, Finding2, MergedFinding2, Rebuttal2, RebuttalVerdict2, ScopeJudgement2, isBlocking2, mergeFindings2, splitDisputed2, settleRound2, rallyStop2, CheckFailed2, StepNamedTwice2, ReplayDiverged2, LoopCheckError2, checkLoop2, defineKit2, BaseSync2, syncBase2, Continuing2, continuingBrief2 };
+export { Numeric, isWholeNumber, guard, Id, Timestamp, canonicalJson, KitDigest, LoopCapabilities2, LoopManifest, AgentDeclaration, KitDeclarations, LoopOutcome2, capabilitiesOf2, defineLoop2, ManifestInvalid2, jsonSchemaOf2, loopManifest2, questionAdvice, EvidenceCheck2, VerifyResult2, OutcomeTable2, failsOn2, testsNotRunReasons2, evidenceGate2, StepFailed2, OutputInvalid2, QuestionRefused2, WaitTimedOut2, ChangeRequestClosed2, ChildFailed2, CapabilityDenied2, DuplicateStep2, InputInvalid2, LoopEvent2, LoopRun2, LoopHost2, agentDeferredNamed2, agentWorkDeferred2, syncDeferred2, answerDeferred2, childDeferred2, eventDeferred2, verifyDeferred2, takeStep2, launch2, agentWork2, agentWorkAs2, agentWorkOnce2, ask2, call2, waitFor2, verify2, suggestVerification2, PlanTicket2, PlanTickets2, BlockingCycle2, planWaves2, ChangeRequestRequest2, ChangeRequestResult2, WriteBackMilestones2, WriteBackRequest2, RunFile2, FileRequest2, ArtifactRequest2, ArtifactResult2, NoteRequest2, CreateTasksRequest2, CreateTasksResult2, AlertTaskRequest2, AlertTaskResult2, IntegrationBranchRequest2, IntegrationBranch2, MergeChangeRequestRequest2, MergeResult2, ApproveChangeRequestRequest2, ApproveChangeRequestResult2, CloseChangeRequestRequest2, CloseChangeRequestResult2, RerunPipelineRequest2, RerunPipelineResult2, ReportPipelineRequest2, ReportPipelineResult2, CommentRequest2, ReleaseRequest2, ReleaseResult2, ChangeRequestReadRequest2, PipelineJob2, PipelineStatus2, ReviewThread2, ReviewThreads2, OpenChangeRequestsRequest2, OpenChangeRequest2, OpenChangeRequests2, OwnChangeRequest2, OwnChangeRequests2, TranscriptPoint2, TranscriptsRequest2, TranscriptsResult2, ProposeRequest2, ProposeResult2, ProjectActivityRequest2, ProjectActivityResult2, DraftUpdateRequest2, DraftUpdateResult2, ChangeRequestActivity2, WriteBackActivity2, ArtifactActivity2, FileActivity2, NoteActivity2, CommentActivity2, CreateTasksActivity2, AlertTaskActivity2, IntegrationBranchActivity2, MergeChangeRequestActivity2, ReleaseActivity2, TranscriptsActivity2, ProposeActivity2, ProjectActivityActivity2, DraftUpdateActivity2, ChangeRequestReadActivity2, changeRequest2, writeBack2, artifact2, file2, note2, comment2, createTasks2, alertTask2, integrationBranch2, mergeChangeRequest2, approveChangeRequest2, closeChangeRequest2, pipelineMoved2, rerunPipeline2, reportPipeline2, release2, transcripts2, propose2, projectActivity2, pipelineStatus2, reviewThreads2, openChangeRequests2, ownChangeRequests2, draftUpdate2, ResourceName, ClaimResult2, claimDeferred2, letGoDeferred2, claim2, letGo2, WorkUnitRepoBinding, ProgramWorkUnit, CheckName2, ApprovedCheck, MeasurePlan2, WorkUnitClaimResult, WorkUnitClaimInput, WorkUnitHeartbeatInput, WorkUnitHeartbeatResult, WorkUnitReleaseInput, WorkUnitCompletion, MetricStats2, MeasureVerdict2, Measurement2, measureDeferred2, noiseFloor2, judgeMeasurement2, measure2, LoopJournal2, ScriptedFailure2, scriptedFailure2, loopWorkflow2, executeLoop2, testLoop2, Severity2, Finding2, MergedFinding2, Rebuttal2, RebuttalVerdict2, ScopeJudgement2, isBlocking2, mergeFindings2, splitDisputed2, settleRound2, rallyStop2, CheckFailed2, StepNamedTwice2, ReplayDiverged2, LoopCheckError2, checkLoop2, defineKit2, BaseSync2, syncBase2, Continuing2, continuingBrief2 };