@kitman-sh/sdk 0.10.69 → 0.10.71

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

@@ -1861,6 +1861,12 @@ var RunWaiting = Schema12.Union([
     name: Schema12.String.check(Schema12.isMinLength(1)),
     verificationId: Id
   }),
+  Schema12.Struct({
+    kind: Schema12.Literal("claim"),
+    name: Schema12.String.check(Schema12.isMinLength(1)),
+    resource: Schema12.String.check(Schema12.isMinLength(1)),
+    holder: Schema12.optionalKey(Schema12.Struct({ runId: Id, loopId: Schema12.String }))
+  }),
   Schema12.Struct({
     kind: Schema12.Literal("queue"),
     name: Schema12.String.check(Schema12.isMinLength(1)),
@@ -1882,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({
@@ -2734,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,
@@ -2756,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)];
@@ -2798,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)]);
@@ -3243,7 +3268,10 @@ var PipelineStatus2 = Schema19.Struct({
   source: Schema19.Literals(["forge", "reported"]),
   jobs: Schema19.Array(PipelineJob2),
   readAt: Schema19.optionalKey(Schema19.String),
-  runnerChecks: Schema19.optionalKey(Schema19.Array(Schema19.String))
+  runnerChecks: Schema19.optionalKey(Schema19.Array(Schema19.String)),
+  approved: Schema19.optionalKey(Schema19.String),
+  repository: Schema19.optionalKey(Schema19.String),
+  target: Schema19.optionalKey(Schema19.Struct({ branch: Schema19.String, head: Schema19.String, jobs: Schema19.Array(PipelineJob2) }))
 });
 var ReviewThread2 = Schema19.Struct({
   id: Schema19.String,
@@ -3475,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
@@ -3552,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";
@@ -3652,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 });
@@ -4046,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") {
@@ -4102,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* () {
@@ -4110,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;
   })
 });
@@ -4157,7 +4207,7 @@ var scriptedHost = (script, engine, agentLaunches, childLaunches, waits, verifyL
       });
       return resolve(eventDeferred2(launch.step), launch.token, event === undefined ? Exit3.fail(new WaitTimedOut2({ step: launch.step, event: launch.event })) : Exit3.succeed(event));
     },
-    claimResource: (launch) => launch.action === "let_go" ? resolve(letGoDeferred2(launch.step), launch.token, Exit3.succeed(null)) : resolve(claimDeferred2(launch.step), launch.token, Exit3.succeed(script.claims?.[launch.step] ?? { status: "granted", resource: launch.resource })),
+    claimResource: (launch) => Effect8.flatMap(script.claimed?.({ step: launch.step, resource: launch.resource, action: launch.action }) ?? Effect8.undefined, (settled) => launch.action === "let_go" ? resolve(letGoDeferred2(launch.step), launch.token, Exit3.succeed(null)) : resolve(claimDeferred2(launch.step), launch.token, Exit3.succeed(settled ?? script.claims?.[launch.step] ?? { status: "granted", resource: launch.resource }))),
     startVerification: (launch) => {
       const scripted = script.verifications?.[launch.step];
       if (launch.measure === undefined)
@@ -4190,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,
@@ -4244,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) => {
@@ -4317,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}`;
@@ -4331,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`;
@@ -4344,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";
@@ -4359,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)) {
@@ -4386,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.";
@@ -4421,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.`,
@@ -4444,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 };