@kitman-sh/sdk 0.10.79 → 0.10.80

package/dist/{chunk-r609bz8q.js → chunk-9ff7wyqt.js}

@@ -1,6 +1,6 @@
 // @bun
 // packages/core/src/kit-declarations.ts
-import * as Schema14 from "effect/Schema";
+import * as Schema15 from "effect/Schema";
 
 // packages/core/src/agent-sandbox-policy.ts
 import * as Schema from "effect/Schema";
@@ -352,7 +352,7 @@ var AgentCapabilities = ["web", "subagents", "artifacts", "browser"];
 
 // packages/core/src/loop.ts
 import * as Effect from "effect/Effect";
-import * as Schema12 from "effect/Schema";
+import * as Schema13 from "effect/Schema";
 
 // packages/core/src/context-pack.ts
 import * as Schema6 from "effect/Schema";
@@ -483,61 +483,102 @@ var ContextPackRetrievedContext = Schema6.Struct({
 });
 
 // packages/core/src/extension.ts
-import * as Schema9 from "effect/Schema";
+import * as Schema10 from "effect/Schema";
 
 // packages/core/src/run.ts
-import * as Schema8 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
 
 // packages/core/src/redaction.ts
-import * as Schema7 from "effect/Schema";
+import * as Schema8 from "effect/Schema";
 import * as Data from "effect/Data";
+
+// packages/core/src/secret.ts
+import * as Schema7 from "effect/Schema";
+var SecretName = Schema7.String.check(Schema7.isPattern(new RegExp("^[A-Za-z_][A-Za-z0-9_]*$", "u")), Schema7.isMinLength(1), Schema7.isMaxLength(128));
+var SecretScope = Schema7.Union([Schema7.Literal("workspace"), Schema7.Literal("team")]);
+var SecretHost = Schema7.String.check(Schema7.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")), Schema7.isMaxLength(260));
+var SecretHosts = Schema7.Array(SecretHost).check(Schema7.isMaxLength(32));
+var referencePattern = /secret:\/\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+/;
+var placeholderMarker = "kitmanref";
+var tokenCharacter = "[A-Za-z0-9._~+/-]";
+var placeholderPattern = new RegExp(`(?<!${tokenCharacter})(?:proxy-ep=[A-Za-z0-9.-]+;)?${tokenCharacter}*${placeholderMarker}((?:[0-9a-f]{2})+)`);
+var anyReference = new RegExp(`${referencePattern.source}|${placeholderPattern.source}`, "g");
+var unhex = (text) => new TextDecoder().decode(Uint8Array.from(text.match(/../g) ?? [], (pair) => Number.parseInt(pair, 16)));
+var isReference = (text) => new RegExp(`^${referencePattern.source}$`).test(text);
+var tokenPrefix = /^(?:sk-ant-[a-z]+[0-9]*-|sk-proj-|sk-or-v[0-9]+-|sk-|ya29\.|gh[opsu]_|github_pat_|xai-|gsk_|AIza)/;
+var wholePlaceholder = new RegExp(`^(?:[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.|proxy-ep=[A-Za-z0-9.-]+;|${tokenPrefix.source.slice(1)})?${placeholderMarker}((?:[0-9a-f]{2})+)$`);
+var isSecretReference = (text) => {
+  if (isReference(text))
+    return true;
+  const encoded = wholePlaceholder.exec(text)?.[1];
+  return encoded !== undefined && isReference(unhex(encoded));
+};
+var SecretSummary = Schema7.Struct({
+  name: SecretName,
+  scope: SecretScope,
+  teamId: Schema7.optionalKey(Id),
+  hosts: SecretHosts,
+  setByActorType: ActorType,
+  setByActorId: Schema7.String,
+  setAt: Timestamp
+});
+var SecretList = Schema7.Struct({ items: Schema7.Array(SecretSummary) });
+var SecretSet = Schema7.Struct({
+  value: Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(65536)),
+  teamId: Schema7.optionalKey(Schema7.String.check(Schema7.isMinLength(1))),
+  hosts: Schema7.optionalKey(SecretHosts)
+});
+var SecretScopeQuery = Schema7.Struct({ teamId: Schema7.optionalKey(Id) });
+
+// packages/core/src/redaction.ts
 var EvidenceRefContractVersion = "evidence-ref.v1";
-var RedactionClassificationSchema = Schema7.Union([
-  Schema7.Literal("secret"),
-  Schema7.Literal("credential"),
-  Schema7.Literal("pii"),
-  Schema7.Literal("source"),
-  Schema7.Literal("log"),
-  Schema7.Literal("diff"),
-  Schema7.Literal("transcript"),
-  Schema7.Literal("provider_payload"),
-  Schema7.Literal("url"),
-  Schema7.Literal("path"),
-  Schema7.Literal("unknown")
+var RedactionClassificationSchema = Schema8.Union([
+  Schema8.Literal("secret"),
+  Schema8.Literal("credential"),
+  Schema8.Literal("pii"),
+  Schema8.Literal("source"),
+  Schema8.Literal("log"),
+  Schema8.Literal("diff"),
+  Schema8.Literal("transcript"),
+  Schema8.Literal("provider_payload"),
+  Schema8.Literal("url"),
+  Schema8.Literal("path"),
+  Schema8.Literal("unknown")
 ]);
-var RedactionFindingSchema = Schema7.Struct({
-  path: Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(512)),
+var RedactionFindingSchema = Schema8.Struct({
+  path: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(512)),
   classification: RedactionClassificationSchema,
-  rule: Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(120)),
-  preview: Schema7.String.check(Schema7.isMaxLength(160)),
-  sha256: Schema7.String.check(Schema7.isPattern(new RegExp("^[a-f0-9]{64}$", "u")))
-});
-var EvidenceRef = Schema7.Struct({
-  contractVersion: Schema7.Literal(EvidenceRefContractVersion),
-  kind: Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(80)),
-  summary: Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(240)),
-  sha256: Schema7.String.check(Schema7.isPattern(new RegExp("^[a-f0-9]{64}$", "u"))),
-  redaction: Schema7.Literal("redacted"),
-  findingCount: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0)),
-  classifications: Schema7.Array(RedactionClassificationSchema).check(Schema7.isMaxLength(20))
+  rule: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120)),
+  preview: Schema8.String.check(Schema8.isMaxLength(160)),
+  sha256: Schema8.String.check(Schema8.isPattern(new RegExp("^[a-f0-9]{64}$", "u"))),
+  span: Schema8.optionalKey(Schema8.Struct({ start: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)), end: Schema8.Int }))
+});
+var EvidenceRef = Schema8.Struct({
+  contractVersion: Schema8.Literal(EvidenceRefContractVersion),
+  kind: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80)),
+  summary: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240)),
+  sha256: Schema8.String.check(Schema8.isPattern(new RegExp("^[a-f0-9]{64}$", "u"))),
+  redaction: Schema8.Literal("redacted"),
+  findingCount: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
+  classifications: Schema8.Array(RedactionClassificationSchema).check(Schema8.isMaxLength(20))
 });
 var RedactionSurfaceKinds = ["api", "mcp", "cli", "web", "event", "log", "evidence", "export"];
-var RedactionSurfaceKindSchema = Schema7.Literals(RedactionSurfaceKinds);
-var RedactionWaiver = Schema7.Struct({
-  contractVersion: Schema7.Literal("redaction-waiver.v1"),
-  id: Schema7.String.check(Schema7.isMinLength(1)),
-  workspaceId: Schema7.String.check(Schema7.isMinLength(1)),
-  findingId: Schema7.String.check(Schema7.isMinLength(1)),
-  reason: Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(1000)),
-  authorityActorType: Schema7.Union([
-    Schema7.Literal("human"),
-    Schema7.Literal("delegated_agent"),
-    Schema7.Literal("agent")
+var RedactionSurfaceKindSchema = Schema8.Literals(RedactionSurfaceKinds);
+var RedactionWaiver = Schema8.Struct({
+  contractVersion: Schema8.Literal("redaction-waiver.v1"),
+  id: Schema8.String.check(Schema8.isMinLength(1)),
+  workspaceId: Schema8.String.check(Schema8.isMinLength(1)),
+  findingId: Schema8.String.check(Schema8.isMinLength(1)),
+  reason: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(1000)),
+  authorityActorType: Schema8.Union([
+    Schema8.Literal("human"),
+    Schema8.Literal("delegated_agent"),
+    Schema8.Literal("agent")
   ]),
-  authorityActorId: Schema7.String.check(Schema7.isMinLength(1)),
-  authorityRole: Schema7.Union([Schema7.Literal("owner"), Schema7.Literal("admin")]),
-  expiresAt: Schema7.optionalKey(Schema7.String.check(isDateTime)),
-  createdAt: Schema7.String.check(isDateTime)
+  authorityActorId: Schema8.String.check(Schema8.isMinLength(1)),
+  authorityRole: Schema8.Union([Schema8.Literal("owner"), Schema8.Literal("admin")]),
+  expiresAt: Schema8.optionalKey(Schema8.String.check(isDateTime)),
+  createdAt: Schema8.String.check(isDateTime)
 });
 class DurableSurfaceScanError extends Data.TaggedError("DurableSurfaceScanError") {
   constructor(findings) {
@@ -585,144 +626,190 @@ var LOCAL_PATH_KEYS = new Set([
   "docker_socket",
   "ssh_agent_socket"
 ]);
+var wrappedValue = String.raw`<[A-Za-z][A-Za-z0-9 _.-]*>|\$\{[^{}\s]*\}|\{\{[^{}]*\}\}|proxy-ep=[A-Za-z0-9.-]+;kitmanref(?:[0-9a-f]{2})+(?![A-Za-z0-9._~+/-])`;
+var secretReferenceTail = String.raw`(?<=secret:)\/\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?![^\s,;}"')\]\x60])`;
+var bearerValue = /[0-9]|[._~+/:-][A-Za-z0-9]|[<{]/u;
 var VALUE_RULES = [
-  ["secret", /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/u, "private-key"],
-  ["credential", /\bBearer\s+(?=[A-Za-z]*(?:[0-9]|[._~+/-][A-Za-z0-9]))[A-Za-z0-9._~+/-]+=*/iu, "bearer-token"],
-  [
-    "credential",
-    /(?:^|[^A-Za-z0-9])(?:ghp_|github_pat_|glpat-|ksa1\.|sk-[A-Za-z0-9_-]{8,}|xox[baprs]-)[A-Za-z0-9._-]+/u,
-    "provider-token"
-  ],
-  [
-    "credential",
-    /(?:api[_ -]?key|secret|token|password)\s*[:=]\s*(?!env\b|file\b|exec\b)[^\s,;}]+/iu,
-    "credential-assignment"
-  ],
-  ["pii", /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/iu, "email"],
-  ["pii", /\b\d{3}-\d{2}-\d{4}\b/u, "ssn"],
-  ["pii", /(?:\+\d[\d ()-]{8,}\d|\(\d{3}\)[\d -]{7,}\d|\b\d{3}[ -]\d{3}[ -]\d{4}\b)/u, "phone"],
-  ["pii", /\b(?:\d[ -]*?){13,19}\b/u, "payment-number"],
-  ["url", /\b(?:https?|ftp):\/\/[^\s]+/iu, "url-content"],
-  ["diff", /(^|\n)diff --git\s/u, "diff-content"],
-  ["source", /(^|\n)\s*(?:import|export|const|let|var|function|class)\s+[A-Za-z_$]/u, "source-content"],
-  ["log", /(?:^|\n)\s*\d{4}-\d{2}-\d{2}T\S+\s+(?:ERROR|WARN|INFO|DEBUG)\b/u, "structured-log"],
-  ["transcript", /(?:^|\n)\s*(?:user|assistant|system)\s*:/iu, "transcript-content"]
+  { classification: "secret", name: "private-key", pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/u },
+  {
+    classification: "credential",
+    name: "bearer-token",
+    pattern: new RegExp(`\\bBearer\\s+(?<value>(?:${wrappedValue}|[A-Za-z0-9._~+/*:=-])+(?<![.,:]))`, "iu"),
+    holds: (value) => !isPlaceholder(value) && bearerValue.test(value)
+  },
+  {
+    classification: "credential",
+    name: "provider-token",
+    pattern: /(?:^|[^A-Za-z0-9])(?<value><?(?:ghp_|github_pat_|glpat-|ksa1\.|sk-[A-Za-z0-9_-]{8,}|xox[baprs]-)[A-Za-z0-9._*-]*[A-Za-z0-9_*-]>?)/u,
+    holds: (value) => !isPlaceholder(value)
+  },
+  {
+    classification: "credential",
+    name: "credential-assignment",
+    pattern: new RegExp(`(?:api[_ -]?key|secret|token|password)\\s*[:=]\\s*(?!env\\b|file\\b|exec\\b|${secretReferenceTail})(?<value>(?:${wrappedValue}|[^\\s,;{}])+)`, "iu"),
+    holds: looksLikeCredential
+  },
+  { classification: "pii", name: "email", pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/iu },
+  { classification: "pii", name: "ssn", pattern: /\b\d{3}-\d{2}-\d{4}\b/u },
+  {
+    classification: "pii",
+    name: "phone",
+    pattern: /(?:\+\d[\d ()-]{8,}\d|\(\d{3}\)[\d -]{7,}\d|\b\d{3}[ -]\d{3}[ -]\d{4}\b)/u
+  },
+  { classification: "pii", name: "payment-number", pattern: /\b(?:\d[ -]*?){13,19}\b/u },
+  { classification: "url", name: "url-content", pattern: /\b(?:https?|ftp):\/\/[^\s]+/iu },
+  { classification: "diff", name: "diff-content", pattern: /(^|\n)diff --git\s/u },
+  {
+    classification: "source",
+    name: "source-content",
+    pattern: /(^|\n)\s*(?:import|export|const|let|var|function|class)\s+[A-Za-z_$]/u
+  },
+  {
+    classification: "log",
+    name: "structured-log",
+    pattern: /(?:^|\n)\s*\d{4}-\d{2}-\d{2}T\S+\s+(?:ERROR|WARN|INFO|DEBUG)\b/u
+  },
+  { classification: "transcript", name: "transcript-content", pattern: /(?:^|\n)\s*(?:user|assistant|system)\s*:/iu }
 ];
-var credentialUrl = /\b(?:https?|ftp):\/\/(?:[^\s/?#]*@|[^\s?#]*\?)[^\s]*/iu;
+var maskedToken = /^(?:ghp_|github_pat_|glpat-|ksa1\.|xox[baprs]-|sk-(?:ant-(?:[a-z]+[0-9]*-)?|proj-|or-v[0-9]+-)?)(?:x{4,}|X{4,}|\*{4,})$/u;
+var placeholderWord = "(?:[A-Z]?[a-z]+|[A-Z]+)";
+var placeholders = [
+  maskedToken,
+  new RegExp(`^<${placeholderWord}[0-9]{0,2}(?:[ _.-]${placeholderWord}[0-9]{0,2})*>$`, "u"),
+  /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/u,
+  /^\$[A-Za-z_][A-Za-z0-9_]*$/u,
+  /^\{\{\s*[A-Za-z_][A-Za-z0-9_.]*\s*\}\}$/u,
+  /^%[A-Za-z_][A-Za-z0-9_]*%$/u,
+  /^\[REDACTED(?::[a-z_]+)?\]$/u,
+  /^[A-Z][A-Z0-9]*(?:_[A-Z][A-Z0-9]*)+$/u,
+  /^([xX*\u2022#.-])\1{2,}$/u,
+  /^runner-secret:[A-Z0-9_]+:(?:env|file|exec)$/u
+];
+var isPlaceholder = (value) => placeholders.some((pattern) => pattern.test(value)) || isSecretReference(value);
+var unwrapped = (value) => value.replace(/^["'`(]+/u, "").replace(/["'`).]+$/u, "");
+function looksLikeCredential(raw, matched) {
+  const value = unwrapped(raw);
+  if (isPlaceholder(raw) || isPlaceholder(value))
+    return false;
+  return /^[^\s:=]+=\S/u.test(matched) || value.length >= 6 && /[0-9]/u.test(value) || value.length >= 20 && /[a-z]/u.test(value) && /[A-Z]/u.test(value);
+}
+var globalPatterns = new WeakMap;
+var credentialUrlRule = {
+  classification: "url",
+  name: "credential-url",
+  pattern: /\b(?:https?|ftp):\/\/(?:[^\s/?#]*@|[^\s?#]*\?)[^\s]*/iu
+};
 var keptClassifications = new Set(["secret", "credential", "unknown"]);
 var normalizedKeys = new Map;
-var CREDENTIAL_RULES = VALUE_RULES.flatMap(([classification, pattern]) => classification === "secret" || classification === "credential" ? [[classification, new RegExp(pattern.source, `${pattern.flags}g`)]] : []);
-var RESPONSE_RULES = [
-  ...CREDENTIAL_RULES,
-  ["url", new RegExp(credentialUrl.source, "giu")]
-];
+var CREDENTIAL_RULES = VALUE_RULES.filter((rule) => rule.classification === "secret" || rule.classification === "credential");
+var RESPONSE_RULES = [...CREDENTIAL_RULES, credentialUrlRule];
 
 // packages/core/src/run.ts
-var RunContractVersion = Schema8.Literal("run.v1");
-var ImmutableExecutionClosureContractVersion = Schema8.Literal("immutable-execution-closure.v1");
-var Sha256 = Schema8.String.check(Schema8.isPattern(new RegExp("^[a-f0-9]{64}$", "u")));
-var BoundedText = Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(4000));
-var SafeKey = Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120), Schema8.isPattern(new RegExp("^[A-Za-z][A-Za-z0-9_-]*$", "u")));
-var SafeJson = Schema8.Union([
-  Schema8.Null,
-  Schema8.Boolean,
-  Schema8.Finite.check(Schema8.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER), Schema8.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER)),
+var RunContractVersion = Schema9.Literal("run.v1");
+var ImmutableExecutionClosureContractVersion = Schema9.Literal("immutable-execution-closure.v1");
+var Sha256 = Schema9.String.check(Schema9.isPattern(new RegExp("^[a-f0-9]{64}$", "u")));
+var BoundedText = Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(4000));
+var SafeKey = Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120), Schema9.isPattern(new RegExp("^[A-Za-z][A-Za-z0-9_-]*$", "u")));
+var SafeJson = Schema9.Union([
+  Schema9.Null,
+  Schema9.Boolean,
+  Schema9.Finite.check(Schema9.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER), Schema9.isGreaterThanOrEqualTo(Number.MIN_SAFE_INTEGER)),
   BoundedText,
-  Schema8.Array(Schema8.suspend(() => SafeJson)).check(Schema8.isMaxLength(200)),
-  Schema8.Record(SafeKey, Schema8.suspend(() => SafeJson)).check(Schema8.isMaxProperties(200))
+  Schema9.Array(Schema9.suspend(() => SafeJson)).check(Schema9.isMaxLength(200)),
+  Schema9.Record(SafeKey, Schema9.suspend(() => SafeJson)).check(Schema9.isMaxProperties(200))
 ]).annotate({ identifier: "RunSafeJson" });
-var RunActorRef = Schema8.Struct({
-  actorType: Schema8.Union([ActorType, Schema8.Literal("runner")]),
+var RunActorRef = Schema9.Struct({
+  actorType: Schema9.Union([ActorType, Schema9.Literal("runner")]),
   actorId: Id,
-  delegatedByUserId: Schema8.optionalKey(Id),
-  agentIdentityId: Schema8.optionalKey(Id),
-  runnerId: Schema8.optionalKey(Id)
+  delegatedByUserId: Schema9.optionalKey(Id),
+  agentIdentityId: Schema9.optionalKey(Id),
+  runnerId: Schema9.optionalKey(Id)
 });
-var RunResourceRef = Schema8.Struct({
-  kind: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80)),
+var RunResourceRef = Schema9.Struct({
+  kind: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)),
   id: Id
 });
-var RunSchemaRef = Schema8.Struct({
-  kind: Schema8.Literal("typebox_ref"),
-  name: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  version: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(40)),
+var RunSchemaRef = Schema9.Struct({
+  kind: Schema9.Literal("typebox_ref"),
+  name: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  version: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(40)),
   sha256: Sha256
 });
-var AgentPinnedKitRef = Schema8.Struct({
+var AgentPinnedKitRef = Schema9.Struct({
   kitId: Id,
-  version: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1)),
+  version: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
   sha256: Sha256,
-  precedence: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
-  required: Schema8.Boolean
-});
-var AgentSkillRef = Schema8.Struct({
-  sourceId: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240)),
-  name: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  version: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(80))),
-  sha256: Schema8.optionalKey(Sha256),
-  required: Schema8.Boolean
-});
-var AgentReference = Schema8.Union([
-  Schema8.Struct({ agentId: Id, alias: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80)) }),
-  Schema8.Struct({ agentId: Id, version: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1)), digest: Sha256 })
+  precedence: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0)),
+  required: Schema9.Boolean
+});
+var AgentSkillRef = Schema9.Struct({
+  sourceId: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240)),
+  name: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  version: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(80))),
+  sha256: Schema9.optionalKey(Sha256),
+  required: Schema9.Boolean
+});
+var AgentReference = Schema9.Union([
+  Schema9.Struct({ agentId: Id, alias: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)) }),
+  Schema9.Struct({ agentId: Id, version: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)), digest: Sha256 })
 ]);
-var AgentToolGrant = Schema8.Struct({
-  ref: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240)),
-  inputSchema: Schema8.optionalKey(RunSchemaRef),
-  scope: Schema8.optionalKey(RunResourceRef),
-  approval: Schema8.Union([Schema8.Literal("none"), Schema8.Literal("human_each_call"), Schema8.Literal("human_once")]),
-  delegable: Schema8.Boolean
-});
-var AgentHarnessSelector = Schema8.Struct({
-  mode: Schema8.Union([Schema8.Literal("direct_model"), Schema8.Literal("harness_v1"), Schema8.Literal("native")]),
-  harness: Schema8.optionalKey(Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80))),
-  adapterRef: Schema8.optionalKey(Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240))),
-  requiredCapabilities: Schema8.Array(Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80))).check(Schema8.isMaxLength(40)),
-  allowedFallbacks: Schema8.Array(Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160))).check(Schema8.isMaxLength(20))
-});
-var AgentModelSelector = Schema8.Struct({
-  providerRef: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  modelRef: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  profile: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(80))),
-  reasoning: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(80)))
-});
-var AgentPolicy = Schema8.Struct({
-  requestedCapabilities: Schema8.Array(Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120))).check(Schema8.isMaxLength(100)),
-  maxChildDepth: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0), Schema8.isLessThanOrEqualTo(32)),
-  allowSubdelegation: Schema8.Boolean,
-  maxWallSeconds: Schema8.optionalKey(Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1), Schema8.isLessThanOrEqualTo(31536000))),
-  maxInputTokens: Schema8.optionalKey(Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0), Schema8.isLessThanOrEqualTo(1e8))),
-  maxOutputTokens: Schema8.optionalKey(Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0), Schema8.isLessThanOrEqualTo(1e8))),
-  hardLimit: Schema8.Boolean
-});
-var AgentProvenance = Schema8.Struct({
-  source: Schema8.Union([
-    Schema8.Literal("kitman"),
-    Schema8.Literal("workspace"),
-    Schema8.Literal("team"),
-    Schema8.Literal("git"),
-    Schema8.Literal("package"),
-    Schema8.Literal("import")
+var AgentToolGrant = Schema9.Struct({
+  ref: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240)),
+  inputSchema: Schema9.optionalKey(RunSchemaRef),
+  scope: Schema9.optionalKey(RunResourceRef),
+  approval: Schema9.Union([Schema9.Literal("none"), Schema9.Literal("human_each_call"), Schema9.Literal("human_once")]),
+  delegable: Schema9.Boolean
+});
+var AgentHarnessSelector = Schema9.Struct({
+  mode: Schema9.Union([Schema9.Literal("direct_model"), Schema9.Literal("harness_v1"), Schema9.Literal("native")]),
+  harness: Schema9.optionalKey(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80))),
+  adapterRef: Schema9.optionalKey(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240))),
+  requiredCapabilities: Schema9.Array(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80))).check(Schema9.isMaxLength(40)),
+  allowedFallbacks: Schema9.Array(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160))).check(Schema9.isMaxLength(20))
+});
+var AgentModelSelector = Schema9.Struct({
+  providerRef: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  modelRef: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  profile: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(80))),
+  reasoning: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(80)))
+});
+var AgentPolicy = Schema9.Struct({
+  requestedCapabilities: Schema9.Array(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120))).check(Schema9.isMaxLength(100)),
+  maxChildDepth: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0), Schema9.isLessThanOrEqualTo(32)),
+  allowSubdelegation: Schema9.Boolean,
+  maxWallSeconds: Schema9.optionalKey(Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1), Schema9.isLessThanOrEqualTo(31536000))),
+  maxInputTokens: Schema9.optionalKey(Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0), Schema9.isLessThanOrEqualTo(1e8))),
+  maxOutputTokens: Schema9.optionalKey(Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0), Schema9.isLessThanOrEqualTo(1e8))),
+  hardLimit: Schema9.Boolean
+});
+var AgentProvenance = Schema9.Struct({
+  source: Schema9.Union([
+    Schema9.Literal("kitman"),
+    Schema9.Literal("workspace"),
+    Schema9.Literal("team"),
+    Schema9.Literal("git"),
+    Schema9.Literal("package"),
+    Schema9.Literal("import")
   ]),
-  sourceRef: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(240))),
-  sourceCommitSha: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(128))),
+  sourceRef: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(240))),
+  sourceCommitSha: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(128))),
   contentSha256: Sha256,
-  reviewedBy: Schema8.optionalKey(Schema8.Array(RunActorRef).check(Schema8.isMaxLength(20)))
+  reviewedBy: Schema9.optionalKey(Schema9.Array(RunActorRef).check(Schema9.isMaxLength(20)))
 });
-var Agent = Schema8.Struct({
+var Agent = Schema9.Struct({
   contractVersion: RunContractVersion,
   id: Id,
   workspaceId: Id,
-  teamId: Schema8.optionalKey(Id),
-  name: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  slug: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160), Schema8.isPattern(new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u"))),
-  currentVersion: Schema8.optionalKey(Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1))),
-  status: Schema8.Union([
-    Schema8.Literal("draft"),
-    Schema8.Literal("published"),
-    Schema8.Literal("deprecated"),
-    Schema8.Literal("disabled"),
-    Schema8.Literal("archived")
+  teamId: Schema9.optionalKey(Id),
+  name: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  slug: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160), Schema9.isPattern(new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u"))),
+  currentVersion: Schema9.optionalKey(Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1))),
+  status: Schema9.Union([
+    Schema9.Literal("draft"),
+    Schema9.Literal("published"),
+    Schema9.Literal("deprecated"),
+    Schema9.Literal("disabled"),
+    Schema9.Literal("archived")
   ]),
   createdBy: RunActorRef,
   createdAt: Timestamp,
@@ -740,78 +827,78 @@ var RunMessageTypes = [
   "instruction",
   "notice"
 ];
-var RunMessageType = Schema8.Literals(RunMessageTypes);
-var MessageEvidenceRefs = Schema8.Array(RunResourceRef).check(Schema8.isMaxLength(100));
-var MessageProgressPayload = Schema8.Struct({
-  type: Schema8.Literal("progress"),
+var RunMessageType = Schema9.Literals(RunMessageTypes);
+var MessageEvidenceRefs = Schema9.Array(RunResourceRef).check(Schema9.isMaxLength(100));
+var MessageProgressPayload = Schema9.Struct({
+  type: Schema9.Literal("progress"),
   summary: BoundedText,
-  phase: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(120))),
-  percent: Schema8.optionalKey(Schema8.Finite.check(Schema8.isGreaterThanOrEqualTo(0), Schema8.isLessThanOrEqualTo(100))),
-  evidenceRefs: Schema8.optionalKey(MessageEvidenceRefs)
+  phase: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(120))),
+  percent: Schema9.optionalKey(Schema9.Finite.check(Schema9.isGreaterThanOrEqualTo(0), Schema9.isLessThanOrEqualTo(100))),
+  evidenceRefs: Schema9.optionalKey(MessageEvidenceRefs)
 });
-var MessageQuestionPayload = Schema8.Struct({
-  type: Schema8.Literal("question"),
-  questionId: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
+var MessageQuestionPayload = Schema9.Struct({
+  type: Schema9.Literal("question"),
+  questionId: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
   prompt: BoundedText,
   answerSchema: RunSchemaRef,
-  urgency: Schema8.Union([Schema8.Literal("normal"), Schema8.Literal("blocking")]),
+  urgency: Schema9.Union([Schema9.Literal("normal"), Schema9.Literal("blocking")]),
   waitId: Id
 });
-var MessageAnswerPayload = Schema8.Struct({
-  type: Schema8.Literal("answer"),
-  questionId: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
+var MessageAnswerPayload = Schema9.Struct({
+  type: Schema9.Literal("answer"),
+  questionId: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
   answer: SafeJson,
   answerSchema: RunSchemaRef,
   waitId: Id
 });
-var MessageContextRequestPayload = Schema8.Struct({
-  type: Schema8.Literal("context_request"),
-  requestId: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  refs: Schema8.Array(RunResourceRef).check(Schema8.isMaxLength(100)),
+var MessageContextRequestPayload = Schema9.Struct({
+  type: Schema9.Literal("context_request"),
+  requestId: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  refs: Schema9.Array(RunResourceRef).check(Schema9.isMaxLength(100)),
   reason: BoundedText
 });
-var MessageContextResponsePayload = Schema8.Struct({
-  type: Schema8.Literal("context_response"),
-  requestId: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160)),
-  refs: Schema8.Array(RunResourceRef).check(Schema8.isMaxLength(100)),
-  summaries: Schema8.Array(SafeJson).check(Schema8.isMaxLength(100))
-});
-var MessageFindingPayload = Schema8.Struct({
-  type: Schema8.Literal("finding"),
-  severity: Schema8.Union([
-    Schema8.Literal("info"),
-    Schema8.Literal("low"),
-    Schema8.Literal("medium"),
-    Schema8.Literal("high"),
-    Schema8.Literal("critical")
+var MessageContextResponsePayload = Schema9.Struct({
+  type: Schema9.Literal("context_response"),
+  requestId: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  refs: Schema9.Array(RunResourceRef).check(Schema9.isMaxLength(100)),
+  summaries: Schema9.Array(SafeJson).check(Schema9.isMaxLength(100))
+});
+var MessageFindingPayload = Schema9.Struct({
+  type: Schema9.Literal("finding"),
+  severity: Schema9.Union([
+    Schema9.Literal("info"),
+    Schema9.Literal("low"),
+    Schema9.Literal("medium"),
+    Schema9.Literal("high"),
+    Schema9.Literal("critical")
   ]),
-  category: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120)),
+  category: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)),
   summary: BoundedText,
   evidenceRefs: MessageEvidenceRefs
 });
-var MessagePartialResultPayload = Schema8.Struct({
-  type: Schema8.Literal("partial_result"),
+var MessagePartialResultPayload = Schema9.Struct({
+  type: Schema9.Literal("partial_result"),
   outputSchema: RunSchemaRef,
   data: SafeJson,
-  complete: Schema8.Literal(false)
+  complete: Schema9.Literal(false)
 });
-var MessageHandoffPayload = Schema8.Struct({
-  type: Schema8.Literal("handoff"),
+var MessageHandoffPayload = Schema9.Struct({
+  type: Schema9.Literal("handoff"),
   summary: BoundedText,
-  nextAction: Schema8.optionalKey(Schema8.String.check(Schema8.isMaxLength(4000))),
-  evidenceRefs: Schema8.optionalKey(MessageEvidenceRefs)
+  nextAction: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(4000))),
+  evidenceRefs: Schema9.optionalKey(MessageEvidenceRefs)
 });
-var MessageInstructionPayload = Schema8.Struct({
-  type: Schema8.Literal("instruction"),
+var MessageInstructionPayload = Schema9.Struct({
+  type: Schema9.Literal("instruction"),
   instruction: BoundedText,
-  authority: Schema8.Union([Schema8.Literal("normal"), Schema8.Literal("operator")])
+  authority: Schema9.Union([Schema9.Literal("normal"), Schema9.Literal("operator")])
 });
-var MessageNoticePayload = Schema8.Struct({
-  type: Schema8.Literal("notice"),
-  code: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120)),
+var MessageNoticePayload = Schema9.Struct({
+  type: Schema9.Literal("notice"),
+  code: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)),
   summary: BoundedText
 });
-var RunMessagePayload = Schema8.Union([
+var RunMessagePayload = Schema9.Union([
   MessageProgressPayload,
   MessageQuestionPayload,
   MessageAnswerPayload,
@@ -823,94 +910,94 @@ var RunMessagePayload = Schema8.Union([
   MessageInstructionPayload,
   MessageNoticePayload
 ]);
-var RunMessage = Schema8.Struct({
+var RunMessage = Schema9.Struct({
   contractVersion: RunContractVersion,
   id: Id,
   workspaceId: Id,
-  teamId: Schema8.optionalKey(Id),
+  teamId: Schema9.optionalKey(Id),
   rootRunId: Id,
-  sender: Schema8.Union([
-    Schema8.Struct({ kind: Schema8.Union([Schema8.Literal("run"), Schema8.Literal("step_attempt")]), id: Id }),
+  sender: Schema9.Union([
+    Schema9.Struct({ kind: Schema9.Union([Schema9.Literal("run"), Schema9.Literal("step_attempt")]), id: Id }),
     RunActorRef
   ]),
-  recipient: Schema8.Struct({ kind: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80)), id: Id }),
+  recipient: Schema9.Struct({ kind: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)), id: Id }),
   type: RunMessageType,
-  streamKey: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240)),
-  sequence: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1)),
-  correlationId: Schema8.optionalKey(Id),
-  causationId: Schema8.optionalKey(Id),
-  replyToMessageId: Schema8.optionalKey(Id),
-  payloadSchema: Schema8.optionalKey(RunSchemaRef),
+  streamKey: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240)),
+  sequence: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
+  correlationId: Schema9.optionalKey(Id),
+  causationId: Schema9.optionalKey(Id),
+  replyToMessageId: Schema9.optionalKey(Id),
+  payloadSchema: Schema9.optionalKey(RunSchemaRef),
   payload: RunMessagePayload,
-  delivery: Schema8.Union([
-    Schema8.Literal("created"),
-    Schema8.Literal("queued"),
-    Schema8.Literal("delivered"),
-    Schema8.Literal("acknowledged"),
-    Schema8.Literal("expired"),
-    Schema8.Literal("failed")
+  delivery: Schema9.Union([
+    Schema9.Literal("created"),
+    Schema9.Literal("queued"),
+    Schema9.Literal("delivered"),
+    Schema9.Literal("acknowledged"),
+    Schema9.Literal("expired"),
+    Schema9.Literal("failed")
   ]),
-  idempotencyKey: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240)),
-  expiresAt: Schema8.optionalKey(Timestamp),
+  idempotencyKey: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240)),
+  expiresAt: Schema9.optionalKey(Timestamp),
   createdAt: Timestamp,
-  acknowledgedAt: Schema8.optionalKey(Timestamp)
+  acknowledgedAt: Schema9.optionalKey(Timestamp)
 });
-var RunResult = Schema8.Struct({
+var RunResult = Schema9.Struct({
   contractVersion: RunContractVersion,
   id: Id,
   workspaceId: Id,
-  teamId: Schema8.optionalKey(Id),
+  teamId: Schema9.optionalKey(Id),
   runId: Id,
   rootRunId: Id,
-  attempt: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1)),
-  outcome: Schema8.Union([
-    Schema8.Literal("succeeded"),
-    Schema8.Literal("failed"),
-    Schema8.Literal("canceled"),
-    Schema8.Literal("blocked"),
-    Schema8.Literal("expired")
+  attempt: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
+  outcome: Schema9.Union([
+    Schema9.Literal("succeeded"),
+    Schema9.Literal("failed"),
+    Schema9.Literal("canceled"),
+    Schema9.Literal("blocked"),
+    Schema9.Literal("expired")
   ]),
-  output: Schema8.optionalKey(Schema8.Struct({ schema: RunSchemaRef, data: SafeJson, digest: Sha256 })),
-  failure: Schema8.optionalKey(Schema8.Struct({
-    code: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120)),
-    category: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80)),
+  output: Schema9.optionalKey(Schema9.Struct({ schema: RunSchemaRef, data: SafeJson, digest: Sha256 })),
+  failure: Schema9.optionalKey(Schema9.Struct({
+    code: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)),
+    category: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)),
     summary: BoundedText,
-    retryable: Schema8.Boolean,
-    details: Schema8.optionalKey(SafeJson)
+    retryable: Schema9.Boolean,
+    details: Schema9.optionalKey(SafeJson)
   })),
-  evidenceRefs: Schema8.Array(Schema8.Union([RunResourceRef, EvidenceRef])).check(Schema8.isMaxLength(100)),
-  childSummary: Schema8.Struct({
-    awaited: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
-    detached: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
-    succeeded: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
-    failed: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0)),
-    canceled: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(0))
+  evidenceRefs: Schema9.Array(Schema9.Union([RunResourceRef, EvidenceRef])).check(Schema9.isMaxLength(100)),
+  childSummary: Schema9.Struct({
+    awaited: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0)),
+    detached: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0)),
+    succeeded: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0)),
+    failed: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0)),
+    canceled: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(0))
   }),
-  usage: Schema8.optionalKey(Schema8.Record(SafeKey, SafeJson).check(Schema8.isMaxProperties(20))),
-  producedBy: Schema8.Struct({
-    workUnitId: Schema8.optionalKey(Id),
-    leaseId: Schema8.optionalKey(Id),
-    fencingTokenDigest: Schema8.optionalKey(Sha256)
+  usage: Schema9.optionalKey(Schema9.Record(SafeKey, SafeJson).check(Schema9.isMaxProperties(20))),
+  producedBy: Schema9.Struct({
+    workUnitId: Schema9.optionalKey(Id),
+    leaseId: Schema9.optionalKey(Id),
+    fencingTokenDigest: Schema9.optionalKey(Sha256)
   }),
   createdAt: Timestamp,
   finalizedAt: Timestamp
 });
-var RunEvent = Schema8.Struct({
+var RunEvent = Schema9.Struct({
   contractVersion: RunContractVersion,
   id: Id,
-  eventVersion: Schema8.Literal(1),
+  eventVersion: Schema9.Literal(1),
   streamId: Id,
-  sequence: Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1)),
+  sequence: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
   workspaceId: Id,
-  teamId: Schema8.optionalKey(Id),
+  teamId: Schema9.optionalKey(Id),
   subject: RunResourceRef,
   rootRunId: Id,
-  type: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(100)),
-  actor: Schema8.optionalKey(RunActorRef),
-  correlationId: Schema8.optionalKey(Id),
-  causationId: Schema8.optionalKey(Id),
+  type: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(100)),
+  actor: Schema9.optionalKey(RunActorRef),
+  correlationId: Schema9.optionalKey(Id),
+  causationId: Schema9.optionalKey(Id),
   occurredAt: Timestamp,
-  data: Schema8.Struct({ type: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(100)), value: SafeJson })
+  data: Schema9.Struct({ type: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(100)), value: SafeJson })
 });
 var WaitKinds = [
   "timer",
@@ -922,44 +1009,44 @@ var WaitKinds = [
   "provider_quota",
   "resource"
 ];
-var WaitKind = Schema8.Literals(WaitKinds);
-var Wait = Schema8.Struct({
+var WaitKind = Schema9.Literals(WaitKinds);
+var Wait = Schema9.Struct({
   contractVersion: RunContractVersion,
   id: Id,
   workspaceId: Id,
-  teamId: Schema8.optionalKey(Id),
+  teamId: Schema9.optionalKey(Id),
   runId: Id,
   rootRunId: Id,
-  stepKey: Schema8.optionalKey(Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(160))),
+  stepKey: Schema9.optionalKey(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160))),
   kind: WaitKind,
-  state: Schema8.Union([
-    Schema8.Literal("open"),
-    Schema8.Literal("resolved"),
-    Schema8.Literal("expired"),
-    Schema8.Literal("canceled")
+  state: Schema9.Union([
+    Schema9.Literal("open"),
+    Schema9.Literal("resolved"),
+    Schema9.Literal("expired"),
+    Schema9.Literal("canceled")
   ]),
-  correlation: Schema8.Record(SafeKey, SafeJson).check(Schema8.isMaxProperties(20)),
-  expectedSchema: Schema8.optionalKey(RunSchemaRef),
-  timeout: Schema8.Struct({
-    dueAt: Schema8.optionalKey(Timestamp),
-    onTimeout: Schema8.Union([
-      Schema8.Literal("fail"),
-      Schema8.Literal("block"),
-      Schema8.Literal("cancel"),
-      Schema8.Literal("default"),
-      Schema8.Literal("escalate")
+  correlation: Schema9.Record(SafeKey, SafeJson).check(Schema9.isMaxProperties(20)),
+  expectedSchema: Schema9.optionalKey(RunSchemaRef),
+  timeout: Schema9.Struct({
+    dueAt: Schema9.optionalKey(Timestamp),
+    onTimeout: Schema9.Union([
+      Schema9.Literal("fail"),
+      Schema9.Literal("block"),
+      Schema9.Literal("cancel"),
+      Schema9.Literal("default"),
+      Schema9.Literal("escalate")
     ]),
-    defaultValue: Schema8.optionalKey(SafeJson)
+    defaultValue: Schema9.optionalKey(SafeJson)
   }),
-  responderScope: Schema8.optionalKey(RunResourceRef),
-  resolution: Schema8.optionalKey(Schema8.Struct({
-    kind: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(80)),
-    data: Schema8.optionalKey(SafeJson),
+  responderScope: Schema9.optionalKey(RunResourceRef),
+  resolution: Schema9.optionalKey(Schema9.Struct({
+    kind: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)),
+    data: Schema9.optionalKey(SafeJson),
     digest: Sha256,
-    actor: Schema8.optionalKey(RunActorRef)
+    actor: Schema9.optionalKey(RunActorRef)
   })),
   createdAt: Timestamp,
-  resolvedAt: Schema8.optionalKey(Timestamp)
+  resolvedAt: Schema9.optionalKey(Timestamp)
 });
 var ControlCommandKinds = [
   "pause",
@@ -985,74 +1072,74 @@ var ControlCommandKinds = [
   "request_status",
   "request_handoff"
 ];
-var ControlCommandKind = Schema8.Literals(ControlCommandKinds);
-var ControlCommand = Schema8.Struct({
+var ControlCommandKind = Schema9.Literals(ControlCommandKinds);
+var ControlCommand = Schema9.Struct({
   contractVersion: RunContractVersion,
   id: Id,
   workspaceId: Id,
-  teamId: Schema8.optionalKey(Id),
+  teamId: Schema9.optionalKey(Id),
   target: RunResourceRef,
   kind: ControlCommandKind,
-  payload: Schema8.Struct({ kind: ControlCommandKind, data: SafeJson }),
+  payload: Schema9.Struct({ kind: ControlCommandKind, data: SafeJson }),
   requestedBy: RunActorRef,
-  idempotencyKey: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(240)),
-  expectedResourceVersion: Schema8.optionalKey(Schema8.Int.check(Schema8.isGreaterThanOrEqualTo(1))),
-  status: Schema8.Union([
-    Schema8.Literal("accepted"),
-    Schema8.Literal("queued"),
-    Schema8.Literal("applied"),
-    Schema8.Literal("rejected"),
-    Schema8.Literal("expired"),
-    Schema8.Literal("superseded")
+  idempotencyKey: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240)),
+  expectedResourceVersion: Schema9.optionalKey(Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1))),
+  status: Schema9.Union([
+    Schema9.Literal("accepted"),
+    Schema9.Literal("queued"),
+    Schema9.Literal("applied"),
+    Schema9.Literal("rejected"),
+    Schema9.Literal("expired"),
+    Schema9.Literal("superseded")
   ]),
-  rejection: Schema8.optionalKey(Schema8.Struct({ code: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(120)), summary: BoundedText })),
+  rejection: Schema9.optionalKey(Schema9.Struct({ code: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)), summary: BoundedText })),
   createdAt: Timestamp,
-  appliedAt: Schema8.optionalKey(Timestamp)
-});
-var ControlCommandList = Schema8.Struct({ items: Schema8.Array(ControlCommand).check(Schema8.isMaxLength(50)) });
-var RunCommandCenterSnapshot = Schema8.Struct({
-  source: Schema8.Literal("http_snapshot"),
-  collection: Schema8.Literal("run_command_center"),
-  scope: Schema8.Struct({
-    kind: Schema8.Literal("run"),
+  appliedAt: Schema9.optionalKey(Timestamp)
+});
+var ControlCommandList = Schema9.Struct({ items: Schema9.Array(ControlCommand).check(Schema9.isMaxLength(50)) });
+var RunCommandCenterSnapshot = Schema9.Struct({
+  source: Schema9.Literal("http_snapshot"),
+  collection: Schema9.Literal("run_command_center"),
+  scope: Schema9.Struct({
+    kind: Schema9.Literal("run"),
     workspaceId: Id,
-    teamId: Schema8.optionalKey(Id),
+    teamId: Schema9.optionalKey(Id),
     runId: Id
   }),
   capturedAt: Timestamp,
-  consistency: Schema8.Literal("lower_bound"),
-  lowerBound: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(512)),
-  isComplete: Schema8.Literal(true)
+  consistency: Schema9.Literal("lower_bound"),
+  lowerBound: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(512)),
+  isComplete: Schema9.Literal(true)
 });
 
 // packages/core/src/extension.ts
 var NativeExtensionTargets = ["runner_backend", "harness", "sandbox"];
-var NativeExtensionTarget = Schema9.Literals(NativeExtensionTargets);
+var NativeExtensionTarget = Schema10.Literals(NativeExtensionTargets);
 var NativeExtensionPolicies = ["optional", "required"];
-var NativeExtensionPolicy = Schema9.Literals(NativeExtensionPolicies);
-var NativeExtensionIdentity = Schema9.String.check(Schema9.isMinLength(3), Schema9.isMaxLength(120), Schema9.isPattern(new RegExp("^[a-z0-9][a-z0-9_-]*(\\.[a-z0-9][a-z0-9_-]*)+$", "u")));
-var NativeExtensionRef = Schema9.Struct({
+var NativeExtensionPolicy = Schema10.Literals(NativeExtensionPolicies);
+var NativeExtensionIdentity = Schema10.String.check(Schema10.isMinLength(3), Schema10.isMaxLength(120), Schema10.isPattern(new RegExp("^[a-z0-9][a-z0-9_-]*(\\.[a-z0-9][a-z0-9_-]*)+$", "u")));
+var NativeExtensionRef = Schema10.Struct({
   extensionId: NativeExtensionIdentity,
-  version: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1), Schema9.isLessThanOrEqualTo(10)),
+  version: Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(1), Schema10.isLessThanOrEqualTo(10)),
   policy: NativeExtensionPolicy,
-  requiredCapabilities: Schema9.optionalKey(Schema9.Array(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120))).check(Schema9.isMaxLength(50))),
-  configuration: Schema9.optionalKey(Schema9.Record(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)), SafeJson).check(Schema9.isMaxProperties(40)))
+  requiredCapabilities: Schema10.optionalKey(Schema10.Array(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(120))).check(Schema10.isMaxLength(50))),
+  configuration: Schema10.optionalKey(Schema10.Record(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(120)), SafeJson).check(Schema10.isMaxProperties(40)))
 });
-var NativeExtensionDescriptor = Schema9.Struct({
+var NativeExtensionDescriptor = Schema10.Struct({
   extensionId: NativeExtensionIdentity,
-  version: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1), Schema9.isLessThanOrEqualTo(10)),
+  version: Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(1), Schema10.isLessThanOrEqualTo(10)),
   target: NativeExtensionTarget,
-  requiredCapabilities: Schema9.Array(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120))).check(Schema9.isMaxLength(50)),
-  configurationSchema: Schema9.optionalKey(Schema9.Record(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)), SafeJson).check(Schema9.isMaxProperties(80))),
-  resultSchema: Schema9.optionalKey(Schema9.Record(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)), SafeJson).check(Schema9.isMaxProperties(80))),
-  observability: Schema9.Struct({
-    transcriptPolicy: Schema9.Literal("metadata_only"),
-    maxMetadataChars: Schema9.optionalKey(Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1), Schema9.isLessThanOrEqualTo(65536)))
+  requiredCapabilities: Schema10.Array(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(120))).check(Schema10.isMaxLength(50)),
+  configurationSchema: Schema10.optionalKey(Schema10.Record(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(120)), SafeJson).check(Schema10.isMaxProperties(80))),
+  resultSchema: Schema10.optionalKey(Schema10.Record(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(120)), SafeJson).check(Schema10.isMaxProperties(80))),
+  observability: Schema10.Struct({
+    transcriptPolicy: Schema10.Literal("metadata_only"),
+    maxMetadataChars: Schema10.optionalKey(Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(1), Schema10.isLessThanOrEqualTo(65536)))
   })
 });
 
 // packages/core/src/proposal.ts
-import * as Schema10 from "effect/Schema";
+import * as Schema11 from "effect/Schema";
 var ProposalStatuses = [
   "proposed",
   "in_review",
@@ -1165,105 +1252,105 @@ var ForbiddenProposalNormalizedKeySet = new Set(ForbiddenProposalNormalizedKeys)
 var ProposalSafePayloadKeyPattern = `^(?!(?:${proposalForbiddenKeyVariants().map(escapeRegExp).join("|")})$).+$`;
 var ProposalForbiddenContentPattern = "sk-[A-Za-z0-9_-]{8,}|ghp_[A-Za-z0-9_]+|glpat-[A-Za-z0-9_-]+|\\bBearer\\s+[A-Za-z0-9._~+/=-]+|eyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+|[dD][iI][fF][fF]\\s+--git|[rR][aA][wW]\\s+(?:[tT][eE][rR][mM][iI][nN][aA][lL]\\s+)?[lL][oO][gG]s?|[tT][eE][rR][mM][iI][nN][aA][lL]\\s+[oO][uU][tT][pP][uU][tT]|[rR][aA][wW]\\s+[tT][rR][aA][nN][sS][cC][rR][iI][pP][tT]s?|[sS][oO][uU][rR][cC][eE]\\s+[cC][oO][dD][eE]|[fF][iI][lL][eE]\\s+[cC][oO][nN][tT][eE][nN][tT]";
 var ProposalSafeStringPattern = `^(?!.*(?:${ProposalForbiddenContentPattern})).*$`;
-var ProposalStatus = Schema10.Literals(ProposalStatuses);
-var ProposalTargetType = Schema10.Literals(ProposalTargetTypes);
-var ProposalRiskLevel = Schema10.Literals(ProposalRiskLevels);
-var ProposalApprovalPolicyMode = Schema10.Literals(ProposalApprovalPolicyModes);
-var ProposalPolicyViolationCode = Schema10.Literals(ProposalPolicyViolationCodes);
-var ProposalPolicyViolationSeverity = Schema10.Literals(ProposalPolicyViolationSeverities);
-var ProposalCheckKind = Schema10.Literals(ProposalCheckKinds);
-var ProposalCheckStatus = Schema10.Literals(ProposalCheckStatuses);
-var ProposalApplicationAction = Schema10.Literals(ProposalApplicationActions);
-var ProposalRenderedDiffFormat = Schema10.Literals(ProposalRenderedDiffFormats);
-var ProposalRenderedDiffSectionRisk = Schema10.Literals(ProposalRenderedDiffSectionRisks);
-var ProposalRenderedDiffRefKind = Schema10.Literals(ProposalRenderedDiffRefKinds);
-var ProposalSafeString = Schema10.String.check(Schema10.isMaxLength(4000), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u")));
-var ProposalSafeMetadataScalar = Schema10.Union([ProposalSafeString, Schema10.Finite, Schema10.Boolean, Schema10.Null]);
-var ProposalSafeMetadataValue = Schema10.Union([
+var ProposalStatus = Schema11.Literals(ProposalStatuses);
+var ProposalTargetType = Schema11.Literals(ProposalTargetTypes);
+var ProposalRiskLevel = Schema11.Literals(ProposalRiskLevels);
+var ProposalApprovalPolicyMode = Schema11.Literals(ProposalApprovalPolicyModes);
+var ProposalPolicyViolationCode = Schema11.Literals(ProposalPolicyViolationCodes);
+var ProposalPolicyViolationSeverity = Schema11.Literals(ProposalPolicyViolationSeverities);
+var ProposalCheckKind = Schema11.Literals(ProposalCheckKinds);
+var ProposalCheckStatus = Schema11.Literals(ProposalCheckStatuses);
+var ProposalApplicationAction = Schema11.Literals(ProposalApplicationActions);
+var ProposalRenderedDiffFormat = Schema11.Literals(ProposalRenderedDiffFormats);
+var ProposalRenderedDiffSectionRisk = Schema11.Literals(ProposalRenderedDiffSectionRisks);
+var ProposalRenderedDiffRefKind = Schema11.Literals(ProposalRenderedDiffRefKinds);
+var ProposalSafeString = Schema11.String.check(Schema11.isMaxLength(4000), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u")));
+var ProposalSafeMetadataScalar = Schema11.Union([ProposalSafeString, Schema11.Finite, Schema11.Boolean, Schema11.Null]);
+var ProposalSafeMetadataValue = Schema11.Union([
   ProposalSafeMetadataScalar,
-  Schema10.Array(ProposalSafeMetadataScalar).check(Schema10.isMaxLength(100))
+  Schema11.Array(ProposalSafeMetadataScalar).check(Schema11.isMaxLength(100))
 ]);
-var ProposalSafeMetadata = Schema10.Record(Schema10.String.check(Schema10.isMinLength(1), Schema10.isPattern(new RegExp(ProposalSafePayloadKeyPattern, "u"))), ProposalSafeMetadataValue);
-var ProposalPayload = Schema10.Struct({
-  memory: Schema10.optionalKey(ProposalSafeMetadata),
-  kit: Schema10.optionalKey(ProposalSafeMetadata),
-  kit_source: Schema10.optionalKey(ProposalSafeMetadata),
-  kit_version: Schema10.optionalKey(ProposalSafeMetadata),
-  kit_installation: Schema10.optionalKey(ProposalSafeMetadata),
-  kit_activation: Schema10.optionalKey(ProposalSafeMetadata),
-  kit_trust_policy: Schema10.optionalKey(ProposalSafeMetadata),
-  agent_environment_policy: Schema10.optionalKey(ProposalSafeMetadata),
-  decision: Schema10.optionalKey(ProposalSafeMetadata),
-  task: Schema10.optionalKey(ProposalSafeMetadata),
-  team_context: Schema10.optionalKey(ProposalSafeMetadata),
-  context_relevance: Schema10.optionalKey(ProposalSafeMetadata)
-});
-var ProposalTargetRef = Schema10.Struct({
+var ProposalSafeMetadata = Schema11.Record(Schema11.String.check(Schema11.isMinLength(1), Schema11.isPattern(new RegExp(ProposalSafePayloadKeyPattern, "u"))), ProposalSafeMetadataValue);
+var ProposalPayload = Schema11.Struct({
+  memory: Schema11.optionalKey(ProposalSafeMetadata),
+  kit: Schema11.optionalKey(ProposalSafeMetadata),
+  kit_source: Schema11.optionalKey(ProposalSafeMetadata),
+  kit_version: Schema11.optionalKey(ProposalSafeMetadata),
+  kit_installation: Schema11.optionalKey(ProposalSafeMetadata),
+  kit_activation: Schema11.optionalKey(ProposalSafeMetadata),
+  kit_trust_policy: Schema11.optionalKey(ProposalSafeMetadata),
+  agent_environment_policy: Schema11.optionalKey(ProposalSafeMetadata),
+  decision: Schema11.optionalKey(ProposalSafeMetadata),
+  task: Schema11.optionalKey(ProposalSafeMetadata),
+  team_context: Schema11.optionalKey(ProposalSafeMetadata),
+  context_relevance: Schema11.optionalKey(ProposalSafeMetadata)
+});
+var ProposalTargetRef = Schema11.Struct({
   type: ProposalTargetType,
-  id: Schema10.optionalKey(Id),
-  scopeType: Schema10.optionalKey(Schema10.Union([Schema10.Literal("workspace"), Schema10.Literal("team"), Schema10.Literal("task"), Schema10.Literal("kit")])),
-  scopeId: Schema10.optionalKey(Id)
+  id: Schema11.optionalKey(Id),
+  scopeType: Schema11.optionalKey(Schema11.Union([Schema11.Literal("workspace"), Schema11.Literal("team"), Schema11.Literal("task"), Schema11.Literal("kit")])),
+  scopeId: Schema11.optionalKey(Id)
 });
-var ProposalApprovalPolicy = Schema10.Struct({
+var ProposalApprovalPolicy = Schema11.Struct({
   mode: ProposalApprovalPolicyMode,
-  requireDifferentApprover: Schema10.optionalKey(Schema10.Boolean),
-  autonomousAgentApprovalAllowed: Schema10.Literal(false),
-  deniedViolationCodes: Schema10.Array(ProposalPolicyViolationCode)
+  requireDifferentApprover: Schema11.optionalKey(Schema11.Boolean),
+  autonomousAgentApprovalAllowed: Schema11.Literal(false),
+  deniedViolationCodes: Schema11.Array(ProposalPolicyViolationCode)
 });
-var ProposalPolicyViolation = Schema10.Struct({
+var ProposalPolicyViolation = Schema11.Struct({
   code: ProposalPolicyViolationCode,
   severity: ProposalPolicyViolationSeverity,
   message: ProposalSafeString,
-  actorId: Schema10.optionalKey(Id),
-  target: Schema10.optionalKey(ProposalTargetRef),
-  metadata: Schema10.optionalKey(ProposalSafeMetadata)
+  actorId: Schema11.optionalKey(Id),
+  target: Schema11.optionalKey(ProposalTargetRef),
+  metadata: Schema11.optionalKey(ProposalSafeMetadata)
 });
-var ProposalRenderedDiffRef = Schema10.Struct({
+var ProposalRenderedDiffRef = Schema11.Struct({
   kind: ProposalRenderedDiffRefKind,
-  id: Schema10.optionalKey(Id),
-  externalId: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1))),
-  url: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1))),
-  title: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240)))
-});
-var ProposalRenderedDiffSection = Schema10.Struct({
-  title: Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
-  beforeSummary: Schema10.optionalKey(ProposalSafeString),
-  afterSummary: Schema10.optionalKey(ProposalSafeString),
+  id: Schema11.optionalKey(Id),
+  externalId: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1))),
+  url: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1))),
+  title: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240)))
+});
+var ProposalRenderedDiffSection = Schema11.Struct({
+  title: Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
+  beforeSummary: Schema11.optionalKey(ProposalSafeString),
+  afterSummary: Schema11.optionalKey(ProposalSafeString),
   risk: ProposalRenderedDiffSectionRisk
 });
-var ProposalRenderedDiff = Schema10.Struct({
+var ProposalRenderedDiff = Schema11.Struct({
   format: ProposalRenderedDiffFormat,
-  title: Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
+  title: Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
   summary: ProposalSafeString,
-  sections: Schema10.Array(ProposalRenderedDiffSection),
-  refs: Schema10.Array(ProposalRenderedDiffRef)
+  sections: Schema11.Array(ProposalRenderedDiffSection),
+  refs: Schema11.Array(ProposalRenderedDiffRef)
 });
-var ProposalRiskSummary = Schema10.Struct({
+var ProposalRiskSummary = Schema11.Struct({
   level: ProposalRiskLevel,
   summary: ProposalSafeString,
-  reasons: Schema10.Array(ProposalSafeString)
+  reasons: Schema11.Array(ProposalSafeString)
 });
-var Proposal = Schema10.Struct({
+var Proposal = Schema11.Struct({
   id: Id,
   workspaceId: Id,
-  teamId: Schema10.optionalKey(Id),
-  taskId: Schema10.optionalKey(Id),
+  teamId: Schema11.optionalKey(Id),
+  taskId: Schema11.optionalKey(Id),
   target: ProposalTargetRef,
-  title: Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
+  title: Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
   summary: ProposalSafeString,
   status: ProposalStatus,
   riskLevel: ProposalRiskLevel,
   approvalPolicy: ProposalApprovalPolicy,
   proposedByActorType: ActorType,
   proposedByActorId: Id,
-  delegatedByUserId: Schema10.optionalKey(Id),
+  delegatedByUserId: Schema11.optionalKey(Id),
   createdAt: Timestamp,
   updatedAt: Timestamp
 });
-var ProposalRevision = Schema10.Struct({
+var ProposalRevision = Schema11.Struct({
   id: Id,
   proposalId: Id,
-  revisionNumber: Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(1)),
+  revisionNumber: Schema11.Int.check(Schema11.isGreaterThanOrEqualTo(1)),
   payload: ProposalPayload,
   renderedDiff: ProposalRenderedDiff,
   riskSummary: ProposalRiskSummary,
@@ -1271,32 +1358,32 @@ var ProposalRevision = Schema10.Struct({
   createdByActorId: Id,
   createdAt: Timestamp
 });
-var ProposalCommentAnchor = Schema10.Struct({
-  path: Schema10.Array(Schema10.String.check(Schema10.isMinLength(1), Schema10.isPattern(new RegExp(ProposalSafePayloadKeyPattern, "u")))),
-  label: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(120), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u"))))
+var ProposalCommentAnchor = Schema11.Struct({
+  path: Schema11.Array(Schema11.String.check(Schema11.isMinLength(1), Schema11.isPattern(new RegExp(ProposalSafePayloadKeyPattern, "u")))),
+  label: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(120), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u"))))
 });
-var ProposalComment = Schema10.Struct({
+var ProposalComment = Schema11.Struct({
   id: Id,
   proposalId: Id,
-  revisionId: Schema10.optionalKey(Id),
+  revisionId: Schema11.optionalKey(Id),
   body: ProposalSafeString,
-  anchor: Schema10.optionalKey(ProposalCommentAnchor),
+  anchor: Schema11.optionalKey(ProposalCommentAnchor),
   actorType: ActorType,
   actorId: Id,
-  delegatedByUserId: Schema10.optionalKey(Id),
+  delegatedByUserId: Schema11.optionalKey(Id),
   createdAt: Timestamp
 });
-var ProposalCheck = Schema10.Struct({
+var ProposalCheck = Schema11.Struct({
   id: Id,
   proposalId: Id,
-  revisionId: Schema10.optionalKey(Id),
+  revisionId: Schema11.optionalKey(Id),
   kind: ProposalCheckKind,
   status: ProposalCheckStatus,
   summary: ProposalSafeString,
-  details: Schema10.optionalKey(ProposalSafeMetadata),
+  details: Schema11.optionalKey(ProposalSafeMetadata),
   createdAt: Timestamp
 });
-var ProposalApplication = Schema10.Struct({
+var ProposalApplication = Schema11.Struct({
   id: Id,
   proposalId: Id,
   revisionId: Id,
@@ -1304,9 +1391,9 @@ var ProposalApplication = Schema10.Struct({
   target: ProposalTargetRef,
   appliedByActorType: ActorType,
   appliedByActorId: Id,
-  targetVersionBefore: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u")))),
-  targetVersionAfter: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u")))),
-  rollbackRef: Schema10.optionalKey(Schema10.String.check(Schema10.isMinLength(1), Schema10.isMaxLength(240), Schema10.isPattern(new RegExp(ProposalSafeStringPattern, "u")))),
+  targetVersionBefore: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u")))),
+  targetVersionAfter: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u")))),
+  rollbackRef: Schema11.optionalKey(Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u")))),
   appliedAt: Timestamp
 });
 function proposalForbiddenKeyVariants() {
@@ -1321,8 +1408,8 @@ function escapeRegExp(value) {
 }
 
 // packages/core/src/waiting-on.ts
-import * as Schema11 from "effect/Schema";
-var WaitingOn = Schema11.Struct({ keys: Schema11.Array(Schema11.String), hidden: Schema11.Int });
+import * as Schema12 from "effect/Schema";
+var WaitingOn = Schema12.Struct({ keys: Schema12.Array(Schema12.String), hidden: Schema12.Int });
 
 // packages/core/src/run-queue.ts
 var ClaimRanks = ["in_progress", "finishing", "new"];
@@ -1465,23 +1552,23 @@ var LoopCapabilityKinds = [
   "propose_context_relevance",
   "execute_runner_sandbox"
 ];
-var LoopStatus = Schema12.Literals(LoopStatuses);
-var LoopTriggerEvent = Schema12.String.check(Schema12.isMinLength(3), Schema12.isMaxLength(160), Schema12.isPattern(new RegExp("^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)+$", "u")));
-var LoopStepImplementationKind = Schema12.Literals(LoopStepImplementationKinds);
-var RunStatus = Schema12.Literals(RunStatuses);
-var RunStepStatus = Schema12.Literals(RunStepStatuses);
-var StepAttemptStatus = Schema12.Literals(StepAttemptStatuses);
-var QuestionStatus = Schema12.Literals(QuestionStatuses);
-var LoopGuardSource = Schema12.Literals(LoopGuardSources);
-var LoopSourceMode = Schema12.Literals(LoopSourceModes);
-var LoopCapabilityKind = Schema12.Literals(LoopCapabilityKinds);
-var LoopGuardOperator = Schema12.Literals(LoopGuardOperators);
-var LoopCapabilityScopeKind = Schema12.Literals(LoopCapabilityScopeKinds);
-var LoopRetryBackoffKind = Schema12.Literals(LoopRetryBackoffKinds);
-var LoopRequiredRunStepStatus = Schema12.Literals(LoopRequiredRunStepStatuses);
-var LoopSafeRefKind = Schema12.Literals(LoopSafeRefKinds);
-var LoopSha256 = Schema12.String.check(Schema12.isPattern(new RegExp("^[a-fA-F0-9]{64}$", "u")));
-var LoopGitCommitSha = Schema12.String.check(Schema12.isPattern(new RegExp("^[a-fA-F0-9]{40}$|^[a-fA-F0-9]{64}$", "u")));
+var LoopStatus = Schema13.Literals(LoopStatuses);
+var LoopTriggerEvent = Schema13.String.check(Schema13.isMinLength(3), Schema13.isMaxLength(160), Schema13.isPattern(new RegExp("^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)+$", "u")));
+var LoopStepImplementationKind = Schema13.Literals(LoopStepImplementationKinds);
+var RunStatus = Schema13.Literals(RunStatuses);
+var RunStepStatus = Schema13.Literals(RunStepStatuses);
+var StepAttemptStatus = Schema13.Literals(StepAttemptStatuses);
+var QuestionStatus = Schema13.Literals(QuestionStatuses);
+var LoopGuardSource = Schema13.Literals(LoopGuardSources);
+var LoopSourceMode = Schema13.Literals(LoopSourceModes);
+var LoopCapabilityKind = Schema13.Literals(LoopCapabilityKinds);
+var LoopGuardOperator = Schema13.Literals(LoopGuardOperators);
+var LoopCapabilityScopeKind = Schema13.Literals(LoopCapabilityScopeKinds);
+var LoopRetryBackoffKind = Schema13.Literals(LoopRetryBackoffKinds);
+var LoopRequiredRunStepStatus = Schema13.Literals(LoopRequiredRunStepStatuses);
+var LoopSafeRefKind = Schema13.Literals(LoopSafeRefKinds);
+var LoopSha256 = Schema13.String.check(Schema13.isPattern(new RegExp("^[a-fA-F0-9]{64}$", "u")));
+var LoopGitCommitSha = Schema13.String.check(Schema13.isPattern(new RegExp("^[a-fA-F0-9]{40}$|^[a-fA-F0-9]{64}$", "u")));
 var LoopCredentialContentPattern = "(?:^|[^A-Za-z0-9])sk-[A-Za-z0-9_-]{16,}|ghp_[A-Za-z0-9_]+|github_pat_[A-Za-z0-9_]+|glpat-[A-Za-z0-9_-]+|\\b[Bb][Ee][Aa][Rr][Ee][Rr]\\s+[A-Za-z0-9._~+/=-]+|eyJ[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+\\.[A-Za-z0-9_-]+";
 var LoopReferenceForbiddenContentPattern = `${LoopCredentialContentPattern}|[dD][iI][fF][fF]\\s+--git|[rR][aA][wW]\\s+(?:[tT][eE][rR][mM][iI][nN][aA][lL]\\s+)?[lL][oO][gG]s?|[tT][eE][rR][mM][iI][nN][aA][lL]\\s+[oO][uU][tT][pP][uU][tT]|[rR][aA][wW]\\s+[tT][rR][aA][nN][sS][cC][rR][iI][pP][tT]s?|[sS][oO][uU][rR][cC][eE]\\s+[cC][oO][dD][eE]|[fF][iI][lL][eE]\\s+[cC][oO][nN][tT][eE][nN][tT]`;
 var LoopReferenceAndUrlForbiddenContentPattern = `${LoopReferenceForbiddenContentPattern}|[A-Za-z][A-Za-z0-9+.-]*://\\S+`;
@@ -1548,26 +1635,26 @@ var LoopForbiddenDataflowKeys = [
 var LoopForbiddenDataflowKeyPattern = LoopForbiddenDataflowKeys.map(loopForbiddenKeyPattern).join("|");
 var LoopForbiddenDataflowKeyRegExp = new RegExp(LoopForbiddenDataflowKeyPattern);
 var LoopForbiddenContentRegExp = new RegExp(LoopReferenceAndUrlForbiddenContentPattern);
-var LoopSafeReferenceString = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")));
-var LoopSafeInternalReferenceString = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeInternalReferencePattern, "u")));
-var LoopSafeText = Schema12.String.check(Schema12.isMaxLength(4000), Schema12.isPattern(new RegExp(`^(?![\\s\\S]*(?:${LoopCredentialContentPattern}|[A-Za-z][A-Za-z0-9+.-]*://(?:[^\\s/?#]*@|[^\\s?#]*\\?)))[\\s\\S]*$`, "u")));
-var recommendedDefault = (recommended) => recommended !== undefined && Schema12.is(LoopSafeText)(recommended) ? recommended : undefined;
+var LoopSafeReferenceString = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u")));
+var LoopSafeInternalReferenceString = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240), Schema13.isPattern(new RegExp(LoopSafeInternalReferencePattern, "u")));
+var LoopSafeText = Schema13.String.check(Schema13.isMaxLength(4000), Schema13.isPattern(new RegExp(`^(?![\\s\\S]*(?:${LoopCredentialContentPattern}|[A-Za-z][A-Za-z0-9+.-]*://(?:[^\\s/?#]*@|[^\\s?#]*\\?)))[\\s\\S]*$`, "u")));
+var recommendedDefault = (recommended) => recommended !== undefined && Schema13.is(LoopSafeText)(recommended) ? recommended : undefined;
 var unansweredQuestionLead = "Nobody answers in full auto, and the agent's Question has no answer to take";
 var unansweredQuestionReason2 = (prompt) => {
   const reason = `${unansweredQuestionLead}: ${prompt}`.slice(0, 4000);
-  return Schema12.is(LoopSafeText)(reason) ? reason : `${unansweredQuestionLead}; its text is on the Run`;
+  return Schema13.is(LoopSafeText)(reason) ? reason : `${unansweredQuestionLead}; its text is on the Run`;
 };
 var isUnansweredQuestion2 = (reason) => reason.startsWith(unansweredQuestionLead);
-var QuestionText = Schema12.String;
-var LoopSafeOutputDataString = Schema12.String.check(Schema12.isMaxLength(4000), Schema12.isPattern(new RegExp(LoopSafeInternalReferencePattern, "u")));
-var LoopSafePackageName = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(200), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")));
-var LoopSafeScopeValue = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeScopeValuePattern, "u")));
-var LoopSafeKey = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.isPattern(new RegExp(`^(?!.*(?:${LoopForbiddenDataflowKeyPattern}))(?!.*(?:${LoopReferenceForbiddenContentPattern}))[A-Za-z0-9][A-Za-z0-9_-]*$`, "u")));
-var LoopDataflowKey = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.isPattern(new RegExp(`^(?!.*(?:${LoopForbiddenDataflowKeyPattern}))(?!.*(?:${LoopReferenceForbiddenContentPattern}))[A-Za-z][A-Za-z0-9]*(?:[_-][A-Za-z0-9]+)*$`, "u")));
-var LoopDataPathSegment = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.isPattern(new RegExp(`^(?!.*(?:${LoopForbiddenDataflowKeyPattern}))(?!.*(?:${LoopReferenceForbiddenContentPattern}))[A-Za-z_][A-Za-z0-9_-]*$`, "u")));
-var LoopGitRef = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(`^(?!.*(?:${LoopReferenceForbiddenContentPattern}))(?!@$)(?!.*\\.\\.)(?!.*@\\{)(?!.*//)(?!.*[\\s~^:?*\\[\\\\])(?!.*(?:^|/)\\.)(?!.*(?:^|/)\\.\\.?(?:/|$))(?!.*\\.lock(?:/|$))(?!.*/$)(?!.*\\.$)[A-Za-z0-9][A-Za-z0-9._/-]*$`, "u")));
-var LoopBundleRef = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(500), Schema12.isPattern(new RegExp(`^(?!.*(?:${LoopReferenceAndUrlForbiddenContentPattern}))(?!/)(?!.*:)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.\\.?($|/))(?!.*\\s).+$`, "u")));
-var LoopSourcePath = Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(500), Schema12.isPattern(new RegExp(`^(?!.*(?:${LoopReferenceForbiddenContentPattern}))(?!/)(?!.*:)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.\\.?($|/))(?!.*\\s).+$`, "u")));
+var QuestionText = Schema13.String;
+var LoopSafeOutputDataString = Schema13.String.check(Schema13.isMaxLength(4000), Schema13.isPattern(new RegExp(LoopSafeInternalReferencePattern, "u")));
+var LoopSafePackageName = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(200), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u")));
+var LoopSafeScopeValue = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240), Schema13.isPattern(new RegExp(LoopSafeScopeValuePattern, "u")));
+var LoopSafeKey = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120), Schema13.isPattern(new RegExp(`^(?!.*(?:${LoopForbiddenDataflowKeyPattern}))(?!.*(?:${LoopReferenceForbiddenContentPattern}))[A-Za-z0-9][A-Za-z0-9_-]*$`, "u")));
+var LoopDataflowKey = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120), Schema13.isPattern(new RegExp(`^(?!.*(?:${LoopForbiddenDataflowKeyPattern}))(?!.*(?:${LoopReferenceForbiddenContentPattern}))[A-Za-z][A-Za-z0-9]*(?:[_-][A-Za-z0-9]+)*$`, "u")));
+var LoopDataPathSegment = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120), Schema13.isPattern(new RegExp(`^(?!.*(?:${LoopForbiddenDataflowKeyPattern}))(?!.*(?:${LoopReferenceForbiddenContentPattern}))[A-Za-z_][A-Za-z0-9_-]*$`, "u")));
+var LoopGitRef = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240), Schema13.isPattern(new RegExp(`^(?!.*(?:${LoopReferenceForbiddenContentPattern}))(?!@$)(?!.*\\.\\.)(?!.*@\\{)(?!.*//)(?!.*[\\s~^:?*\\[\\\\])(?!.*(?:^|/)\\.)(?!.*(?:^|/)\\.\\.?(?:/|$))(?!.*\\.lock(?:/|$))(?!.*/$)(?!.*\\.$)[A-Za-z0-9][A-Za-z0-9._/-]*$`, "u")));
+var LoopBundleRef = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(500), Schema13.isPattern(new RegExp(`^(?!.*(?:${LoopReferenceAndUrlForbiddenContentPattern}))(?!/)(?!.*:)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.\\.?($|/))(?!.*\\s).+$`, "u")));
+var LoopSourcePath = Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(500), Schema13.isPattern(new RegExp(`^(?!.*(?:${LoopReferenceForbiddenContentPattern}))(?!/)(?!.*:)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.\\.?($|/))(?!.*\\s).+$`, "u")));
 function loopForbiddenKeyPattern(key) {
   const words = key.split(/[_-]+/).filter(Boolean);
   const separated = words.map((word) => loopCaseInsensitiveWordPattern(word)).join("[_-]+");
@@ -1585,186 +1672,186 @@ function loopCaseInsensitiveWordPattern(word, uppercaseFirst = false) {
     return char.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
   }).join("");
 }
-var LoopDataSchemaRef = Schema12.Struct({
-  kind: Schema12.Literal("typebox_ref"),
+var LoopDataSchemaRef = Schema13.Struct({
+  kind: Schema13.Literal("typebox_ref"),
   name: LoopSafeReferenceString,
-  version: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")))),
-  sha256: Schema12.optionalKey(LoopSha256)
+  version: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u")))),
+  sha256: Schema13.optionalKey(LoopSha256)
 });
-var LoopStepOutputDataValue = Schema12.Union([
+var LoopStepOutputDataValue = Schema13.Union([
   LoopSafeOutputDataString,
-  Schema12.Finite,
-  Schema12.Boolean,
-  Schema12.Null,
-  Schema12.Array(Schema12.suspend(() => LoopStepOutputDataValue)).check(Schema12.isMaxLength(200)),
-  Schema12.Record(LoopDataPathSegment, Schema12.suspend(() => LoopStepOutputDataValue)).check(Schema12.isMaxProperties(200))
+  Schema13.Finite,
+  Schema13.Boolean,
+  Schema13.Null,
+  Schema13.Array(Schema13.suspend(() => LoopStepOutputDataValue)).check(Schema13.isMaxLength(200)),
+  Schema13.Record(LoopDataPathSegment, Schema13.suspend(() => LoopStepOutputDataValue)).check(Schema13.isMaxProperties(200))
 ]).annotate({ identifier: "LoopStepOutputDataValue" });
-var LoopSafeMetadata = Schema12.Record(LoopDataPathSegment, LoopStepOutputDataValue);
-var LoopGuardValue = Schema12.Union([LoopSafeOutputDataString, Schema12.Finite, Schema12.Boolean]);
-var LoopSafeRef = Schema12.Struct({
+var LoopSafeMetadata = Schema13.Record(LoopDataPathSegment, LoopStepOutputDataValue);
+var LoopGuardValue = Schema13.Union([LoopSafeOutputDataString, Schema13.Finite, Schema13.Boolean]);
+var LoopSafeRef = Schema13.Struct({
   kind: LoopSafeRefKind,
-  id: Schema12.optionalKey(LoopSafeInternalReferenceString),
-  externalId: Schema12.optionalKey(LoopSafeInternalReferenceString),
-  provider: Schema12.optionalKey(LoopSafeInternalReferenceString),
-  title: Schema12.optionalKey(LoopSafeInternalReferenceString)
+  id: Schema13.optionalKey(LoopSafeInternalReferenceString),
+  externalId: Schema13.optionalKey(LoopSafeInternalReferenceString),
+  provider: Schema13.optionalKey(LoopSafeInternalReferenceString),
+  title: Schema13.optionalKey(LoopSafeInternalReferenceString)
 });
-var LoopGuard = Schema12.Struct({
+var LoopGuard = Schema13.Struct({
   key: LoopSafeKey,
   source: LoopGuardSource,
-  path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1)),
+  path: Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1)),
   operator: LoopGuardOperator,
-  value: Schema12.optionalKey(LoopGuardValue),
-  values: Schema12.optionalKey(Schema12.Array(LoopGuardValue).check(Schema12.isMinLength(1)))
+  value: Schema13.optionalKey(LoopGuardValue),
+  values: Schema13.optionalKey(Schema13.Array(LoopGuardValue).check(Schema13.isMinLength(1)))
 });
-var LoopCapabilityScope = Schema12.Struct({
+var LoopCapabilityScope = Schema13.Struct({
   kind: LoopCapabilityScopeKind,
-  id: Schema12.optionalKey(Id),
-  idRef: Schema12.optionalKey(LoopSafeReferenceString),
-  value: Schema12.optionalKey(LoopSafeScopeValue)
+  id: Schema13.optionalKey(Id),
+  idRef: Schema13.optionalKey(LoopSafeReferenceString),
+  value: Schema13.optionalKey(LoopSafeScopeValue)
 });
-var LoopCapabilityGrant = Schema12.Struct({
+var LoopCapabilityGrant = Schema13.Struct({
   capability: LoopCapabilityKind,
-  scope: Schema12.optionalKey(LoopCapabilityScope),
-  reason: Schema12.optionalKey(LoopSafeText)
+  scope: Schema13.optionalKey(LoopCapabilityScope),
+  reason: Schema13.optionalKey(LoopSafeText)
 });
-var LoopRequiredContextSlice = Schema12.Struct({
+var LoopRequiredContextSlice = Schema13.Struct({
   kind: ContextPackRetrievalRefKind,
-  id: Schema12.optionalKey(Id),
-  idRef: Schema12.optionalKey(LoopSafeReferenceString),
+  id: Schema13.optionalKey(Id),
+  idRef: Schema13.optionalKey(LoopSafeReferenceString),
   reason: LoopSafeText,
-  required: Schema12.Boolean.pipe(Schema12.withDecodingDefaultKey(Effect.succeed(true)))
+  required: Schema13.Boolean.pipe(Schema13.withDecodingDefaultKey(Effect.succeed(true)))
 });
-var LoopRetryPolicy = Schema12.Struct({
-  maxAttempts: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(20)),
+var LoopRetryPolicy = Schema13.Struct({
+  maxAttempts: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1), Schema13.isLessThanOrEqualTo(20)),
   backoff: LoopRetryBackoffKind,
-  delaySeconds: Schema12.optionalKey(Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(86400)))
+  delaySeconds: Schema13.optionalKey(Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1), Schema13.isLessThanOrEqualTo(86400)))
 });
-var LoopTimeoutPolicy = Schema12.Struct({
-  timeoutSeconds: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(604800))
+var LoopTimeoutPolicy = Schema13.Struct({
+  timeoutSeconds: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1), Schema13.isLessThanOrEqualTo(604800))
 });
-var LoopDirectSource = Schema12.Struct({
-  mode: Schema12.Literal("direct"),
-  registeredFrom: Schema12.optionalKey(Schema12.Union([Schema12.Literal("api"), Schema12.Literal("cli"), Schema12.Literal("mcp"), Schema12.Literal("import")])),
-  bundleRef: Schema12.optionalKey(LoopBundleRef),
-  bundleSha256: Schema12.optionalKey(LoopSha256),
-  metadata: Schema12.optionalKey(LoopSafeMetadata)
+var LoopDirectSource = Schema13.Struct({
+  mode: Schema13.Literal("direct"),
+  registeredFrom: Schema13.optionalKey(Schema13.Union([Schema13.Literal("api"), Schema13.Literal("cli"), Schema13.Literal("mcp"), Schema13.Literal("import")])),
+  bundleRef: Schema13.optionalKey(LoopBundleRef),
+  bundleSha256: Schema13.optionalKey(LoopSha256),
+  metadata: Schema13.optionalKey(LoopSafeMetadata)
 });
-var LoopGitBackedSource = Schema12.Struct({
-  mode: Schema12.Literal("git_backed"),
+var LoopGitBackedSource = Schema13.Struct({
+  mode: Schema13.Literal("git_backed"),
   repoBindingId: Id,
   gitRef: LoopGitRef,
   commitSha: LoopGitCommitSha,
-  definitionPath: Schema12.optionalKey(LoopSourcePath),
-  packagePath: Schema12.optionalKey(LoopSourcePath),
-  metadata: Schema12.optionalKey(LoopSafeMetadata)
+  definitionPath: Schema13.optionalKey(LoopSourcePath),
+  packagePath: Schema13.optionalKey(LoopSourcePath),
+  metadata: Schema13.optionalKey(LoopSafeMetadata)
 });
-var LoopSource = Schema12.Union([LoopDirectSource, LoopGitBackedSource]);
-var LoopStepPackageMetadata = Schema12.Struct({
+var LoopSource = Schema13.Union([LoopDirectSource, LoopGitBackedSource]);
+var LoopStepPackageMetadata = Schema13.Struct({
   packageName: LoopSafePackageName,
-  version: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")))),
+  version: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u")))),
   entrypoint: LoopSafeReferenceString,
   source: LoopSource,
-  runtime: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")))),
-  integritySha256: Schema12.optionalKey(LoopSha256),
-  metadata: Schema12.optionalKey(LoopSafeMetadata)
+  runtime: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u")))),
+  integritySha256: Schema13.optionalKey(LoopSha256),
+  metadata: Schema13.optionalKey(LoopSafeMetadata)
 });
 var LoopStepInputBindingFields = {
   key: LoopDataflowKey,
-  required: Schema12.optionalKey(Schema12.Boolean)
+  required: Schema13.optionalKey(Schema13.Boolean)
 };
-var LoopStepInputBinding = Schema12.Union([
-  Schema12.Struct({
+var LoopStepInputBinding = Schema13.Union([
+  Schema13.Struct({
     ...LoopStepInputBindingFields,
-    source: Schema12.Literal("trigger_event"),
-    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+    source: Schema13.Literal("trigger_event"),
+    path: Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1))
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...LoopStepInputBindingFields,
-    source: Schema12.Literal("subject"),
-    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+    source: Schema13.Literal("subject"),
+    path: Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1))
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...LoopStepInputBindingFields,
-    source: Schema12.Literal("context"),
-    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+    source: Schema13.Literal("context"),
+    path: Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1))
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...LoopStepInputBindingFields,
-    source: Schema12.Literal("step_output"),
+    source: Schema13.Literal("step_output"),
     stepKey: LoopSafeKey,
     outputKey: LoopDataflowKey,
-    path: Schema12.optionalKey(Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1)))
+    path: Schema13.optionalKey(Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1)))
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...LoopStepInputBindingFields,
-    source: Schema12.Literal("run"),
-    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+    source: Schema13.Literal("run"),
+    path: Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1))
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...LoopStepInputBindingFields,
-    source: Schema12.Literal("literal"),
+    source: Schema13.Literal("literal"),
     value: LoopStepOutputDataValue
   })
 ]);
-var LoopStepOutputRef = Schema12.Struct({
+var LoopStepOutputRef = Schema13.Struct({
   key: LoopDataflowKey,
-  schemaRef: Schema12.optionalKey(LoopDataSchemaRef),
-  path: Schema12.optionalKey(Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))),
-  required: Schema12.optionalKey(Schema12.Boolean)
+  schemaRef: Schema13.optionalKey(LoopDataSchemaRef),
+  path: Schema13.optionalKey(Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1))),
+  required: Schema13.optionalKey(Schema13.Boolean)
 });
-var LoopBuiltInActionStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("built_in_action"),
+var LoopBuiltInActionStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("built_in_action"),
   action: LoopSafeReferenceString,
-  input: Schema12.optionalKey(LoopSafeMetadata)
+  input: Schema13.optionalKey(LoopSafeMetadata)
 });
-var LoopAgentRuntimeComponentSelector = Schema12.Struct({
+var LoopAgentRuntimeComponentSelector = Schema13.Struct({
   implementation: LoopSafeReferenceString,
-  kind: Schema12.Union([Schema12.Literal("preferred"), Schema12.Literal("required")])
+  kind: Schema13.Union([Schema13.Literal("preferred"), Schema13.Literal("required")])
 });
-var LoopAgentStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("agent"),
+var LoopAgentStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("agent"),
   taskIdRef: LoopSafeReferenceString,
   agentId: Id,
-  agentRef: Schema12.optionalKey(AgentReference),
-  runtimeKind: Schema12.optionalKey(LoopSafeReferenceString),
-  harness: Schema12.optionalKey(LoopAgentRuntimeComponentSelector),
-  sandbox: Schema12.optionalKey(LoopAgentRuntimeComponentSelector),
-  models: Schema12.optionalKey(Schema12.Array(AgentModelSelector).check(Schema12.isMinLength(1), Schema12.isMaxLength(20))),
-  extensions: Schema12.optionalKey(Schema12.Array(NativeExtensionRef).check(Schema12.isMaxLength(20)))
-});
-var LoopWaitForEventStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("wait_for_event"),
+  agentRef: Schema13.optionalKey(AgentReference),
+  runtimeKind: Schema13.optionalKey(LoopSafeReferenceString),
+  harness: Schema13.optionalKey(LoopAgentRuntimeComponentSelector),
+  sandbox: Schema13.optionalKey(LoopAgentRuntimeComponentSelector),
+  models: Schema13.optionalKey(Schema13.Array(AgentModelSelector).check(Schema13.isMinLength(1), Schema13.isMaxLength(20))),
+  extensions: Schema13.optionalKey(Schema13.Array(NativeExtensionRef).check(Schema13.isMaxLength(20)))
+});
+var LoopWaitForEventStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("wait_for_event"),
   event: LoopTriggerEvent,
-  anyOf: Schema12.optionalKey(Schema12.Array(LoopTriggerEvent).check(Schema12.isMinLength(1))),
-  correlationPath: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1)),
-  authPolicy: Schema12.optionalKey(Schema12.Struct({
-    mode: Schema12.Union([Schema12.Literal("trusted_source"), Schema12.Literal("actor")]),
-    capability: Schema12.optionalKey(LoopSafeReferenceString)
+  anyOf: Schema13.optionalKey(Schema13.Array(LoopTriggerEvent).check(Schema13.isMinLength(1))),
+  correlationPath: Schema13.Array(LoopDataPathSegment).check(Schema13.isMinLength(1)),
+  authPolicy: Schema13.optionalKey(Schema13.Struct({
+    mode: Schema13.Union([Schema13.Literal("trusted_source"), Schema13.Literal("actor")]),
+    capability: Schema13.optionalKey(LoopSafeReferenceString)
   })),
-  cancellation: Schema12.optionalKey(Schema12.Union([Schema12.Literal("cancel"), Schema12.Literal("timeout")])),
-  releaseRunner: Schema12.optionalKey(Schema12.Boolean)
+  cancellation: Schema13.optionalKey(Schema13.Union([Schema13.Literal("cancel"), Schema13.Literal("timeout")])),
+  releaseRunner: Schema13.optionalKey(Schema13.Boolean)
 });
-var LoopHumanApprovalStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("human_approval"),
+var LoopHumanApprovalStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("human_approval"),
   prompt: LoopSafeText,
   approvalPolicy: ProposalApprovalPolicy
 });
-var LoopRunnerSandboxStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("runner_sandbox"),
+var LoopRunnerSandboxStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("runner_sandbox"),
   runnerSelector: LoopSafeMetadata,
   entrypoint: LoopSafeReferenceString,
-  package: Schema12.optionalKey(LoopStepPackageMetadata)
+  package: Schema13.optionalKey(LoopStepPackageMetadata)
 });
-var LoopPackageRefStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("package_ref"),
+var LoopPackageRefStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("package_ref"),
   package: LoopStepPackageMetadata
 });
-var LoopCallStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("call_loop"),
+var LoopCallStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("call_loop"),
   loop: LoopReferenceSchema,
-  mode: Schema12.Literal("awaited")
+  mode: Schema13.Literal("awaited")
 });
-var LoopConcreteActionImplementation = Schema12.Union([
+var LoopConcreteActionImplementation = Schema13.Union([
   LoopBuiltInActionStepImplementation,
   LoopAgentStepImplementation,
   LoopWaitForEventStepImplementation,
@@ -1772,221 +1859,221 @@ var LoopConcreteActionImplementation = Schema12.Union([
   LoopRunnerSandboxStepImplementation,
   LoopPackageRefStepImplementation
 ]);
-var LoopRepeatUntilSafetyPolicy = Schema12.Struct({
-  maxIterations: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(1000)),
-  timeoutSeconds: Schema12.optionalKey(Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(604800)))
+var LoopRepeatUntilSafetyPolicy = Schema13.Struct({
+  maxIterations: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1), Schema13.isLessThanOrEqualTo(1000)),
+  timeoutSeconds: Schema13.optionalKey(Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1), Schema13.isLessThanOrEqualTo(604800)))
 });
-var LoopRepeatUntilStepImplementation = Schema12.Struct({
-  kind: Schema12.Literal("repeat_until"),
+var LoopRepeatUntilStepImplementation = Schema13.Struct({
+  kind: Schema13.Literal("repeat_until"),
   body: LoopConcreteActionImplementation,
   convergenceOutput: LoopDataflowKey,
   safetyPolicy: LoopRepeatUntilSafetyPolicy
 });
-var LoopStepImplementation = Schema12.Union([
+var LoopStepImplementation = Schema13.Union([
   LoopConcreteActionImplementation,
   LoopRepeatUntilStepImplementation,
   LoopCallStepImplementation
 ]);
-var LoopStep = Schema12.Struct({
+var LoopStep = Schema13.Struct({
   key: LoopSafeKey,
   title: LoopSafeReferenceString,
-  required: Schema12.Boolean.pipe(Schema12.withDecodingDefaultKey(Effect.succeed(true))),
-  dependsOn: Schema12.Array(LoopSafeKey),
-  requiredContext: Schema12.Array(LoopRequiredContextSlice),
-  guards: Schema12.Array(LoopGuard),
+  required: Schema13.Boolean.pipe(Schema13.withDecodingDefaultKey(Effect.succeed(true))),
+  dependsOn: Schema13.Array(LoopSafeKey),
+  requiredContext: Schema13.Array(LoopRequiredContextSlice),
+  guards: Schema13.Array(LoopGuard),
   implementation: LoopStepImplementation,
   inputSchemaRef: LoopDataSchemaRef,
   outputSchemaRef: LoopDataSchemaRef,
-  inputBindings: Schema12.Array(LoopStepInputBinding),
-  outputRefs: Schema12.Array(LoopStepOutputRef),
-  allowedCapabilities: Schema12.Array(LoopCapabilityGrant),
+  inputBindings: Schema13.Array(LoopStepInputBinding),
+  outputRefs: Schema13.Array(LoopStepOutputRef),
+  allowedCapabilities: Schema13.Array(LoopCapabilityGrant),
   retryPolicy: LoopRetryPolicy,
   timeoutPolicy: LoopTimeoutPolicy,
   metadata: LoopSafeMetadata
 });
-var LoopStepOutput = Schema12.Struct({
+var LoopStepOutput = Schema13.Struct({
   stepKey: LoopSafeKey,
   outputSchemaRef: LoopDataSchemaRef,
   summary: LoopSafeText,
-  data: Schema12.Record(LoopDataflowKey, LoopStepOutputDataValue).check(Schema12.isMinProperties(1)),
-  metadata: Schema12.optionalKey(LoopSafeMetadata),
-  refs: Schema12.Array(LoopSafeRef)
+  data: Schema13.Record(LoopDataflowKey, LoopStepOutputDataValue).check(Schema13.isMinProperties(1)),
+  metadata: Schema13.optionalKey(LoopSafeMetadata),
+  refs: Schema13.Array(LoopSafeRef)
 });
 var RunStepStateFields = {
-  stepKey: Schema12.String.check(Schema12.isMinLength(1)),
-  sequence: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(0)),
-  attempts: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(0)),
-  stepAttemptId: Schema12.optionalKey(Id),
-  startedAt: Schema12.optionalKey(Timestamp),
-  endedAt: Schema12.optionalKey(Timestamp),
-  output: Schema12.optionalKey(LoopStepOutput),
-  failureSummary: Schema12.optionalKey(LoopSafeText),
+  stepKey: Schema13.String.check(Schema13.isMinLength(1)),
+  sequence: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0)),
+  attempts: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0)),
+  stepAttemptId: Schema13.optionalKey(Id),
+  startedAt: Schema13.optionalKey(Timestamp),
+  endedAt: Schema13.optionalKey(Timestamp),
+  output: Schema13.optionalKey(LoopStepOutput),
+  failureSummary: Schema13.optionalKey(LoopSafeText),
   updatedAt: Timestamp
 };
-var RunStepState = Schema12.Union([
-  Schema12.Struct({
+var RunStepState = Schema13.Union([
+  Schema13.Struct({
     ...RunStepStateFields,
-    required: Schema12.Literal(true),
+    required: Schema13.Literal(true),
     status: LoopRequiredRunStepStatus
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...RunStepStateFields,
-    required: Schema12.Literal(false),
+    required: Schema13.Literal(false),
     status: RunStepStatus
   })
 ]);
-var RunState = Schema12.Struct({
-  stepStates: Schema12.Array(RunStepState),
-  summary: Schema12.optionalKey(LoopSafeText),
+var RunState = Schema13.Struct({
+  stepStates: Schema13.Array(RunStepState),
+  summary: Schema13.optionalKey(LoopSafeText),
   resultMetadata: LoopSafeMetadata
 });
-var RunTrigger = Schema12.Struct({
+var RunTrigger = Schema13.Struct({
   event: LoopSafeReferenceString,
   eventId: Id,
-  subject: Schema12.optionalKey(RunResourceRef),
+  subject: Schema13.optionalKey(RunResourceRef),
   occurredAt: Timestamp,
   metadata: LoopSafeMetadata
 });
-var RunWaiting = Schema12.Union([
-  Schema12.Struct({ kind: Schema12.Literal("question"), name: Schema12.String.check(Schema12.isMinLength(1)), questionId: Id }),
-  Schema12.Struct({
-    kind: Schema12.Literal("clock"),
-    name: Schema12.String.check(Schema12.isMinLength(1)),
+var RunWaiting = Schema13.Union([
+  Schema13.Struct({ kind: Schema13.Literal("question"), name: Schema13.String.check(Schema13.isMinLength(1)), questionId: Id }),
+  Schema13.Struct({
+    kind: Schema13.Literal("clock"),
+    name: Schema13.String.check(Schema13.isMinLength(1)),
     firesAt: Timestamp
   }),
-  Schema12.Struct({
-    kind: Schema12.Literal("event"),
-    name: Schema12.String.check(Schema12.isMinLength(1)),
-    event: Schema12.String.check(Schema12.isMinLength(1)),
+  Schema13.Struct({
+    kind: Schema13.Literal("event"),
+    name: Schema13.String.check(Schema13.isMinLength(1)),
+    event: Schema13.String.check(Schema13.isMinLength(1)),
     timesOutAt: Timestamp
   }),
-  Schema12.Struct({ kind: Schema12.Literal("step"), name: Schema12.String.check(Schema12.isMinLength(1)), stepAttemptId: Id }),
-  Schema12.Struct({ kind: Schema12.Literal("child"), name: Schema12.String.check(Schema12.isMinLength(1)), runId: Id }),
-  Schema12.Struct({
-    kind: Schema12.Literal("verification"),
-    name: Schema12.String.check(Schema12.isMinLength(1)),
+  Schema13.Struct({ kind: Schema13.Literal("step"), name: Schema13.String.check(Schema13.isMinLength(1)), stepAttemptId: Id }),
+  Schema13.Struct({ kind: Schema13.Literal("child"), name: Schema13.String.check(Schema13.isMinLength(1)), runId: Id }),
+  Schema13.Struct({
+    kind: Schema13.Literal("verification"),
+    name: Schema13.String.check(Schema13.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 }))
+  Schema13.Struct({
+    kind: Schema13.Literal("claim"),
+    name: Schema13.String.check(Schema13.isMinLength(1)),
+    resource: Schema13.String.check(Schema13.isMinLength(1)),
+    holder: Schema13.optionalKey(Schema13.Struct({ runId: Id, loopId: Schema13.String }))
   }),
-  Schema12.Struct({
-    kind: Schema12.Literal("queue"),
-    name: Schema12.String.check(Schema12.isMinLength(1)),
+  Schema13.Struct({
+    kind: Schema13.Literal("queue"),
+    name: Schema13.String.check(Schema13.isMinLength(1)),
     workUnitId: Id,
-    rank: Schema12.Literals(ClaimRanks),
-    position: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
-    reason: Schema12.String
+    rank: Schema13.Literals(ClaimRanks),
+    position: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
+    reason: Schema13.String
   })
 ]);
-var RunEvidence = Schema12.Struct({
+var RunEvidence = Schema13.Struct({
   id: Id,
-  step: Schema12.String,
-  name: Schema12.String,
-  command: Schema12.String,
-  status: Schema12.Literals(["passed", "failed"]),
-  preExisting: Schema12.Boolean,
-  revision: Schema12.String,
-  tree: Schema12.String,
-  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)),
+  step: Schema13.String,
+  name: Schema13.String,
+  command: Schema13.String,
+  status: Schema13.Literals(["passed", "failed"]),
+  preExisting: Schema13.Boolean,
+  revision: Schema13.String,
+  tree: Schema13.String,
+  durationMs: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0)),
+  outputTail: Schema13.String,
+  fileIds: Schema13.optionalKey(Schema13.Array(Schema13.String)),
+  skippedSinceBaseline: Schema13.optionalKey(Schema13.Array(Schema13.String)),
+  newNotRun: Schema13.optionalKey(Schema13.Array(Schema13.String)),
   recordedAt: Timestamp
 });
-var ApprovedVerification = Schema12.Struct({
+var ApprovedVerification = Schema13.Struct({
   id: Id,
   repoBindingId: Id,
-  name: Schema12.String,
-  command: Schema12.String,
-  workingDirectory: Schema12.optionalKey(Schema12.String),
-  pipeline: Schema12.optionalKey(Schema12.Boolean),
-  approvedByUserId: Schema12.String,
+  name: Schema13.String,
+  command: Schema13.String,
+  workingDirectory: Schema13.optionalKey(Schema13.String),
+  pipeline: Schema13.optionalKey(Schema13.Boolean),
+  approvedByUserId: Schema13.String,
   createdAt: Timestamp
 });
-var ApprovedVerificationList = Schema12.Struct({ items: Schema12.Array(ApprovedVerification) });
-var BundleDigest = Schema12.String.check(Schema12.isMinLength(64), Schema12.isMaxLength(64), Schema12.isPattern(new RegExp("^[a-f0-9]{64}$", "u")));
-var RunArtifact = Schema12.Struct({
+var ApprovedVerificationList = Schema13.Struct({ items: Schema13.Array(ApprovedVerification) });
+var BundleDigest = Schema13.String.check(Schema13.isMinLength(64), Schema13.isMaxLength(64), Schema13.isPattern(new RegExp("^[a-f0-9]{64}$", "u")));
+var RunArtifact = Schema13.Struct({
   id: Id,
   runId: Id,
-  teamId: Schema12.optionalKey(Id),
-  taskId: Schema12.optionalKey(Id),
-  step: Schema12.String,
-  kind: Schema12.String,
-  title: Schema12.String,
-  text: Schema12.String,
-  data: Schema12.optionalKey(Schema12.Unknown),
+  teamId: Schema13.optionalKey(Id),
+  taskId: Schema13.optionalKey(Id),
+  step: Schema13.String,
+  kind: Schema13.String,
+  title: Schema13.String,
+  text: Schema13.String,
+  data: Schema13.optionalKey(Schema13.Unknown),
   createdAt: Timestamp
 });
-var RunArtifactSearch = Schema12.Struct({
-  query: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(2000)),
-  limit: Schema12.optionalKey(Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(50)))
+var RunArtifactSearch = Schema13.Struct({
+  query: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(2000)),
+  limit: Schema13.optionalKey(Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1), Schema13.isLessThanOrEqualTo(50)))
 });
-var RunArtifactSearchResult = Schema12.Struct({ items: Schema12.Array(RunArtifact) });
+var RunArtifactSearchResult = Schema13.Struct({ items: Schema13.Array(RunArtifact) });
 var RunClosureKinds = ["complete", "abandoned"];
-var RunClosure = Schema12.Struct({
-  kind: Schema12.Literals(RunClosureKinds),
-  reason: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(2000))),
+var RunClosure = Schema13.Struct({
+  kind: Schema13.Literals(RunClosureKinds),
+  reason: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(2000))),
   closedByUserId: Id,
   closedAt: Timestamp
 });
-var RunCloseInput = Schema12.Struct({
-  kind: Schema12.Literals(RunClosureKinds),
-  reason: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(2000)))
+var RunCloseInput = Schema13.Struct({
+  kind: Schema13.Literals(RunClosureKinds),
+  reason: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(2000)))
 });
 var RunAlignmentVerdicts = ["aligned", "not_aligned", "unverified"];
-var RunAlignment = Schema12.Struct({
-  verdict: Schema12.Literals(RunAlignmentVerdicts),
-  reasons: Schema12.Array(Schema12.String),
-  intentVersion: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+var RunAlignment = Schema13.Struct({
+  verdict: Schema13.Literals(RunAlignmentVerdicts),
+  reasons: Schema13.Array(Schema13.String),
+  intentVersion: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
   judgedAt: Timestamp
 });
-var Run = Schema12.Struct({
+var Run = Schema13.Struct({
   id: Id,
   workspaceId: Id,
-  teamId: Schema12.optionalKey(Id),
-  taskId: Schema12.optionalKey(Id),
-  sessionId: Schema12.optionalKey(Id),
+  teamId: Schema13.optionalKey(Id),
+  taskId: Schema13.optionalKey(Id),
+  sessionId: Schema13.optionalKey(Id),
   loopId: Id,
-  kitVersionId: Schema12.optionalKey(Id),
-  resourceVersion: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+  kitVersionId: Schema13.optionalKey(Id),
+  resourceVersion: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
   status: RunStatus,
   trigger: RunTrigger,
   state: RunState,
-  loopDigest: Schema12.optionalKey(BundleDigest),
-  loopLayer: Schema12.optionalKey(Schema12.Literals(["team", "workspace"])),
-  loopVersion: Schema12.optionalKey(Schema12.String),
-  parentRunId: Schema12.optionalKey(Id),
-  continuesRunId: Schema12.optionalKey(Id),
-  waiting: Schema12.optionalKey(Schema12.Array(RunWaiting)),
-  output: Schema12.optionalKey(Schema12.Unknown),
-  failureSummary: Schema12.optionalKey(Schema12.String),
-  closure: Schema12.optionalKey(RunClosure),
-  alignment: Schema12.optionalKey(RunAlignment),
-  startedAt: Schema12.optionalKey(Timestamp),
-  completedAt: Schema12.optionalKey(Timestamp),
+  loopDigest: Schema13.optionalKey(BundleDigest),
+  loopLayer: Schema13.optionalKey(Schema13.Literals(["team", "workspace"])),
+  loopVersion: Schema13.optionalKey(Schema13.String),
+  parentRunId: Schema13.optionalKey(Id),
+  continuesRunId: Schema13.optionalKey(Id),
+  waiting: Schema13.optionalKey(Schema13.Array(RunWaiting)),
+  output: Schema13.optionalKey(Schema13.Unknown),
+  failureSummary: Schema13.optionalKey(Schema13.String),
+  closure: Schema13.optionalKey(RunClosure),
+  alignment: Schema13.optionalKey(RunAlignment),
+  startedAt: Schema13.optionalKey(Timestamp),
+  completedAt: Schema13.optionalKey(Timestamp),
   createdAt: Timestamp,
   updatedAt: Timestamp
 });
 var StepAttemptInputKinds = ["kit", "memory", "decision", "knowledge_record", "context_pack"];
 var StepAttemptInputScopeKinds = ["workspace", "team", "task", "loop", "agent"];
-var StepAttemptInputKind = Schema12.Literals(StepAttemptInputKinds);
-var StepAttemptInputScopeKind = Schema12.Literals(StepAttemptInputScopeKinds);
-var StepAttemptInputScope = Schema12.Struct({
+var StepAttemptInputKind = Schema13.Literals(StepAttemptInputKinds);
+var StepAttemptInputScopeKind = Schema13.Literals(StepAttemptInputScopeKinds);
+var StepAttemptInputScope = Schema13.Struct({
   kind: StepAttemptInputScopeKind,
   id: Id
 });
-var StepAttemptInputAvailability = Schema12.Union([
-  Schema12.Struct({
-    kind: Schema12.Literal("available"),
+var StepAttemptInputAvailability = Schema13.Union([
+  Schema13.Struct({
+    kind: Schema13.Literal("available"),
     inspectRef: LoopSafeRef
   }),
-  Schema12.Struct({
-    kind: Schema12.Union([Schema12.Literal("redacted"), Schema12.Literal("unavailable")]),
+  Schema13.Struct({
+    kind: Schema13.Union([Schema13.Literal("redacted"), Schema13.Literal("unavailable")]),
     reason: LoopSafeText
   })
 ]);
@@ -1999,243 +2086,244 @@ var StepAttemptInputBase = {
   appliedToStepKey: LoopSafeKey,
   availability: StepAttemptInputAvailability
 };
-var StepAttemptInput = Schema12.Union([
-  Schema12.Struct({
+var StepAttemptInput = Schema13.Union([
+  Schema13.Struct({
     ...StepAttemptInputBase,
-    sourceVersion: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")))
+    sourceVersion: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u")))
   }),
-  Schema12.Struct({
+  Schema13.Struct({
     ...StepAttemptInputBase,
     contentSha256: LoopSha256
   })
 ]);
-var StepAttemptInputManifest = Schema12.Struct({
-  manifestVersion: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+var StepAttemptInputManifest = Schema13.Struct({
+  manifestVersion: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
   assembledAt: Timestamp,
-  entries: Schema12.Array(StepAttemptInput),
-  budget: Schema12.optionalKey(LoopSafeMetadata)
+  entries: Schema13.Array(StepAttemptInput),
+  budget: Schema13.optionalKey(LoopSafeMetadata)
 });
-var StepAttemptAgent = Schema12.Struct({
+var StepAttemptAgent = Schema13.Struct({
   id: Id,
-  version: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u"))))
+  version: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240), Schema13.isPattern(new RegExp(LoopSafeReferencePattern, "u"))))
 });
-var StepAttemptRunner = Schema12.Struct({
+var StepAttemptRunner = Schema13.Struct({
   id: Id,
-  capabilitySnapshot: Schema12.optionalKey(LoopSafeMetadata)
+  capabilitySnapshot: Schema13.optionalKey(LoopSafeMetadata)
 });
-var StepAttemptExecutionEnvironment = Schema12.Struct({
-  agent: Schema12.optionalKey(StepAttemptAgent),
-  runner: Schema12.optionalKey(StepAttemptRunner),
-  harness: Schema12.optionalKey(LoopSafeReferenceString),
-  model: Schema12.optionalKey(LoopSafeReferenceString),
+var StepAttemptExecutionEnvironment = Schema13.Struct({
+  agent: Schema13.optionalKey(StepAttemptAgent),
+  runner: Schema13.optionalKey(StepAttemptRunner),
+  harness: Schema13.optionalKey(LoopSafeReferenceString),
+  model: Schema13.optionalKey(LoopSafeReferenceString),
   metadata: LoopSafeMetadata
 });
-var StepAttemptLease = Schema12.Struct({
+var StepAttemptLease = Schema13.Struct({
   ownerId: Id,
-  runnerReplicaId: Schema12.optionalKey(Id),
+  runnerReplicaId: Schema13.optionalKey(Id),
   leaseId: Id,
   fencingToken: LoopSafeReferenceString,
-  capacitySlot: Schema12.optionalKey(LoopSafeReferenceString),
+  capacitySlot: Schema13.optionalKey(LoopSafeReferenceString),
   expiresAt: Timestamp,
-  lastHeartbeatAt: Schema12.optionalKey(Timestamp)
+  lastHeartbeatAt: Schema13.optionalKey(Timestamp)
 });
-var JsonDocumentObject = Schema12.JsonObject;
-var StepBrief = Schema12.Struct({
+var JsonDocumentObject = Schema13.JsonObject;
+var StepBrief = Schema13.Struct({
   stepAttemptId: Id,
-  harness: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(80)),
-  model: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(200))),
-  effort: Schema12.optionalKey(Schema12.Literals(AgentEfforts)),
-  prompt: Schema12.String.check(Schema12.isMinLength(1)),
-  contextPack: Schema12.optionalKey(Schema12.Struct({
-    contextPackId: Schema12.optionalKey(Id),
-    mode: Schema12.String.check(Schema12.isMinLength(1)),
-    contentMarkdown: Schema12.String.check(Schema12.isMinLength(1))
+  harness: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(80)),
+  model: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(200))),
+  effort: Schema13.optionalKey(Schema13.Literals(AgentEfforts)),
+  prompt: Schema13.String.check(Schema13.isMinLength(1)),
+  contextPack: Schema13.optionalKey(Schema13.Struct({
+    contextPackId: Schema13.optionalKey(Id),
+    mode: Schema13.String.check(Schema13.isMinLength(1)),
+    contentMarkdown: Schema13.String.check(Schema13.isMinLength(1))
   })),
   outputSchema: JsonDocumentObject,
-  kits: Schema12.optionalKey(Schema12.Array(Schema12.Struct({
-    name: Schema12.String.check(Schema12.isMinLength(1)),
-    version: Schema12.String.check(Schema12.isMinLength(1)),
-    setupDigest: Schema12.String.check(Schema12.isPattern(/^[a-f0-9]{64}$/u))
+  kits: Schema13.optionalKey(Schema13.Array(Schema13.Struct({
+    name: Schema13.String.check(Schema13.isMinLength(1)),
+    version: Schema13.String.check(Schema13.isMinLength(1)),
+    setupDigest: Schema13.String.check(Schema13.isPattern(/^[a-f0-9]{64}$/u))
   }))),
-  toolless: Schema12.optionalKey(Schema12.Literal(true)),
-  tools: Schema12.optionalKey(Schema12.Array(Schema12.Literals(AgentCapabilities))),
-  listedSkills: Schema12.optionalKey(Schema12.Array(Schema12.String.check(Schema12.isMinLength(1))))
+  toolless: Schema13.optionalKey(Schema13.Literal(true)),
+  tools: Schema13.optionalKey(Schema13.Array(Schema13.Literals(AgentCapabilities))),
+  listedSkills: Schema13.optionalKey(Schema13.Array(Schema13.String.check(Schema13.isMinLength(1))))
 });
-var StepOutputSubmission = Schema12.Struct({ output: JsonDocumentObject });
-var StepSessionUpdate = Schema12.Struct({
-  kind: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(80)),
-  content: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(4000))
+var StepOutputSubmission = Schema13.Struct({ output: JsonDocumentObject });
+var StepSessionUpdate = Schema13.Struct({
+  kind: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(80)),
+  content: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(4000))
 });
-var StepAttemptSessionUpdate = Schema12.Struct({
+var StepAttemptSessionUpdate = Schema13.Struct({
   id: Id,
-  kind: Schema12.String,
-  content: Schema12.String,
+  kind: Schema13.String,
+  content: Schema13.String,
   createdAt: Timestamp
 });
-var StepAttemptSessionUpdateList = Schema12.Struct({
-  items: Schema12.Array(StepAttemptSessionUpdate),
-  next: Schema12.optionalKey(Schema12.String)
+var StepAttemptSessionUpdateList = Schema13.Struct({
+  items: Schema13.Array(StepAttemptSessionUpdate),
+  next: Schema13.optionalKey(Schema13.String)
 });
-var StepOutputSubmissionResult = Schema12.Union([
-  Schema12.Struct({ status: Schema12.Literal("accepted") }),
-  Schema12.Struct({
-    status: Schema12.Literal("rejected"),
-    message: Schema12.String,
-    submissionsLeft: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(0))
-  }),
-  Schema12.Struct({ status: Schema12.Literal("failed"), message: Schema12.String })
-]);
 var HarnessHoldReasons = ["out_of_quota", "rate_limited", "login_refused", "failed_to_start"];
 var SkippedChoiceReasons = ["not_on_runner", ...HarnessHoldReasons];
-var SkippedChoice = Schema12.Struct({
-  harness: Schema12.optionalKey(Schema12.String),
-  model: Schema12.optionalKey(Schema12.String),
-  effort: Schema12.optionalKey(Schema12.Literals(AgentEfforts)),
-  reason: Schema12.Literals(SkippedChoiceReasons),
-  until: Schema12.optionalKey(Timestamp)
-});
-var StepAttempt = Schema12.Struct({
+var SkippedChoice = Schema13.Struct({
+  harness: Schema13.optionalKey(Schema13.String),
+  model: Schema13.optionalKey(Schema13.String),
+  effort: Schema13.optionalKey(Schema13.Literals(AgentEfforts)),
+  reason: Schema13.Literals(SkippedChoiceReasons),
+  until: Schema13.optionalKey(Timestamp)
+});
+var StepAttempt = Schema13.Struct({
   id: Id,
   workspaceId: Id,
-  teamId: Schema12.optionalKey(Id),
-  taskId: Schema12.optionalKey(Id),
-  sessionId: Schema12.optionalKey(Id),
+  teamId: Schema13.optionalKey(Id),
+  taskId: Schema13.optionalKey(Id),
+  sessionId: Schema13.optionalKey(Id),
   runId: Id,
-  stepSnapshotId: Schema12.optionalKey(Id),
-  stepKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240)),
-  sequence: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(0)),
-  required: Schema12.Boolean,
-  attempt: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
-  retryOfAttemptId: Schema12.optionalKey(Id),
+  stepSnapshotId: Schema13.optionalKey(Id),
+  stepKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240)),
+  sequence: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0)),
+  required: Schema13.Boolean,
+  attempt: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
+  retryOfAttemptId: Schema13.optionalKey(Id),
   status: StepAttemptStatus,
   inputManifest: StepAttemptInputManifest,
   execution: StepAttemptExecutionEnvironment,
-  output: Schema12.optionalKey(LoopStepOutput),
-  brief: Schema12.optionalKey(StepBrief),
-  failureSummary: Schema12.optionalKey(LoopSafeText),
-  reviewEvidence: Schema12.Array(LoopSafeRef),
-  skippedChoices: Schema12.optionalKey(Schema12.Array(SkippedChoice)),
-  lease: Schema12.optionalKey(StepAttemptLease),
-  claimIdempotencyKey: Schema12.optionalKey(LoopSafeReferenceString),
-  terminalIdempotencyKey: Schema12.optionalKey(LoopSafeReferenceString),
-  startedAt: Schema12.optionalKey(Timestamp),
-  completedAt: Schema12.optionalKey(Timestamp),
+  output: Schema13.optionalKey(LoopStepOutput),
+  brief: Schema13.optionalKey(StepBrief),
+  failureSummary: Schema13.optionalKey(LoopSafeText),
+  reviewEvidence: Schema13.Array(LoopSafeRef),
+  skippedChoices: Schema13.optionalKey(Schema13.Array(SkippedChoice)),
+  lease: Schema13.optionalKey(StepAttemptLease),
+  claimIdempotencyKey: Schema13.optionalKey(LoopSafeReferenceString),
+  terminalIdempotencyKey: Schema13.optionalKey(LoopSafeReferenceString),
+  startedAt: Schema13.optionalKey(Timestamp),
+  completedAt: Schema13.optionalKey(Timestamp),
   createdAt: Timestamp,
   updatedAt: Timestamp
 });
-var StepAttemptList = Schema12.Struct({ items: Schema12.Array(StepAttempt) });
-var QuestionResponderPolicy = Schema12.Struct({
-  eligibleMemberIds: Schema12.Array(Id).check(Schema12.isMinLength(1), Schema12.isMaxLength(100), Schema12.isUnique()),
-  allowWorkspaceAdmins: Schema12.Boolean
-});
-var QuestionAnswer = Schema12.Struct({
+var StepAttemptList = Schema13.Struct({ items: Schema13.Array(StepAttempt) });
+var QuestionResponderPolicy = Schema13.Struct({
+  eligibleMemberIds: Schema13.Array(Id).check(Schema13.isMaxLength(100), Schema13.isUnique()),
+  allowWorkspaceAdmins: Schema13.Boolean
+}).check(Schema13.makeFilter((policy) => policy.eligibleMemberIds.length > 0 || policy.allowWorkspaceAdmins || "someone who may answer"));
+var QuestionAnswer = Schema13.Struct({
   value: LoopSafeText,
-  answeredByUserId: Schema12.optionalKey(Id),
-  byDefault: Schema12.optionalKey(Schema12.Boolean),
+  answeredByUserId: Schema13.optionalKey(Id),
+  byDefault: Schema13.optionalKey(Schema13.Boolean),
   answeredAt: Timestamp,
-  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+  idempotencyKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240))
 });
-var Question = Schema12.Struct({
+var Question = Schema13.Struct({
   id: Id,
   workspaceId: Id,
-  teamId: Schema12.optionalKey(Id),
-  taskId: Schema12.optionalKey(Id),
+  teamId: Schema13.optionalKey(Id),
+  taskId: Schema13.optionalKey(Id),
   runId: Id,
-  stepKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240)),
+  stepKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240)),
   waitId: Id,
-  taskThreadEntryId: Schema12.optionalKey(Id),
+  taskThreadEntryId: Schema13.optionalKey(Id),
   prompt: QuestionText,
-  options: Schema12.optionalKey(Schema12.Array(QuestionText)),
-  freeText: Schema12.optionalKey(Schema12.Boolean),
-  optionDescriptions: Schema12.optionalKey(Schema12.Record(Schema12.String, QuestionText)),
-  recommended: Schema12.optionalKey(QuestionText),
-  recommendationReason: Schema12.optionalKey(QuestionText),
-  informationOnly: Schema12.optionalKey(Schema12.Boolean),
-  default: Schema12.optionalKey(LoopSafeText),
-  defaultAt: Schema12.optionalKey(Timestamp),
+  options: Schema13.optionalKey(Schema13.Array(QuestionText)),
+  freeText: Schema13.optionalKey(Schema13.Boolean),
+  optionDescriptions: Schema13.optionalKey(Schema13.Record(Schema13.String, QuestionText)),
+  recommended: Schema13.optionalKey(QuestionText),
+  recommendationReason: Schema13.optionalKey(QuestionText),
+  informationOnly: Schema13.optionalKey(Schema13.Boolean),
+  default: Schema13.optionalKey(LoopSafeText),
+  defaultAt: Schema13.optionalKey(Timestamp),
   responderPolicy: QuestionResponderPolicy,
   status: QuestionStatus,
-  answer: Schema12.optionalKey(QuestionAnswer),
-  resolutionOutcome: Schema12.optionalKey(LoopSafeText),
+  answer: Schema13.optionalKey(QuestionAnswer),
+  resolutionOutcome: Schema13.optionalKey(LoopSafeText),
   createdAt: Timestamp,
   updatedAt: Timestamp,
-  resolvedAt: Schema12.optionalKey(Timestamp)
-});
-var QuestionAnswerCreate = Schema12.Struct({
+  resolvedAt: Schema13.optionalKey(Timestamp)
+});
+var StepOutputSubmissionResult = Schema13.Union([
+  Schema13.Struct({ status: Schema13.Literal("accepted") }),
+  Schema13.Struct({
+    status: Schema13.Literal("rejected"),
+    message: Schema13.String,
+    submissionsLeft: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0))
+  }),
+  Schema13.Struct({ status: Schema13.Literal("failed"), message: Schema13.String }),
+  Schema13.Struct({ status: Schema13.Literal("parked"), message: Schema13.String, question: Question })
+]);
+var QuestionAnswerCreate = Schema13.Struct({
   value: LoopSafeText,
-  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+  idempotencyKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240))
 });
-var QuestionList = Schema12.Struct({ items: Schema12.Array(Question) });
-var RunLaunchContext = Schema12.Struct({
-  teamId: Schema12.optionalKey(Id),
-  remoteUrl: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(2000))),
-  repoBindingId: Schema12.optionalKey(Id),
-  branch: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(255)))
+var QuestionList = Schema13.Struct({ items: Schema13.Array(Question) });
+var RunLaunchContext = Schema13.Struct({
+  teamId: Schema13.optionalKey(Id),
+  remoteUrl: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(2000))),
+  repoBindingId: Schema13.optionalKey(Id),
+  branch: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(255)))
 });
-var RunStart = Schema12.Struct({
+var RunStart = Schema13.Struct({
   workspaceId: Id,
-  loop: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120))),
-  words: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(4000))),
-  plainWords: Schema12.optionalKey(Schema12.Boolean),
-  task: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(200))),
-  teamId: Schema12.optionalKey(Id),
-  taskTypeId: Schema12.optionalKey(Id),
-  input: Schema12.optionalKey(Schema12.Record(Schema12.String, Schema12.Unknown)),
-  context: Schema12.optionalKey(RunLaunchContext),
-  devVersionId: Schema12.optionalKey(Id),
-  constraints: Schema12.optionalKey(Schema12.Array(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(1000))).check(Schema12.isMaxLength(20))),
-  fresh: Schema12.optionalKey(Schema12.Boolean),
-  overrideBlockers: Schema12.optionalKey(Schema12.Boolean)
-});
-var RunActionTake = Schema12.Struct({ overrideBlockers: Schema12.optionalKey(Schema12.Boolean) });
-var RunStarted = Schema12.Struct({
+  loop: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(120))),
+  words: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(4000))),
+  plainWords: Schema13.optionalKey(Schema13.Boolean),
+  task: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(200))),
+  teamId: Schema13.optionalKey(Id),
+  taskTypeId: Schema13.optionalKey(Id),
+  input: Schema13.optionalKey(Schema13.Record(Schema13.String, Schema13.Unknown)),
+  context: Schema13.optionalKey(RunLaunchContext),
+  devVersionId: Schema13.optionalKey(Id),
+  constraints: Schema13.optionalKey(Schema13.Array(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(1000))).check(Schema13.isMaxLength(20))),
+  fresh: Schema13.optionalKey(Schema13.Boolean),
+  overrideBlockers: Schema13.optionalKey(Schema13.Boolean)
+});
+var RunActionTake = Schema13.Struct({ overrideBlockers: Schema13.optionalKey(Schema13.Boolean) });
+var RunStarted = Schema13.Struct({
   run: Run,
-  task: Schema12.optionalKey(Schema12.Struct({ id: Id, taskKey: Schema12.String })),
-  inferred: Schema12.Struct({
-    repoBindingId: Schema12.optionalKey(Id),
-    branch: Schema12.optionalKey(Schema12.String),
-    changeRequestId: Schema12.optionalKey(Id),
-    trackerKeys: Schema12.Array(Schema12.String),
-    outcome: Schema12.optionalKey(Schema12.String)
+  task: Schema13.optionalKey(Schema13.Struct({ id: Id, taskKey: Schema13.String })),
+  inferred: Schema13.Struct({
+    repoBindingId: Schema13.optionalKey(Id),
+    branch: Schema13.optionalKey(Schema13.String),
+    changeRequestId: Schema13.optionalKey(Id),
+    trackerKeys: Schema13.Array(Schema13.String),
+    outcome: Schema13.optionalKey(Schema13.String)
   })
 });
-var RunStepSummary = Schema12.Struct({
-  name: Schema12.String,
+var RunStepSummary = Schema13.Struct({
+  name: Schema13.String,
   status: StepAttemptStatus,
   startedAt: Timestamp,
-  completedAt: Schema12.optionalKey(Timestamp),
-  output: Schema12.optionalKey(Schema12.Unknown),
-  attempts: Schema12.Array(Schema12.Struct({
+  completedAt: Schema13.optionalKey(Timestamp),
+  output: Schema13.optionalKey(Schema13.Unknown),
+  attempts: Schema13.Array(Schema13.Struct({
     id: Id,
-    attempt: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+    attempt: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
     status: StepAttemptStatus,
-    failureSummary: Schema12.optionalKey(Schema12.String),
-    output: Schema12.optionalKey(Schema12.Unknown),
-    revision: Schema12.optionalKey(Schema12.String)
+    failureSummary: Schema13.optionalKey(Schema13.String),
+    output: Schema13.optionalKey(Schema13.Unknown),
+    revision: Schema13.optionalKey(Schema13.String)
   }))
 });
 var RunSteerDeliveries = ["queued", "delivered", "failed"];
-var RunSteer = Schema12.Struct({
+var RunSteer = Schema13.Struct({
   id: Id,
   text: LoopSafeText,
-  delivery: Schema12.Literals(RunSteerDeliveries),
-  step: Schema12.optionalKey(Schema12.String),
+  delivery: Schema13.Literals(RunSteerDeliveries),
+  step: Schema13.optionalKey(Schema13.String),
   createdAt: Timestamp
 });
-var RunSteerInput = Schema12.Struct({
+var RunSteerInput = Schema13.Struct({
   text: LoopSafeText,
-  stepAttemptId: Schema12.optionalKey(Id),
-  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+  stepAttemptId: Schema13.optionalKey(Id),
+  idempotencyKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240))
 });
-var RunResumeInput = Schema12.Struct({
-  steer: Schema12.optionalKey(Schema12.Struct({
+var RunResumeInput = Schema13.Struct({
+  steer: Schema13.optionalKey(Schema13.Struct({
     text: LoopSafeText,
-    idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+    idempotencyKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240))
   }))
 });
-var RunSteerSent = Schema12.Struct({
+var RunSteerSent = Schema13.Struct({
   steer: RunSteer,
-  target: Schema12.Literals(["session", "next_step"])
+  target: Schema13.Literals(["session", "next_step"])
 });
 var RunDisplayStates = [
   "queued",
@@ -2247,206 +2335,206 @@ var RunDisplayStates = [
   "succeeded",
   "partial"
 ];
-var RunDisplay = Schema12.Struct({
-  state: Schema12.Literals(RunDisplayStates),
-  retried: Schema12.Boolean,
-  summary: Schema12.optionalKey(Schema12.String)
+var RunDisplay = Schema13.Struct({
+  state: Schema13.Literals(RunDisplayStates),
+  retried: Schema13.Boolean,
+  summary: Schema13.optionalKey(Schema13.String)
 });
 var RunGraphNodeKinds = ["agent", "check", "question", "child", "wait", "activity"];
-var RunGraphNode = Schema12.Struct({
+var RunGraphNode = Schema13.Struct({
   id: Id,
-  name: Schema12.String,
-  kind: Schema12.Literals(RunGraphNodeKinds),
-  status: Schema12.Literals(RunDisplayStates),
+  name: Schema13.String,
+  kind: Schema13.Literals(RunGraphNodeKinds),
+  status: Schema13.Literals(RunDisplayStates),
   startedAt: Timestamp,
-  endedAt: Schema12.optionalKey(Timestamp),
-  attempts: Schema12.Array(Schema12.Struct({
+  endedAt: Schema13.optionalKey(Timestamp),
+  attempts: Schema13.Array(Schema13.Struct({
     id: Id,
-    attempt: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
-    status: Schema12.Literals(RunDisplayStates),
-    failureSummary: Schema12.optionalKey(Schema12.String)
+    attempt: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
+    status: Schema13.Literals(RunDisplayStates),
+    failureSummary: Schema13.optionalKey(Schema13.String)
   })),
-  agent: Schema12.optionalKey(Schema12.Struct({
+  agent: Schema13.optionalKey(Schema13.Struct({
     id: Id,
-    harness: Schema12.optionalKey(Schema12.String),
-    model: Schema12.optionalKey(Schema12.String),
-    runner: Schema12.optionalKey(Schema12.Struct({ id: Id, name: Schema12.String }))
+    harness: Schema13.optionalKey(Schema13.String),
+    model: Schema13.optionalKey(Schema13.String),
+    runner: Schema13.optionalKey(Schema13.Struct({ id: Id, name: Schema13.String }))
   })),
-  child: Schema12.optionalKey(Schema12.Struct({
+  child: Schema13.optionalKey(Schema13.Struct({
     runId: Id,
-    loopTitle: Schema12.String,
+    loopTitle: Schema13.String,
     display: RunDisplay,
-    task: Schema12.optionalKey(Schema12.Struct({ id: Id, key: Schema12.String, title: Schema12.String }))
+    task: Schema13.optionalKey(Schema13.Struct({ id: Id, key: Schema13.String, title: Schema13.String }))
   }))
 });
-var RunGraph = Schema12.Struct({
-  columns: Schema12.Array(Schema12.Array(RunGraphNode)),
-  needs: Schema12.Array(Schema12.Struct({ from: Id, to: Id }))
-});
-var RunHeader = Schema12.Struct({
-  loopTitle: Schema12.String,
-  branch: Schema12.optionalKey(Schema12.String),
-  changeRequest: Schema12.optionalKey(Schema12.Struct({ id: Id, title: Schema12.String, url: Schema12.String })),
-  startedBy: Schema12.optionalKey(Schema12.Union([
-    Schema12.Struct({ kind: Schema12.Literal("person"), name: Schema12.String }),
-    Schema12.Struct({ kind: Schema12.Literal("event"), event: Schema12.String })
+var RunGraph = Schema13.Struct({
+  columns: Schema13.Array(Schema13.Array(RunGraphNode)),
+  needs: Schema13.Array(Schema13.Struct({ from: Id, to: Id }))
+});
+var RunHeader = Schema13.Struct({
+  loopTitle: Schema13.String,
+  branch: Schema13.optionalKey(Schema13.String),
+  changeRequest: Schema13.optionalKey(Schema13.Struct({ id: Id, title: Schema13.String, url: Schema13.String })),
+  startedBy: Schema13.optionalKey(Schema13.Union([
+    Schema13.Struct({ kind: Schema13.Literal("person"), name: Schema13.String }),
+    Schema13.Struct({ kind: Schema13.Literal("event"), event: Schema13.String })
   ]))
 });
-var RunShow = Schema12.Struct({
+var RunShow = Schema13.Struct({
   run: Run,
   header: RunHeader,
   display: RunDisplay,
   graph: RunGraph,
-  steps: Schema12.Array(RunStepSummary),
-  questions: Schema12.Array(Question),
-  children: Schema12.Array(Schema12.Struct({
+  steps: Schema13.Array(RunStepSummary),
+  questions: Schema13.Array(Question),
+  children: Schema13.Array(Schema13.Struct({
     runId: Id,
-    name: Schema12.String,
+    name: Schema13.String,
     status: RunStatus,
     createdAt: Timestamp,
-    unsettled: Schema12.optional(Schema12.Array(Schema12.String))
+    unsettled: Schema13.optional(Schema13.Array(Schema13.String))
   })),
-  activities: Schema12.Array(Schema12.Struct({
-    name: Schema12.String,
-    attempt: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
-    status: Schema12.Literals(["succeeded", "failed"]),
+  activities: Schema13.Array(Schema13.Struct({
+    name: Schema13.String,
+    attempt: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
+    status: Schema13.Literals(["succeeded", "failed"]),
     recordedAt: Timestamp
   })),
-  artifacts: Schema12.Array(RunArtifact),
-  findings: Schema12.Array(RunArtifact),
-  events: Schema12.Array(Schema12.Struct({ id: Id, type: Schema12.String, occurredAt: Timestamp })),
-  evidence: Schema12.Array(RunEvidence),
-  steers: Schema12.Array(RunSteer),
-  waiting: Schema12.Array(RunWaiting),
-  closures: Schema12.Array(RunClosure)
-});
-var RunStartPreview = Schema12.Struct({
-  loop: Schema12.Struct({ id: Schema12.String, title: Schema12.String, outcome: Schema12.optionalKey(Schema12.String) }),
-  inputSchema: Schema12.Record(Schema12.String, Schema12.Unknown),
-  input: Schema12.Record(Schema12.String, Schema12.Unknown),
-  missing: Schema12.Array(Schema12.String),
-  message: Schema12.optionalKey(Schema12.String),
-  waitingOn: Schema12.optionalKey(WaitingOn),
-  teamId: Schema12.optionalKey(Id),
-  inferred: Schema12.Struct({
-    repoBindingId: Schema12.optionalKey(Id),
-    branch: Schema12.optionalKey(Schema12.String),
-    changeRequestId: Schema12.optionalKey(Id),
-    trackerKeys: Schema12.Array(Schema12.String),
-    outcome: Schema12.optionalKey(Schema12.String)
+  artifacts: Schema13.Array(RunArtifact),
+  findings: Schema13.Array(RunArtifact),
+  events: Schema13.Array(Schema13.Struct({ id: Id, type: Schema13.String, occurredAt: Timestamp })),
+  evidence: Schema13.Array(RunEvidence),
+  steers: Schema13.Array(RunSteer),
+  waiting: Schema13.Array(RunWaiting),
+  closures: Schema13.Array(RunClosure)
+});
+var RunStartPreview = Schema13.Struct({
+  loop: Schema13.Struct({ id: Schema13.String, title: Schema13.String, outcome: Schema13.optionalKey(Schema13.String) }),
+  inputSchema: Schema13.Record(Schema13.String, Schema13.Unknown),
+  input: Schema13.Record(Schema13.String, Schema13.Unknown),
+  missing: Schema13.Array(Schema13.String),
+  message: Schema13.optionalKey(Schema13.String),
+  waitingOn: Schema13.optionalKey(WaitingOn),
+  teamId: Schema13.optionalKey(Id),
+  inferred: Schema13.Struct({
+    repoBindingId: Schema13.optionalKey(Id),
+    branch: Schema13.optionalKey(Schema13.String),
+    changeRequestId: Schema13.optionalKey(Id),
+    trackerKeys: Schema13.Array(Schema13.String),
+    outcome: Schema13.optionalKey(Schema13.String)
   })
 });
-var LoopVersion = Schema12.String.check(Schema12.isPattern(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/));
-var ProgramLoop = Schema12.Struct({
-  id: Schema12.String,
-  title: Schema12.String,
-  version: Schema12.optionalKey(LoopVersion),
-  layer: Schema12.Literals(["team", "workspace"]),
-  digest: Schema12.String,
-  outcome: Schema12.optionalKey(Schema12.String),
-  offers: Schema12.Array(Schema12.Struct({
-    id: Schema12.String,
-    title: Schema12.String,
-    loop: Schema12.String,
-    from: Schema12.optionalKey(Schema12.String)
+var LoopVersion = Schema13.String.check(Schema13.isPattern(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/));
+var ProgramLoop = Schema13.Struct({
+  id: Schema13.String,
+  title: Schema13.String,
+  version: Schema13.optionalKey(LoopVersion),
+  layer: Schema13.Literals(["team", "workspace"]),
+  digest: Schema13.String,
+  outcome: Schema13.optionalKey(Schema13.String),
+  offers: Schema13.Array(Schema13.Struct({
+    id: Schema13.String,
+    title: Schema13.String,
+    loop: Schema13.String,
+    from: Schema13.optionalKey(Schema13.String)
   })),
   publishedAt: Timestamp,
-  kit: Schema12.String
-});
-var AutomaticStart = Schema12.Struct({
-  eventId: Schema12.String,
-  eventType: Schema12.String,
-  teamId: Schema12.Union([Schema12.String, Schema12.Null]),
-  loop: Schema12.String,
-  runId: Schema12.optionalKey(Schema12.String),
-  rejection: Schema12.optionalKey(Schema12.String),
-  at: Schema12.String
-});
-var AutomaticStartList = Schema12.Struct({ items: Schema12.Array(AutomaticStart) });
-var AgentFallback = Schema12.Struct({
-  harness: Schema12.String,
-  model: Schema12.optionalKey(Schema12.String),
-  effort: Schema12.optionalKey(Schema12.Literals(AgentEfforts))
-});
-var ProgramAgent = Schema12.Struct({
-  id: Schema12.String,
-  layer: Schema12.Literals(["team", "workspace"]),
-  kit: Schema12.String,
-  extends: Schema12.optionalKey(Schema12.String),
-  instructions: Schema12.optionalKey(Schema12.String),
-  harness: Schema12.optionalKey(Schema12.String),
-  model: Schema12.optionalKey(Schema12.String),
-  effort: Schema12.optionalKey(Schema12.Literals(AgentEfforts)),
-  fallbacks: Schema12.optionalKey(Schema12.Array(AgentFallback)),
-  tools: Schema12.optionalKey(Schema12.Array(Schema12.Literals(AgentCapabilities))),
-  skills: Schema12.optionalKey(Schema12.Array(Schema12.String)),
-  network: Schema12.optionalKey(AgentSandboxNetwork),
-  sandbox: Schema12.optionalKey(Schema12.Literal("docker")),
-  fieldLayers: Schema12.optionalKey(Schema12.Struct({
-    instructions: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    harness: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    model: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    effort: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    fallbacks: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    tools: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    skills: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    network: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
-    sandbox: Schema12.optionalKey(Schema12.Literals(LoopLayers))
+  kit: Schema13.String
+});
+var AutomaticStart = Schema13.Struct({
+  eventId: Schema13.String,
+  eventType: Schema13.String,
+  teamId: Schema13.Union([Schema13.String, Schema13.Null]),
+  loop: Schema13.String,
+  runId: Schema13.optionalKey(Schema13.String),
+  rejection: Schema13.optionalKey(Schema13.String),
+  at: Schema13.String
+});
+var AutomaticStartList = Schema13.Struct({ items: Schema13.Array(AutomaticStart) });
+var AgentFallback = Schema13.Struct({
+  harness: Schema13.String,
+  model: Schema13.optionalKey(Schema13.String),
+  effort: Schema13.optionalKey(Schema13.Literals(AgentEfforts))
+});
+var ProgramAgent = Schema13.Struct({
+  id: Schema13.String,
+  layer: Schema13.Literals(["team", "workspace"]),
+  kit: Schema13.String,
+  extends: Schema13.optionalKey(Schema13.String),
+  instructions: Schema13.optionalKey(Schema13.String),
+  harness: Schema13.optionalKey(Schema13.String),
+  model: Schema13.optionalKey(Schema13.String),
+  effort: Schema13.optionalKey(Schema13.Literals(AgentEfforts)),
+  fallbacks: Schema13.optionalKey(Schema13.Array(AgentFallback)),
+  tools: Schema13.optionalKey(Schema13.Array(Schema13.Literals(AgentCapabilities))),
+  skills: Schema13.optionalKey(Schema13.Array(Schema13.String)),
+  network: Schema13.optionalKey(AgentSandboxNetwork),
+  sandbox: Schema13.optionalKey(Schema13.Literal("docker")),
+  fieldLayers: Schema13.optionalKey(Schema13.Struct({
+    instructions: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    harness: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    model: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    effort: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    fallbacks: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    tools: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    skills: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    network: Schema13.optionalKey(Schema13.Literals(LoopLayers)),
+    sandbox: Schema13.optionalKey(Schema13.Literals(LoopLayers))
   }))
 });
-var ProgramAgentList = Schema12.Struct({ items: Schema12.Array(ProgramAgent) });
-var ProgramLoopList = Schema12.Struct({ items: Schema12.Array(ProgramLoop) });
-var RunListItem = Schema12.Struct({
+var ProgramAgentList = Schema13.Struct({ items: Schema13.Array(ProgramAgent) });
+var ProgramLoopList = Schema13.Struct({ items: Schema13.Array(ProgramLoop) });
+var RunListItem = Schema13.Struct({
   run: Run,
-  loop: Schema12.Struct({ id: Schema12.String, title: Schema12.String }),
-  task: Schema12.optionalKey(Schema12.Struct({ id: Id, key: Schema12.String, title: Schema12.String })),
+  loop: Schema13.Struct({ id: Schema13.String, title: Schema13.String }),
+  task: Schema13.optionalKey(Schema13.Struct({ id: Id, key: Schema13.String, title: Schema13.String })),
   display: RunDisplay,
-  miniGraph: Schema12.Array(Schema12.Literals(RunDisplayStates))
+  miniGraph: Schema13.Array(Schema13.Literals(RunDisplayStates))
 });
-var RunList = Schema12.Struct({
-  items: Schema12.Array(RunListItem),
-  next: Schema12.optionalKey(Schema12.String)
+var RunList = Schema13.Struct({
+  items: Schema13.Array(RunListItem),
+  next: Schema13.optionalKey(Schema13.String)
 });
 var RunWaitReasons = ["question", "completed", "failed", "stopped", "timeout"];
-var RunWaitResult = Schema12.Struct({
-  reason: Schema12.Literals(RunWaitReasons),
+var RunWaitResult = Schema13.Struct({
+  reason: Schema13.Literals(RunWaitReasons),
   run: Run,
-  questions: Schema12.Array(Question)
+  questions: Schema13.Array(Question)
 });
-var RunAnswer = Schema12.Struct({
+var RunAnswer = Schema13.Struct({
   value: LoopSafeText,
-  question: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(200))),
-  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+  question: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(200))),
+  idempotencyKey: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(240))
 });
 var RunActionKinds = ["offer", "stop", "resume"];
-var RunActionSummary = Schema12.Struct({
-  id: Schema12.String.check(Schema12.isMinLength(1)),
-  title: Schema12.String,
-  kind: Schema12.Literals(RunActionKinds),
-  loop: Schema12.optionalKey(Schema12.String)
-});
-var RunActionList = Schema12.Struct({ items: Schema12.Array(RunActionSummary) });
-var RunActionTaken = Schema12.Struct({ action: Schema12.String, run: Run });
+var RunActionSummary = Schema13.Struct({
+  id: Schema13.String.check(Schema13.isMinLength(1)),
+  title: Schema13.String,
+  kind: Schema13.Literals(RunActionKinds),
+  loop: Schema13.optionalKey(Schema13.String)
+});
+var RunActionList = Schema13.Struct({ items: Schema13.Array(RunActionSummary) });
+var RunActionTaken = Schema13.Struct({ action: Schema13.String, run: Run });
 
 // packages/core/src/schedule.ts
-import * as Schema13 from "effect/Schema";
+import * as Schema14 from "effect/Schema";
 import * as DateTime from "effect/DateTime";
 import * as Option from "effect/Option";
 var ScheduleFrequency = ["daily", "weekly"];
 var ScheduleMisfirePolicies = ["skip", "fire_once", "catch_up"];
 var ScheduleOverlapPolicies = ["allow", "skip", "coalesce"];
 var ScheduleVersionStatuses = ["draft", "published", "disabled", "archived"];
-var ScheduleCalendarRule = Schema13.Struct({
-  frequency: Schema13.Literals(ScheduleFrequency),
-  hour: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0), Schema13.isLessThanOrEqualTo(23)),
-  minute: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0), Schema13.isLessThanOrEqualTo(59)),
-  second: Schema13.optionalKey(Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0), Schema13.isLessThanOrEqualTo(59))),
-  daysOfWeek: Schema13.optionalKey(Schema13.Array(Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0), Schema13.isLessThanOrEqualTo(6))).check(Schema13.isMinLength(1), Schema13.isMaxLength(7)))
+var ScheduleCalendarRule = Schema14.Struct({
+  frequency: Schema14.Literals(ScheduleFrequency),
+  hour: Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0), Schema14.isLessThanOrEqualTo(23)),
+  minute: Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0), Schema14.isLessThanOrEqualTo(59)),
+  second: Schema14.optionalKey(Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0), Schema14.isLessThanOrEqualTo(59))),
+  daysOfWeek: Schema14.optionalKey(Schema14.Array(Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0), Schema14.isLessThanOrEqualTo(6))).check(Schema14.isMinLength(1), Schema14.isMaxLength(7)))
 });
-var ScheduleCronRule = Schema13.Struct({
-  cron: Schema13.String.check(Schema13.isMinLength(9), Schema13.isMaxLength(200), Schema13.isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
+var ScheduleCronRule = Schema14.Struct({
+  cron: Schema14.String.check(Schema14.isMinLength(9), Schema14.isMaxLength(200), Schema14.isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
 });
-var ScheduleRule = Schema13.Union([ScheduleCalendarRule, ScheduleCronRule]);
+var ScheduleRule = Schema14.Union([ScheduleCalendarRule, ScheduleCronRule]);
 var cronBounds = [
   [0, 59],
   [0, 23],
@@ -2488,25 +2576,25 @@ function parseCron(cron) {
 function isScheduleRule(value) {
   return guard(ScheduleRule)(value) && (!("cron" in value) || parseCron(value.cron) !== undefined);
 }
-var ScheduleVersion = Schema13.Struct({
-  contractVersion: Schema13.Literal("schedule.v1"),
-  id: Schema13.String.check(Schema13.isMinLength(1)),
-  scheduleId: Schema13.String.check(Schema13.isMinLength(1)),
-  workspaceId: Schema13.String.check(Schema13.isMinLength(1)),
-  teamId: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1))),
-  loopId: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1))),
-  name: Schema13.optionalKey(Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(200))),
-  version: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(1)),
-  status: Schema13.Literals(ScheduleVersionStatuses),
-  timezone: Schema13.String.check(Schema13.isMinLength(1), Schema13.isMaxLength(80)),
+var ScheduleVersion = Schema14.Struct({
+  contractVersion: Schema14.Literal("schedule.v1"),
+  id: Schema14.String.check(Schema14.isMinLength(1)),
+  scheduleId: Schema14.String.check(Schema14.isMinLength(1)),
+  workspaceId: Schema14.String.check(Schema14.isMinLength(1)),
+  teamId: Schema14.optionalKey(Schema14.String.check(Schema14.isMinLength(1))),
+  loopId: Schema14.optionalKey(Schema14.String.check(Schema14.isMinLength(1))),
+  name: Schema14.optionalKey(Schema14.String.check(Schema14.isMinLength(1), Schema14.isMaxLength(200))),
+  version: Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(1)),
+  status: Schema14.Literals(ScheduleVersionStatuses),
+  timezone: Schema14.String.check(Schema14.isMinLength(1), Schema14.isMaxLength(80)),
   rule: ScheduleRule,
-  misfirePolicy: Schema13.Literals(ScheduleMisfirePolicies),
-  overlapPolicy: Schema13.Literals(ScheduleOverlapPolicies),
-  maxCatchUp: Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0), Schema13.isLessThanOrEqualTo(200)),
-  misfireGraceSeconds: Schema13.optionalKey(Schema13.Int.check(Schema13.isGreaterThanOrEqualTo(0), Schema13.isLessThanOrEqualTo(604800))),
-  inputSchemaRef: Schema13.optionalKey(LoopDataSchemaRef),
-  input: Schema13.optionalKey(SafeJson),
-  createdAt: Schema13.String.check(Schema13.isMinLength(1))
+  misfirePolicy: Schema14.Literals(ScheduleMisfirePolicies),
+  overlapPolicy: Schema14.Literals(ScheduleOverlapPolicies),
+  maxCatchUp: Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0), Schema14.isLessThanOrEqualTo(200)),
+  misfireGraceSeconds: Schema14.optionalKey(Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(0), Schema14.isLessThanOrEqualTo(604800))),
+  inputSchemaRef: Schema14.optionalKey(LoopDataSchemaRef),
+  input: Schema14.optionalKey(SafeJson),
+  createdAt: Schema14.String.check(Schema14.isMinLength(1))
 });
 var zones = new Map;
 var resolvedLocalDateTimes = new Map;
@@ -2532,102 +2620,102 @@ var LoopCapabilities2 = [
   "read_project",
   "draft_update"
 ];
-var JsonObject2 = Schema14.Record(Schema14.String, Schema14.Json);
-var SecretName = Schema14.String.check(Schema14.isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
-var EventFilterValue = Schema14.Union([Schema14.String, Schema14.Finite, Schema14.Boolean, Schema14.Null]);
-var LoopManifest = Schema14.Struct({
-  id: Schema14.String,
-  title: Schema14.String,
-  version: Schema14.optionalKey(LoopVersion),
+var JsonObject2 = Schema15.Record(Schema15.String, Schema15.Json);
+var SecretName2 = Schema15.String.check(Schema15.isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
+var EventFilterValue = Schema15.Union([Schema15.String, Schema15.Finite, Schema15.Boolean, Schema15.Null]);
+var LoopManifest = Schema15.Struct({
+  id: Schema15.String,
+  title: Schema15.String,
+  version: Schema15.optionalKey(LoopVersion),
   input: JsonObject2,
   output: JsonObject2,
-  outcome: Schema14.optionalKey(Schema14.Literals(["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"])),
-  agents: Schema14.Record(Schema14.String, Schema14.String),
-  checkout: Schema14.Literals(["none", "read", "write"]),
-  when: Schema14.Array(Schema14.Struct({
-    event: Schema14.String,
-    filter: Schema14.optionalKey(Schema14.Record(Schema14.String, Schema14.Union([EventFilterValue, Schema14.Array(EventFilterValue)]))),
-    input: Schema14.Record(Schema14.String, Schema14.String),
-    values: Schema14.optionalKey(JsonObject2)
+  outcome: Schema15.optionalKey(Schema15.Literals(["feature", "bug", "refactor", "investigation", "docs", "migration", "performance"])),
+  agents: Schema15.Record(Schema15.String, Schema15.String),
+  checkout: Schema15.Literals(["none", "read", "write"]),
+  when: Schema15.Array(Schema15.Struct({
+    event: Schema15.String,
+    filter: Schema15.optionalKey(Schema15.Record(Schema15.String, Schema15.Union([EventFilterValue, Schema15.Array(EventFilterValue)]))),
+    input: Schema15.Record(Schema15.String, Schema15.String),
+    values: Schema15.optionalKey(JsonObject2)
   })),
-  offers: Schema14.Array(Schema14.Struct({
-    id: Schema14.String,
-    title: Schema14.String,
-    loop: Schema14.String,
-    from: Schema14.optionalKey(Schema14.String)
+  offers: Schema15.Array(Schema15.Struct({
+    id: Schema15.String,
+    title: Schema15.String,
+    loop: Schema15.String,
+    from: Schema15.optionalKey(Schema15.String)
   })),
-  capabilities: Schema14.Array(Schema14.Literals(LoopCapabilities2)),
-  secrets: Schema14.optionalKey(Schema14.Array(SecretName)),
-  network: Schema14.optionalKey(AgentSandboxNetwork),
-  schedule: Schema14.optionalKey(Schema14.Struct({ rule: ScheduleRule, timezone: Schema14.String }))
-});
-var LoopDetail = Schema14.Struct({
-  id: Schema14.String,
-  resolved: Schema14.optionalKey(Schema14.Struct({
+  capabilities: Schema15.Array(Schema15.Literals(LoopCapabilities2)),
+  secrets: Schema15.optionalKey(Schema15.Array(SecretName2)),
+  network: Schema15.optionalKey(AgentSandboxNetwork),
+  schedule: Schema15.optionalKey(Schema15.Struct({ rule: ScheduleRule, timezone: Schema15.String }))
+});
+var LoopDetail = Schema15.Struct({
+  id: Schema15.String,
+  resolved: Schema15.optionalKey(Schema15.Struct({
     ...ProgramLoop.fields,
     agents: LoopManifest.fields.agents,
     when: LoopManifest.fields.when,
-    schedule: Schema14.optionalKey(Schema14.Struct({
+    schedule: Schema15.optionalKey(Schema15.Struct({
       rule: ScheduleRule,
-      timezone: Schema14.String,
-      on: Schema14.Boolean,
-      nextRunAt: Schema14.optionalKey(Schema14.String)
+      timezone: Schema15.String,
+      on: Schema15.Boolean,
+      nextRunAt: Schema15.optionalKey(Schema15.String)
     }))
   }))
 });
-var AgentDeclaration = Schema14.Struct({
-  extends: Schema14.optionalKey(Schema14.String),
-  instructions: Schema14.optionalKey(Schema14.String),
-  harness: Schema14.optionalKey(Schema14.String),
-  model: Schema14.optionalKey(Schema14.String),
-  effort: Schema14.optionalKey(Schema14.Literals(AgentEfforts)),
-  fallbacks: Schema14.optionalKey(Schema14.Array(AgentFallback)),
-  tools: Schema14.optionalKey(Schema14.Array(Schema14.Literals(AgentCapabilities))),
-  skills: Schema14.optionalKey(Schema14.Array(Schema14.String.check(Schema14.isMinLength(1)))),
-  network: Schema14.optionalKey(Schema14.Union([Schema14.Struct({ hosts: Schema14.Array(Schema14.String) }), Schema14.Literal("open")])),
-  sandbox: Schema14.optionalKey(Schema14.Literal("docker"))
+var AgentDeclaration = Schema15.Struct({
+  extends: Schema15.optionalKey(Schema15.String),
+  instructions: Schema15.optionalKey(Schema15.String),
+  harness: Schema15.optionalKey(Schema15.String),
+  model: Schema15.optionalKey(Schema15.String),
+  effort: Schema15.optionalKey(Schema15.Literals(AgentEfforts)),
+  fallbacks: Schema15.optionalKey(Schema15.Array(AgentFallback)),
+  tools: Schema15.optionalKey(Schema15.Array(Schema15.Literals(AgentCapabilities))),
+  skills: Schema15.optionalKey(Schema15.Array(Schema15.String.check(Schema15.isMinLength(1)))),
+  network: Schema15.optionalKey(Schema15.Union([Schema15.Struct({ hosts: Schema15.Array(Schema15.String) }), Schema15.Literal("open")])),
+  sandbox: Schema15.optionalKey(Schema15.Literal("docker"))
 });
 var scheduleFields = {
-  name: Schema14.String.check(Schema14.isMinLength(1)),
-  loop: Schema14.String,
-  team: Schema14.optionalKey(Schema14.String),
-  input: Schema14.optionalKey(JsonObject2),
-  timezone: Schema14.String,
-  misfire: Schema14.optionalKey(Schema14.Literals(ScheduleMisfirePolicies)),
-  overlap: Schema14.optionalKey(Schema14.Literals(ScheduleOverlapPolicies))
+  name: Schema15.String.check(Schema15.isMinLength(1)),
+  loop: Schema15.String,
+  team: Schema15.optionalKey(Schema15.String),
+  input: Schema15.optionalKey(JsonObject2),
+  timezone: Schema15.String,
+  misfire: Schema15.optionalKey(Schema15.Literals(ScheduleMisfirePolicies)),
+  overlap: Schema15.optionalKey(Schema15.Literals(ScheduleOverlapPolicies))
 };
-var ScheduleDeclaration = Schema14.Union([
-  Schema14.Struct({
+var ScheduleDeclaration = Schema15.Union([
+  Schema15.Struct({
     ...scheduleFields,
-    cron: Schema14.String.check(Schema14.makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
+    cron: Schema15.String.check(Schema15.makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
   }),
-  Schema14.Struct({
+  Schema15.Struct({
     ...scheduleFields,
-    rule: Schema14.declare((value) => isScheduleRule(value), {
+    rule: Schema15.declare((value) => isScheduleRule(value), {
       expected: "a Schedule rule: frequency daily or weekly, hour, minute, and optionally second and daysOfWeek"
     })
   })
 ]);
-var CarriedKit = Schema14.Struct({
+var CarriedKit = Schema15.Struct({
   name: KitName,
-  version: Schema14.String.check(Schema14.isMinLength(1)),
+  version: Schema15.String.check(Schema15.isMinLength(1)),
   setup: KitDigest,
-  loops: Schema14.Array(Schema14.String),
-  agents: Schema14.Array(Schema14.String)
+  loops: Schema15.Array(Schema15.String),
+  agents: Schema15.Array(Schema15.String)
 });
-var KitDeclarations = Schema14.Struct({
-  loops: Schema14.Array(LoopManifest),
-  agents: Schema14.Record(Schema14.String, AgentDeclaration),
-  schedules: Schema14.optionalKey(Schema14.Record(Schema14.String, ScheduleDeclaration)),
-  carried: Schema14.optionalKey(Schema14.Array(CarriedKit))
+var KitDeclarations = Schema15.Struct({
+  loops: Schema15.Array(LoopManifest),
+  agents: Schema15.Record(Schema15.String, AgentDeclaration),
+  schedules: Schema15.optionalKey(Schema15.Record(Schema15.String, ScheduleDeclaration)),
+  carried: Schema15.optionalKey(Schema15.Array(CarriedKit))
 });
-var sameLoop = Schema14.toEquivalence(LoopManifest);
-var sameAgent = Schema14.toEquivalence(AgentDeclaration);
+var sameLoop = Schema15.toEquivalence(LoopManifest);
+var sameAgent = Schema15.toEquivalence(AgentDeclaration);
 
 // packages/sdk/src/loop/define.ts
 import * as Effect2 from "effect/Effect";
-import * as Schema15 from "effect/Schema";
-var LoopOutcome2 = Schema15.Literals([
+import * as Schema16 from "effect/Schema";
+var LoopOutcome2 = Schema16.Literals([
   "feature",
   "bug",
   "refactor",
@@ -2656,17 +2744,17 @@ var capabilitiesOf2 = (loop) => {
 };
 var defineLoop2 = (definition) => definition;
 
-class ManifestInvalid2 extends Schema15.TaggedError()("ManifestInvalid", {
-  loop: Schema15.String,
-  message: Schema15.String
+class ManifestInvalid2 extends Schema16.TaggedError()("ManifestInvalid", {
+  loop: Schema16.String,
+  message: Schema16.String
 }) {
 }
 var jsonSchemaOf2 = (loop, schema) => Effect2.try({
-  try: () => Schema15.toJsonSchemaDocument(schema),
+  try: () => Schema16.toJsonSchemaDocument(schema),
   catch: (error) => new ManifestInvalid2({ loop, message: `Schema has no JSON Schema: ${String(error)}` })
-}).pipe(Effect2.flatMap((document) => Schema15.decodeUnknownEffect(JsonObjectSchema)({ ...document.schema, $defs: document.definitions }).pipe(Effect2.mapError((error) => new ManifestInvalid2({ loop, message: error.message })))));
-var JsonObjectSchema = Schema15.Record(Schema15.String, Schema15.Json);
-var declarationsAreData = (definition) => Schema15.decodeEffect(JsonObjectSchema)({
+}).pipe(Effect2.flatMap((document) => Schema16.decodeUnknownEffect(JsonObjectSchema)({ ...document.schema, $defs: document.definitions }).pipe(Effect2.mapError((error) => new ManifestInvalid2({ loop, message: error.message })))));
+var JsonObjectSchema = Schema16.Record(Schema16.String, Schema16.Json);
+var declarationsAreData = (definition) => Schema16.decodeEffect(JsonObjectSchema)({
   agents: definition.agents,
   when: definition.when ?? [],
   offers: definition.offers ?? [],
@@ -2674,7 +2762,7 @@ var declarationsAreData = (definition) => Schema15.decodeEffect(JsonObjectSchema
 }).pipe(Effect2.mapError((error) => new ManifestInvalid2({ loop: definition.id, message: `Declarations must be data: ${error.message}` })));
 var loopManifest2 = (definition) => Effect2.gen(function* () {
   yield* declarationsAreData(definition);
-  if (definition.version !== undefined && !Schema15.is(LoopVersion)(definition.version))
+  if (definition.version !== undefined && !Schema16.is(LoopVersion)(definition.version))
     return yield* new ManifestInvalid2({
       loop: definition.id,
       message: `version "${String(definition.version)}" is not semver, such as 2.0.0`
@@ -2702,7 +2790,7 @@ import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect3 from "effect/Effect";
 import * as Exit2 from "effect/Exit";
-import * as Schema17 from "effect/Schema";
+import * as Schema18 from "effect/Schema";
 import { Activity, DurableDeferred } from "effect/workflow";
 
 // packages/core/src/question-recommendation.ts
@@ -2739,25 +2827,25 @@ var questionAdvice = (question) => ({
 });
 
 // packages/sdk/src/loop/evidence.ts
-import * as Schema16 from "effect/Schema";
-var EvidenceCheck2 = Schema16.Struct({
-  name: Schema16.String,
-  command: Schema16.String,
-  status: Schema16.Literals(["passed", "failed"]),
-  preExisting: Schema16.Boolean,
-  durationMs: Schema16.Finite,
-  evidenceId: Schema16.String,
-  outputTail: Schema16.optionalKey(Schema16.String),
-  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,
-  tree: Schema16.String,
-  passed: Schema16.Boolean,
-  unchanged: Schema16.optionalKey(Schema16.Boolean),
-  checks: Schema16.Array(EvidenceCheck2)
+import * as Schema17 from "effect/Schema";
+var EvidenceCheck2 = Schema17.Struct({
+  name: Schema17.String,
+  command: Schema17.String,
+  status: Schema17.Literals(["passed", "failed"]),
+  preExisting: Schema17.Boolean,
+  durationMs: Schema17.Finite,
+  evidenceId: Schema17.String,
+  outputTail: Schema17.optionalKey(Schema17.String),
+  suggested: Schema17.optionalKey(Schema17.Boolean),
+  skippedSinceBaseline: Schema17.optionalKey(Schema17.Array(Schema17.String)),
+  newNotRun: Schema17.optionalKey(Schema17.Array(Schema17.String))
+});
+var VerifyResult2 = Schema17.Struct({
+  revision: Schema17.String,
+  tree: Schema17.String,
+  passed: Schema17.Boolean,
+  unchanged: Schema17.optionalKey(Schema17.Boolean),
+  checks: Schema17.Array(EvidenceCheck2)
 });
 var OutcomeTable2 = {
   feature: "Approved verifications pass on the head tree, and review says the scope was met",
@@ -2853,82 +2941,82 @@ var outcomeGate = (input) => {
 };
 
 // packages/sdk/src/loop/steps.ts
-class StepFailed2 extends Schema17.TaggedError()("StepFailed", {
-  step: Schema17.String,
-  reason: Schema17.String
+class StepFailed2 extends Schema18.TaggedError()("StepFailed", {
+  step: Schema18.String,
+  reason: Schema18.String
 }) {
   get message() {
     return `Step "${this.step}" failed: ${this.reason}`;
   }
 }
 
-class OutputInvalid2 extends Schema17.TaggedError()("OutputInvalid", {
-  step: Schema17.String,
-  message: Schema17.String
+class OutputInvalid2 extends Schema18.TaggedError()("OutputInvalid", {
+  step: Schema18.String,
+  message: Schema18.String
 }) {
 }
 
-class QuestionRefused2 extends Schema17.TaggedError()("QuestionRefused", {
-  step: Schema17.String,
-  answer: Schema17.String,
-  options: Schema17.Array(Schema17.String)
+class QuestionRefused2 extends Schema18.TaggedError()("QuestionRefused", {
+  step: Schema18.String,
+  answer: Schema18.String,
+  options: Schema18.Array(Schema18.String)
 }) {
 }
 
-class WaitTimedOut2 extends Schema17.TaggedError()("WaitTimedOut", {
-  step: Schema17.String,
-  event: Schema17.String
+class WaitTimedOut2 extends Schema18.TaggedError()("WaitTimedOut", {
+  step: Schema18.String,
+  event: Schema18.String
 }) {
 }
 
-class ChangeRequestClosed2 extends Schema17.TaggedError()("ChangeRequestClosed", {
-  step: Schema17.String,
-  merged: Schema17.Boolean
+class ChangeRequestClosed2 extends Schema18.TaggedError()("ChangeRequestClosed", {
+  step: Schema18.String,
+  merged: Schema18.Boolean
 }) {
 }
 
-class ChildFailed2 extends Schema17.TaggedError()("ChildFailed", {
-  step: Schema17.String,
-  loop: Schema17.String,
-  reason: Schema17.String
+class ChildFailed2 extends Schema18.TaggedError()("ChildFailed", {
+  step: Schema18.String,
+  loop: Schema18.String,
+  reason: Schema18.String
 }) {
   get message() {
     return `Child Run of "${this.loop}" for Step "${this.step}" failed: ${this.reason}`;
   }
 }
 
-class CapabilityDenied2 extends Schema17.TaggedError()("CapabilityDenied", {
-  step: Schema17.String,
-  capability: Schema17.Literals(LoopCapabilities2),
-  secret: Schema17.optionalKey(Schema17.String)
+class CapabilityDenied2 extends Schema18.TaggedError()("CapabilityDenied", {
+  step: Schema18.String,
+  capability: Schema18.Literals(LoopCapabilities2),
+  secret: Schema18.optionalKey(Schema18.String)
 }) {
   get message() {
     return this.secret === undefined ? `Step "${this.step}" needs the "${this.capability}" capability, which this Run was not granted` : `Step "${this.step}" names the Secret "${this.secret}", which its Loop does not declare`;
   }
 }
 
-class DuplicateStep2 extends Schema17.TaggedError()("DuplicateStep", {
-  step: Schema17.String
+class DuplicateStep2 extends Schema18.TaggedError()("DuplicateStep", {
+  step: Schema18.String
 }) {
 }
 
-class InputInvalid2 extends Schema17.TaggedError()("InputInvalid", {
-  loop: Schema17.String,
-  message: Schema17.String
+class InputInvalid2 extends Schema18.TaggedError()("InputInvalid", {
+  loop: Schema18.String,
+  message: Schema18.String
 }) {
 }
-var LoopEvent2 = Schema17.Struct({ type: Schema17.String, payload: Schema17.Record(Schema17.String, Schema17.Json) });
+var LoopEvent2 = Schema18.Struct({ type: Schema18.String, payload: Schema18.Record(Schema18.String, Schema18.Json) });
 
 class LoopRun2 extends Context.Service()("@kitman-sh/sdk/loop/LoopRun") {
 }
 
 class LoopHost2 extends Context.Service()("@kitman-sh/sdk/loop/LoopHost") {
 }
-var agentDeferredNamed2 = (deferredName) => DurableDeferred.make(deferredName, { success: Schema17.Json, error: StepFailed2 });
+var agentDeferredNamed2 = (deferredName) => DurableDeferred.make(deferredName, { success: Schema18.Json, error: StepFailed2 });
 var agentWorkDeferred2 = (step) => agentDeferredNamed2(`agent_work/${step}`);
 var syncDeferred2 = (step) => agentDeferredNamed2(`sync/${step}`);
-var answerDeferred2 = (step) => DurableDeferred.make(`ask/${step}`, { success: Schema17.String, error: StepFailed2 });
-var childDeferred2 = (step) => DurableDeferred.make(`call/${step}`, { success: Schema17.Json, error: ChildFailed2 });
+var answerDeferred2 = (step) => DurableDeferred.make(`ask/${step}`, { success: Schema18.String, error: StepFailed2 });
+var childDeferred2 = (step) => DurableDeferred.make(`call/${step}`, { success: Schema18.Json, error: ChildFailed2 });
 var eventDeferred2 = (step) => DurableDeferred.make(`wait_for/${step}`, { success: LoopEvent2, error: WaitTimedOut2 });
 var verifyDeferred2 = (step) => DurableDeferred.make(`verify/${step}`, { success: VerifyResult2, error: StepFailed2 });
 var recordStep = (name, kind, exit) => {
@@ -2958,7 +3046,7 @@ var launch2 = (deferred, start) => Activity.make({
     return yield* start(yield* LoopHost2, yield* DurableDeferred.token(deferred));
   })
 });
-var toJson = (step, schema, value) => Schema17.encodeUnknownEffect(Schema17.toCodecJson(schema))(value).pipe(Effect3.flatMap(Schema17.decodeUnknownEffect(Schema17.Json)), Effect3.mapError((error) => new StepFailed2({ step, reason: error.message })));
+var toJson = (step, schema, value) => Schema18.encodeUnknownEffect(Schema18.toCodecJson(schema))(value).pipe(Effect3.flatMap(Schema18.decodeUnknownEffect(Schema18.Json)), Effect3.mapError((error) => new StepFailed2({ step, reason: error.message })));
 var agentWork2 = (name, options) => agentWorkAs2(agentWorkDeferred2, name, options);
 var agentWorkAs2 = (deferredOf, name, options) => takeStep2(name, "agent_work", "agent_work", Effect3.gen(function* () {
   const run = yield* LoopRun2;
@@ -2984,7 +3072,7 @@ var agentWorkAs2 = (deferredOf, name, options) => takeStep2(name, "agent_work",
     token
   }));
   const submitted = yield* DurableDeferred.await(deferred);
-  return yield* Schema17.decodeEffect(Schema17.toCodecJson(options.output))(submitted).pipe(Effect3.mapError((error) => new OutputInvalid2({ step: name, message: error.message })));
+  return yield* Schema18.decodeEffect(Schema18.toCodecJson(options.output))(submitted).pipe(Effect3.mapError((error) => new OutputInvalid2({ step: name, message: error.message })));
 }));
 var agentWorkOnce2 = (name, options) => agentWork2(name, options).pipe(Effect3.catchTag("OutputInvalid", (invalid) => agentWork2(`${name}:again`, {
   ...options,
@@ -3046,7 +3134,7 @@ var call2 = (name, loop, input, options) => takeStep2(name, "call", "call", Effe
     token
   }));
   const result = yield* DurableDeferred.await(deferred);
-  return yield* Schema17.decodeEffect(Schema17.toCodecJson(loop.output))(result).pipe(Effect3.mapError((error) => new ChildFailed2({ step: name, loop: loop.id, reason: error.message })));
+  return yield* Schema18.decodeEffect(Schema18.toCodecJson(loop.output))(result).pipe(Effect3.mapError((error) => new ChildFailed2({ step: name, loop: loop.id, reason: error.message })));
 }));
 var waitFor2 = (name, wait) => takeStep2(name, "wait_for", undefined, Effect3.gen(function* () {
   const deferred = eventDeferred2(name);
@@ -3101,21 +3189,21 @@ var suggestVerification2 = (name, verification) => takeStep2(name, "ask", "ask",
 // packages/sdk/src/loop/activities.ts
 import * as Context2 from "effect/Context";
 import * as Effect5 from "effect/Effect";
-import * as Schema19 from "effect/Schema";
+import * as Schema20 from "effect/Schema";
 import * as SchemaTransformation from "effect/SchemaTransformation";
 import { Activity as Activity2 } from "effect/workflow";
 
 // packages/sdk/src/loop/plan.ts
 import * as Effect4 from "effect/Effect";
-import * as Schema18 from "effect/Schema";
-var PlanTicket2 = Schema18.Struct({
-  key: Schema18.String,
-  title: Schema18.String,
-  body: Schema18.String,
-  acceptanceCriteria: Schema18.Array(Schema18.String),
-  repoBindingId: Schema18.optional(Schema18.String),
-  blockedBy: Schema18.Array(Schema18.String),
-  outcome: Schema18.optional(LoopOutcome2)
+import * as Schema19 from "effect/Schema";
+var PlanTicket2 = Schema19.Struct({
+  key: Schema19.String,
+  title: Schema19.String,
+  body: Schema19.String,
+  acceptanceCriteria: Schema19.Array(Schema19.String),
+  repoBindingId: Schema19.optional(Schema19.String),
+  blockedBy: Schema19.Array(Schema19.String),
+  outcome: Schema19.optional(LoopOutcome2)
 });
 var cycleMessage = (keys) => `These tickets block each other in a cycle, so none can start: ${keys.join(", ")}`;
 var ticketsProblem = (tickets) => {
@@ -3132,10 +3220,10 @@ var ticketsProblem = (tickets) => {
   const { blocked } = wavesOf(tickets);
   return blocked.length === 0 ? undefined : cycleMessage(blocked);
 };
-var PlanTickets2 = Schema18.Array(PlanTicket2).check(Schema18.makeFilter((tickets) => ticketsProblem(tickets) ?? true));
+var PlanTickets2 = Schema19.Array(PlanTicket2).check(Schema19.makeFilter((tickets) => ticketsProblem(tickets) ?? true));
 
-class BlockingCycle2 extends Schema18.TaggedError()("BlockingCycle", {
-  tickets: Schema18.Array(Schema18.String)
+class BlockingCycle2 extends Schema19.TaggedError()("BlockingCycle", {
+  tickets: Schema19.Array(Schema19.String)
 }) {
   get message() {
     return cycleMessage(this.tickets);
@@ -3163,235 +3251,235 @@ var planWaves2 = (tickets) => Effect4.suspend(() => {
 });
 
 // packages/sdk/src/loop/activities.ts
-var ChangeRequestRequest2 = Schema19.Struct({
-  title: Schema19.String,
-  body: Schema19.String,
-  integration: Schema19.optional(Schema19.String)
+var ChangeRequestRequest2 = Schema20.Struct({
+  title: Schema20.String,
+  body: Schema20.String,
+  integration: Schema20.optional(Schema20.String)
 });
-var ChangeRequestResult2 = Schema19.Struct({ id: Schema19.String, number: Schema19.String, url: Schema19.String });
+var ChangeRequestResult2 = Schema20.Struct({ id: Schema20.String, number: Schema20.String, url: Schema20.String });
 var WriteBackMilestones2 = ["started", "change_request_opened", "merged", "failed"];
-var WriteBackRequest2 = Schema19.Struct({
-  milestone: Schema19.optional(Schema19.Literals(WriteBackMilestones2)),
-  changeRequestUrl: Schema19.optional(Schema19.String)
+var WriteBackRequest2 = Schema20.Struct({
+  milestone: Schema20.optional(Schema20.Literals(WriteBackMilestones2)),
+  changeRequestUrl: Schema20.optional(Schema20.String)
 });
-var RunFile2 = Schema19.Struct({ runFile: Schema19.String }).pipe(Schema19.decodeTo(Schema19.Struct({ id: Schema19.String }), SchemaTransformation.transform({
+var RunFile2 = Schema20.Struct({ runFile: Schema20.String }).pipe(Schema20.decodeTo(Schema20.Struct({ id: Schema20.String }), SchemaTransformation.transform({
   decode: ({ runFile }) => ({ id: runFile }),
   encode: ({ id }) => ({ runFile: id })
 })));
-var FileRequest2 = Schema19.Struct({ path: Schema19.String, caption: Schema19.optional(Schema19.String) });
-var ArtifactRequest2 = Schema19.Struct({
-  kind: Schema19.String,
-  title: Schema19.String,
-  text: Schema19.String,
-  data: Schema19.optional(Schema19.Json),
-  files: Schema19.optional(Schema19.Array(RunFile2))
-});
-var ArtifactResult2 = Schema19.Struct({ artifactId: Schema19.String });
-var NoteRequest2 = Schema19.Struct({
-  text: Schema19.String,
-  artifactId: Schema19.optional(Schema19.String),
-  kind: Schema19.optional(Schema19.Literals(["note", "blocker"]))
-});
-var CreateTasksRequest2 = Schema19.Struct({
-  tickets: Schema19.Array(PlanTicket2),
-  projectId: Schema19.optionalKey(Schema19.String)
-});
-var CreateTasksResult2 = Schema19.Struct({
-  tasks: Schema19.Array(Schema19.Struct({ key: Schema19.String, taskId: Schema19.String }))
-});
-var AlertTaskRequest2 = Schema19.Struct({
-  fingerprint: Schema19.String.check(Schema19.isMinLength(1), Schema19.isMaxLength(400)),
-  title: Schema19.String,
-  windowHours: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(0), Schema19.isLessThanOrEqualTo(720)),
-  resolved: Schema19.optionalKey(Schema19.Boolean),
-  priority: Schema19.optionalKey(Schema19.Literals(["urgent", "high", "medium", "low"]))
-});
-var AlertTaskResult2 = Schema19.Struct({
-  taskId: Schema19.optionalKey(Schema19.String),
-  created: Schema19.Boolean,
-  resolved: Schema19.optionalKey(Schema19.Boolean),
-  joined: Schema19.optionalKey(Schema19.Struct({ kind: Schema19.Literals(["run", "recent"]), runId: Schema19.String }))
-});
-var IntegrationBranchRequest2 = Schema19.Struct({ repoBindingId: Schema19.optional(Schema19.String) });
-var IntegrationBranch2 = Schema19.Struct({
-  repoBindingId: Schema19.String,
-  branch: Schema19.String,
-  revision: Schema19.String
-});
-var MergeChangeRequestRequest2 = Schema19.Struct({
-  changeRequestId: Schema19.String,
-  head: Schema19.optionalKey(Schema19.String)
-});
-var MergeResult2 = Schema19.Union([
-  Schema19.Struct({ status: Schema19.Literal("merged"), revision: Schema19.String }),
-  Schema19.Struct({ status: Schema19.Literal("conflict") }),
-  Schema19.Struct({ status: Schema19.Literal("moved"), head: Schema19.String })
+var FileRequest2 = Schema20.Struct({ path: Schema20.String, caption: Schema20.optional(Schema20.String) });
+var ArtifactRequest2 = Schema20.Struct({
+  kind: Schema20.String,
+  title: Schema20.String,
+  text: Schema20.String,
+  data: Schema20.optional(Schema20.Json),
+  files: Schema20.optional(Schema20.Array(RunFile2))
+});
+var ArtifactResult2 = Schema20.Struct({ artifactId: Schema20.String });
+var NoteRequest2 = Schema20.Struct({
+  text: Schema20.String,
+  artifactId: Schema20.optional(Schema20.String),
+  kind: Schema20.optional(Schema20.Literals(["note", "blocker"]))
+});
+var CreateTasksRequest2 = Schema20.Struct({
+  tickets: Schema20.Array(PlanTicket2),
+  projectId: Schema20.optionalKey(Schema20.String)
+});
+var CreateTasksResult2 = Schema20.Struct({
+  tasks: Schema20.Array(Schema20.Struct({ key: Schema20.String, taskId: Schema20.String }))
+});
+var AlertTaskRequest2 = Schema20.Struct({
+  fingerprint: Schema20.String.check(Schema20.isMinLength(1), Schema20.isMaxLength(400)),
+  title: Schema20.String,
+  windowHours: Schema20.Int.check(Schema20.isGreaterThanOrEqualTo(0), Schema20.isLessThanOrEqualTo(720)),
+  resolved: Schema20.optionalKey(Schema20.Boolean),
+  priority: Schema20.optionalKey(Schema20.Literals(["urgent", "high", "medium", "low"]))
+});
+var AlertTaskResult2 = Schema20.Struct({
+  taskId: Schema20.optionalKey(Schema20.String),
+  created: Schema20.Boolean,
+  resolved: Schema20.optionalKey(Schema20.Boolean),
+  joined: Schema20.optionalKey(Schema20.Struct({ kind: Schema20.Literals(["run", "recent"]), runId: Schema20.String }))
+});
+var IntegrationBranchRequest2 = Schema20.Struct({ repoBindingId: Schema20.optional(Schema20.String) });
+var IntegrationBranch2 = Schema20.Struct({
+  repoBindingId: Schema20.String,
+  branch: Schema20.String,
+  revision: Schema20.String
+});
+var MergeChangeRequestRequest2 = Schema20.Struct({
+  changeRequestId: Schema20.String,
+  head: Schema20.optionalKey(Schema20.String)
+});
+var MergeResult2 = Schema20.Union([
+  Schema20.Struct({ status: Schema20.Literal("merged"), revision: Schema20.String }),
+  Schema20.Struct({ status: Schema20.Literal("conflict") }),
+  Schema20.Struct({ status: Schema20.Literal("moved"), head: Schema20.String })
 ]);
-var ApproveChangeRequestRequest2 = Schema19.Struct({
-  changeRequestId: Schema19.String,
-  head: Schema19.String,
-  summary: Schema19.String,
-  review: Schema19.optionalKey(Schema19.String),
-  carries: Schema19.optionalKey(Schema19.String)
-});
-var ApproveChangeRequestResult2 = Schema19.Union([
-  Schema19.Struct({ approved: Schema19.Literal(true), reviewId: Schema19.String }),
-  Schema19.Struct({ approved: Schema19.Literal(false), reason: Schema19.String })
+var ApproveChangeRequestRequest2 = Schema20.Struct({
+  changeRequestId: Schema20.String,
+  head: Schema20.String,
+  summary: Schema20.String,
+  review: Schema20.optionalKey(Schema20.String),
+  carries: Schema20.optionalKey(Schema20.String)
+});
+var ApproveChangeRequestResult2 = Schema20.Union([
+  Schema20.Struct({ approved: Schema20.Literal(true), reviewId: Schema20.String }),
+  Schema20.Struct({ approved: Schema20.Literal(false), reason: Schema20.String })
 ]);
-var CloseChangeRequestRequest2 = Schema19.Struct({
-  number: Schema19.String,
-  head: Schema19.String,
-  note: Schema19.String
-});
-var CloseChangeRequestResult2 = Schema19.Struct({
-  closed: Schema19.Boolean,
-  head: Schema19.optionalKey(Schema19.String)
-});
-var RerunPipelineRequest2 = Schema19.Union([
-  Schema19.Struct({ changeRequestId: Schema19.String }),
-  Schema19.Struct({ ref: Schema19.String, all: Schema19.optionalKey(Schema19.Boolean) })
+var CloseChangeRequestRequest2 = Schema20.Struct({
+  number: Schema20.String,
+  head: Schema20.String,
+  note: Schema20.String
+});
+var CloseChangeRequestResult2 = Schema20.Struct({
+  closed: Schema20.Boolean,
+  head: Schema20.optionalKey(Schema20.String)
+});
+var RerunPipelineRequest2 = Schema20.Union([
+  Schema20.Struct({ changeRequestId: Schema20.String }),
+  Schema20.Struct({ ref: Schema20.String, all: Schema20.optionalKey(Schema20.Boolean) })
 ]);
-var RerunPipelineResult2 = Schema19.Struct({ head: Schema19.String, pipelines: Schema19.Int });
-var ReportPipelineRequest2 = Schema19.Struct({ changeRequestId: Schema19.String, verification: Schema19.String });
-var ReportPipelineResult2 = Schema19.Struct({
-  head: Schema19.String,
-  status: Schema19.Literals(["success", "failed"])
-});
-var CommentRequest2 = Schema19.Struct({
-  changeRequestId: Schema19.String,
-  body: Schema19.String,
-  threadId: Schema19.optionalKey(Schema19.String),
-  summary: Schema19.optionalKey(Schema19.String),
-  anchors: Schema19.optionalKey(Schema19.Array(Schema19.Struct({
-    file: Schema19.String,
-    line: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(1)),
-    body: Schema19.String.check(Schema19.isMinLength(1))
+var RerunPipelineResult2 = Schema20.Struct({ head: Schema20.String, pipelines: Schema20.Int });
+var ReportPipelineRequest2 = Schema20.Struct({ changeRequestId: Schema20.String, verification: Schema20.String });
+var ReportPipelineResult2 = Schema20.Struct({
+  head: Schema20.String,
+  status: Schema20.Literals(["success", "failed"])
+});
+var CommentRequest2 = Schema20.Struct({
+  changeRequestId: Schema20.String,
+  body: Schema20.String,
+  threadId: Schema20.optionalKey(Schema20.String),
+  summary: Schema20.optionalKey(Schema20.String),
+  anchors: Schema20.optionalKey(Schema20.Array(Schema20.Struct({
+    file: Schema20.String,
+    line: Schema20.Int.check(Schema20.isGreaterThanOrEqualTo(1)),
+    body: Schema20.String.check(Schema20.isMinLength(1))
   })))
 });
-var ReleaseRequest2 = Schema19.Struct({
-  tag: Schema19.String,
-  revision: Schema19.optional(Schema19.String),
-  title: Schema19.String,
-  notes: Schema19.String
-});
-var ReleaseResult2 = Schema19.Struct({ tag: Schema19.String, revision: Schema19.String, url: Schema19.String });
-var ChangeRequestReadRequest2 = Schema19.Struct({ changeRequestId: Schema19.String });
-var PipelineJob2 = Schema19.Struct({
-  name: Schema19.String,
-  status: Schema19.Literals(["running", "success", "failed", "skipped"]),
-  url: Schema19.optional(Schema19.String),
-  logTail: Schema19.optional(Schema19.String)
-});
-var PipelineStatus2 = Schema19.Struct({
-  head: Schema19.String,
-  status: Schema19.Literals(["none", "running", "success", "failed", "canceled"]),
-  source: Schema19.Literals(["forge", "reported"]),
-  jobs: Schema19.Array(PipelineJob2),
-  readAt: Schema19.optionalKey(Schema19.String),
-  runnerChecks: Schema19.optionalKey(Schema19.Array(Schema19.String)),
-  approved: Schema19.optionalKey(Schema19.String),
-  repository: Schema19.optionalKey(Schema19.String),
-  conflicts: Schema19.optionalKey(Schema19.Boolean),
-  needsRebase: Schema19.optionalKey(Schema19.Boolean),
-  target: Schema19.optionalKey(Schema19.Struct({ branch: Schema19.String, head: Schema19.String, jobs: Schema19.Array(PipelineJob2) }))
-});
-var ReviewThread2 = Schema19.Struct({
-  id: Schema19.String,
-  path: Schema19.optional(Schema19.String),
-  line: Schema19.optional(Schema19.Int),
-  outdated: Schema19.optional(Schema19.Boolean),
-  comments: Schema19.Array(Schema19.Struct({ author: Schema19.optional(Schema19.String), body: Schema19.String }))
-});
-var ReviewThreads2 = Schema19.Struct({ threads: Schema19.Array(ReviewThread2) });
-var OpenChangeRequestsRequest2 = Schema19.Struct({ authors: Schema19.NonEmptyArray(Schema19.String) });
-var OpenChangeRequest2 = Schema19.Struct({
-  number: Schema19.String,
-  title: Schema19.String,
-  body: Schema19.String,
-  url: Schema19.String,
-  author: Schema19.String,
-  sourceBranch: Schema19.String,
-  head: Schema19.String
-});
-var OpenChangeRequests2 = Schema19.Struct({ changeRequests: Schema19.Array(OpenChangeRequest2) });
-var OwnChangeRequest2 = Schema19.Struct({
-  id: Schema19.String,
-  number: Schema19.String,
-  url: Schema19.String,
-  title: Schema19.String,
-  sourceBranch: Schema19.String,
-  body: Schema19.String
-});
-var OwnChangeRequests2 = Schema19.Struct({ changeRequests: Schema19.Array(OwnChangeRequest2) });
-var TranscriptPoint2 = Schema19.Struct({
-  runId: Schema19.String,
-  stepAttemptId: Schema19.String,
-  sequence: Schema19.Int
-});
-var TranscriptsRequest2 = Schema19.Struct({
-  days: Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(1), Schema19.isLessThanOrEqualTo(31))
-});
-var TranscriptsResult2 = Schema19.Struct({
-  runs: Schema19.Array(Schema19.Struct({
-    runId: Schema19.String,
-    loopId: Schema19.String,
-    status: Schema19.optional(Schema19.Literals(["completed", "failed", "canceled", "expired"])),
-    teamId: Schema19.optional(Schema19.String),
-    failure: Schema19.optional(Schema19.String),
-    retried: Schema19.optional(Schema19.Boolean),
-    entries: Schema19.Array(Schema19.Struct({ stepAttemptId: Schema19.String, sequence: Schema19.Int, kind: Schema19.String, text: Schema19.String }))
+var ReleaseRequest2 = Schema20.Struct({
+  tag: Schema20.String,
+  revision: Schema20.optional(Schema20.String),
+  title: Schema20.String,
+  notes: Schema20.String
+});
+var ReleaseResult2 = Schema20.Struct({ tag: Schema20.String, revision: Schema20.String, url: Schema20.String });
+var ChangeRequestReadRequest2 = Schema20.Struct({ changeRequestId: Schema20.String });
+var PipelineJob2 = Schema20.Struct({
+  name: Schema20.String,
+  status: Schema20.Literals(["running", "success", "failed", "skipped"]),
+  url: Schema20.optional(Schema20.String),
+  logTail: Schema20.optional(Schema20.String)
+});
+var PipelineStatus2 = Schema20.Struct({
+  head: Schema20.String,
+  status: Schema20.Literals(["none", "running", "success", "failed", "canceled"]),
+  source: Schema20.Literals(["forge", "reported"]),
+  jobs: Schema20.Array(PipelineJob2),
+  readAt: Schema20.optionalKey(Schema20.String),
+  runnerChecks: Schema20.optionalKey(Schema20.Array(Schema20.String)),
+  approved: Schema20.optionalKey(Schema20.String),
+  repository: Schema20.optionalKey(Schema20.String),
+  conflicts: Schema20.optionalKey(Schema20.Boolean),
+  needsRebase: Schema20.optionalKey(Schema20.Boolean),
+  target: Schema20.optionalKey(Schema20.Struct({ branch: Schema20.String, head: Schema20.String, jobs: Schema20.Array(PipelineJob2) }))
+});
+var ReviewThread2 = Schema20.Struct({
+  id: Schema20.String,
+  path: Schema20.optional(Schema20.String),
+  line: Schema20.optional(Schema20.Int),
+  outdated: Schema20.optional(Schema20.Boolean),
+  comments: Schema20.Array(Schema20.Struct({ author: Schema20.optional(Schema20.String), body: Schema20.String }))
+});
+var ReviewThreads2 = Schema20.Struct({ threads: Schema20.Array(ReviewThread2) });
+var OpenChangeRequestsRequest2 = Schema20.Struct({ authors: Schema20.NonEmptyArray(Schema20.String) });
+var OpenChangeRequest2 = Schema20.Struct({
+  number: Schema20.String,
+  title: Schema20.String,
+  body: Schema20.String,
+  url: Schema20.String,
+  author: Schema20.String,
+  sourceBranch: Schema20.String,
+  head: Schema20.String
+});
+var OpenChangeRequests2 = Schema20.Struct({ changeRequests: Schema20.Array(OpenChangeRequest2) });
+var OwnChangeRequest2 = Schema20.Struct({
+  id: Schema20.String,
+  number: Schema20.String,
+  url: Schema20.String,
+  title: Schema20.String,
+  sourceBranch: Schema20.String,
+  body: Schema20.String
+});
+var OwnChangeRequests2 = Schema20.Struct({ changeRequests: Schema20.Array(OwnChangeRequest2) });
+var TranscriptPoint2 = Schema20.Struct({
+  runId: Schema20.String,
+  stepAttemptId: Schema20.String,
+  sequence: Schema20.Int
+});
+var TranscriptsRequest2 = Schema20.Struct({
+  days: Schema20.Int.check(Schema20.isGreaterThanOrEqualTo(1), Schema20.isLessThanOrEqualTo(31))
+});
+var TranscriptsResult2 = Schema20.Struct({
+  runs: Schema20.Array(Schema20.Struct({
+    runId: Schema20.String,
+    loopId: Schema20.String,
+    status: Schema20.optional(Schema20.Literals(["completed", "failed", "canceled", "expired"])),
+    teamId: Schema20.optional(Schema20.String),
+    failure: Schema20.optional(Schema20.String),
+    retried: Schema20.optional(Schema20.Boolean),
+    entries: Schema20.Array(Schema20.Struct({ stepAttemptId: Schema20.String, sequence: Schema20.Int, kind: Schema20.String, text: Schema20.String }))
   }))
 });
-var Citations = Schema19.NonEmptyArray(TranscriptPoint2);
-var ProposeRequest2 = Schema19.Union([
-  Schema19.Struct({
-    kind: Schema19.Literal("memory"),
-    teamId: Schema19.String,
-    content: Schema19.String,
+var Citations = Schema20.NonEmptyArray(TranscriptPoint2);
+var ProposeRequest2 = Schema20.Union([
+  Schema20.Struct({
+    kind: Schema20.Literal("memory"),
+    teamId: Schema20.String,
+    content: Schema20.String,
     citations: Citations
   }),
-  Schema19.Struct({
-    kind: Schema19.Literal("task"),
-    title: Schema19.String,
-    description: Schema19.String,
-    teamId: Schema19.optional(Schema19.String),
-    key: Schema19.optionalKey(Schema19.String.check(Schema19.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/), Schema19.isMaxLength(80))),
+  Schema20.Struct({
+    kind: Schema20.Literal("task"),
+    title: Schema20.String,
+    description: Schema20.String,
+    teamId: Schema20.optional(Schema20.String),
+    key: Schema20.optionalKey(Schema20.String.check(Schema20.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/), Schema20.isMaxLength(80))),
     citations: Citations
   })
 ]);
-var ProposeResult2 = Schema19.Struct({
-  kind: Schema19.Literals(["memory", "task"]),
-  id: Schema19.String,
-  matched: Schema19.optionalKey(Schema19.Boolean)
-});
-var Health = Schema19.Literals(["on_track", "at_risk", "off_track"]);
-var ProjectActivityRequest2 = Schema19.Struct({ projectId: Schema19.String });
-var ProjectActivityResult2 = Schema19.Struct({
-  project: Schema19.Struct({ id: Schema19.String, name: Schema19.String }),
-  health: Schema19.optional(Health),
-  since: Schema19.optional(Schema19.String),
-  runs: Schema19.Array(Schema19.Struct({
-    runId: Schema19.String,
-    loopId: Schema19.String,
-    status: Schema19.String,
-    taskKey: Schema19.optional(Schema19.String),
-    taskTitle: Schema19.optional(Schema19.String),
-    summary: Schema19.optional(Schema19.String),
-    entries: Schema19.Array(Schema19.Struct({ stepAttemptId: Schema19.String, sequence: Schema19.Int, kind: Schema19.String, text: Schema19.String }))
+var ProposeResult2 = Schema20.Struct({
+  kind: Schema20.Literals(["memory", "task"]),
+  id: Schema20.String,
+  matched: Schema20.optionalKey(Schema20.Boolean)
+});
+var Health = Schema20.Literals(["on_track", "at_risk", "off_track"]);
+var ProjectActivityRequest2 = Schema20.Struct({ projectId: Schema20.String });
+var ProjectActivityResult2 = Schema20.Struct({
+  project: Schema20.Struct({ id: Schema20.String, name: Schema20.String }),
+  health: Schema20.optional(Health),
+  since: Schema20.optional(Schema20.String),
+  runs: Schema20.Array(Schema20.Struct({
+    runId: Schema20.String,
+    loopId: Schema20.String,
+    status: Schema20.String,
+    taskKey: Schema20.optional(Schema20.String),
+    taskTitle: Schema20.optional(Schema20.String),
+    summary: Schema20.optional(Schema20.String),
+    entries: Schema20.Array(Schema20.Struct({ stepAttemptId: Schema20.String, sequence: Schema20.Int, kind: Schema20.String, text: Schema20.String }))
   })),
-  taskChanges: Schema19.Array(Schema19.Struct({ taskKey: Schema19.String, title: Schema19.String, change: Schema19.String, at: Schema19.String }))
+  taskChanges: Schema20.Array(Schema20.Struct({ taskKey: Schema20.String, title: Schema20.String, change: Schema20.String, at: Schema20.String }))
 });
-var DraftUpdateRequest2 = Schema19.Struct({
-  projectId: Schema19.String,
+var DraftUpdateRequest2 = Schema20.Struct({
+  projectId: Schema20.String,
   health: Health,
-  note: Schema19.String,
-  writtenFrom: Schema19.Struct({
-    runs: Schema19.Int,
-    taskChanges: Schema19.Int,
-    since: Schema19.optional(Schema19.String)
+  note: Schema20.String,
+  writtenFrom: Schema20.Struct({
+    runs: Schema20.Int,
+    taskChanges: Schema20.Int,
+    since: Schema20.optional(Schema20.String)
   })
 });
-var DraftUpdateResult2 = Schema19.Struct({ id: Schema19.String });
+var DraftUpdateResult2 = Schema20.Struct({ id: Schema20.String });
 
 class ChangeRequestActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/ChangeRequestActivity") {
 }
@@ -3444,7 +3532,7 @@ var hostActivity = (name, kind, capability, success, execute) => takeStep2(name,
 var changeRequest2 = (name, request) => hostActivity(name, "change_request", "change_request", ChangeRequestResult2, Effect5.gen(function* () {
   return yield* (yield* ChangeRequestActivity2).run(request, name);
 }));
-var writeBack2 = (name, request) => hostActivity(name, "write_back", "write_back", Schema19.Void, Effect5.gen(function* () {
+var writeBack2 = (name, request) => hostActivity(name, "write_back", "write_back", Schema20.Void, Effect5.gen(function* () {
   return yield* (yield* WriteBackActivity2).run(request, name);
 }));
 var artifact2 = (name, request) => hostActivity(name, "artifact", undefined, ArtifactResult2, Effect5.gen(function* () {
@@ -3453,10 +3541,10 @@ var artifact2 = (name, request) => hostActivity(name, "artifact", undefined, Art
 var file2 = (name, request) => hostActivity(name, "file", undefined, RunFile2, Effect5.gen(function* () {
   return yield* (yield* FileActivity2).run(request, name);
 }));
-var note2 = (name, request) => hostActivity(name, "note", undefined, Schema19.Void, Effect5.gen(function* () {
+var note2 = (name, request) => hostActivity(name, "note", undefined, Schema20.Void, Effect5.gen(function* () {
   return yield* (yield* NoteActivity2).run(request, name);
 }));
-var comment2 = (name, request) => hostActivity(name, "comment", "post_comment", Schema19.Void, Effect5.gen(function* () {
+var comment2 = (name, request) => hostActivity(name, "comment", "post_comment", Schema20.Void, Effect5.gen(function* () {
   return yield* (yield* CommentActivity2).run(request, name);
 }));
 var createTasks2 = (name, request) => hostActivity(name, "create_tasks", "create_tasks", CreateTasksResult2, Effect5.gen(function* () {
@@ -3529,45 +3617,45 @@ import * as Schema28 from "effect/Schema";
 import { DurableDeferred as DurableDeferred4, Workflow, WorkflowEngine } from "effect/workflow";
 
 // packages/core/src/resource-claim.ts
-import * as Schema20 from "effect/Schema";
-var ResourceName = Schema20.String.check(Schema20.isPattern(/^[a-z0-9][a-z0-9._:-]*$/u), Schema20.isMinLength(1), Schema20.isMaxLength(128));
-var ClaimHolder = Schema20.Struct({
-  runId: Schema20.optionalKey(Id),
-  loopId: Schema20.optionalKey(Schema20.String),
-  status: Schema20.optionalKey(RunStatus),
-  reason: Schema20.optionalKey(Schema20.String),
-  private: Schema20.optionalKey(Schema20.Literal(true)),
-  sameLoop: Schema20.Boolean
-});
-var ClaimResult2 = Schema20.Union([
-  Schema20.Struct({
-    status: Schema20.Literal("granted"),
+import * as Schema21 from "effect/Schema";
+var ResourceName = Schema21.String.check(Schema21.isPattern(/^[a-z0-9][a-z0-9._:-]*$/u), Schema21.isMinLength(1), Schema21.isMaxLength(128));
+var ClaimHolder = Schema21.Struct({
+  runId: Schema21.optionalKey(Id),
+  loopId: Schema21.optionalKey(Schema21.String),
+  status: Schema21.optionalKey(RunStatus),
+  reason: Schema21.optionalKey(Schema21.String),
+  private: Schema21.optionalKey(Schema21.Literal(true)),
+  sameLoop: Schema21.Boolean
+});
+var ClaimResult2 = Schema21.Union([
+  Schema21.Struct({
+    status: Schema21.Literal("granted"),
     resource: ResourceName,
-    takenOverFrom: Schema20.optionalKey(ClaimHolder)
+    takenOverFrom: Schema21.optionalKey(ClaimHolder)
   }),
-  Schema20.Struct({ status: Schema20.Literal("kept"), resource: ResourceName, holder: ClaimHolder })
+  Schema21.Struct({ status: Schema21.Literal("kept"), resource: ResourceName, holder: ClaimHolder })
 ]);
-var ResourceClaim = Schema20.Struct({
+var ResourceClaim = Schema21.Struct({
   resource: ResourceName,
   runId: Id,
-  loopId: Schema20.String,
+  loopId: Schema21.String,
   runStatus: RunStatus,
   claimedAt: Timestamp,
-  keptAt: Schema20.optionalKey(Timestamp),
-  keptReason: Schema20.optionalKey(Schema20.String),
-  waiting: Schema20.Array(Id)
+  keptAt: Schema21.optionalKey(Timestamp),
+  keptReason: Schema21.optionalKey(Schema21.String),
+  waiting: Schema21.Array(Id)
 });
-var ResourceClaimList = Schema20.Struct({ items: Schema20.Array(ResourceClaim) });
-var ClaimRelease = Schema20.Struct({
-  reason: Schema20.String.check(Schema20.isMinLength(1), Schema20.isMaxLength(500))
+var ResourceClaimList = Schema21.Struct({ items: Schema21.Array(ResourceClaim) });
+var ClaimRelease = Schema21.Struct({
+  reason: Schema21.String.check(Schema21.isMinLength(1), Schema21.isMaxLength(500))
 });
 
 // packages/sdk/src/loop/claims.ts
 import * as Effect6 from "effect/Effect";
-import * as Schema21 from "effect/Schema";
+import * as Schema22 from "effect/Schema";
 import { DurableDeferred as DurableDeferred2 } from "effect/workflow";
 var claimDeferred2 = (step) => DurableDeferred2.make(`claim/${step}`, { success: ClaimResult2, error: StepFailed2 });
-var letGoDeferred2 = (step) => DurableDeferred2.make(`let_go/${step}`, { success: Schema21.Null, error: StepFailed2 });
+var letGoDeferred2 = (step) => DurableDeferred2.make(`let_go/${step}`, { success: Schema22.Null, error: StepFailed2 });
 var claimOnce = (name, resource, action) => takeStep2(name, "claim", "claim", Effect6.gen(function* () {
   const deferred = claimDeferred2(name);
   yield* launch2(deferred, (host, token) => host.claimResource({ step: name, resource, action, token }));
@@ -3606,114 +3694,114 @@ import * as Schema26 from "effect/Schema";
 import * as Struct24 from "effect/Struct";
 
 // packages/core/src/repo-binding.ts
-import * as Schema22 from "effect/Schema";
+import * as Schema23 from "effect/Schema";
 var ForgeKinds = ["github", "gitlab", "forgejo", "gitea", "gitee", "bitbucket", "azure-devops"];
-var ForgeKind = Schema22.Literals(ForgeKinds);
+var ForgeKind = Schema23.Literals(ForgeKinds);
 var RepoBindingProviders = [...ForgeKinds, "generic_git"];
 var RepoBindingPathPrefixPattern = "^(?!/)(?!.*\\\\)(?!.*(?:^|/)\\.\\.?(?:/|$))(?!.*//)\\S+$";
-var RepoBindingProvider = Schema22.Literals(RepoBindingProviders);
-var RepoBindingStatus = Schema22.Union([Schema22.Literal("active"), Schema22.Literal("disabled")]);
-var RepoBindingCredentialProviderType = Schema22.Union([
-  Schema22.Literal("env"),
-  Schema22.Literal("file"),
-  Schema22.Literal("exec")
+var RepoBindingProvider = Schema23.Literals(RepoBindingProviders);
+var RepoBindingStatus = Schema23.Union([Schema23.Literal("active"), Schema23.Literal("disabled")]);
+var RepoBindingCredentialProviderType = Schema23.Union([
+  Schema23.Literal("env"),
+  Schema23.Literal("file"),
+  Schema23.Literal("exec")
 ]);
-var RepoBindingAccessMode = Schema22.Union([
-  Schema22.Literal("local_checkout"),
-  Schema22.Literal("managed_clone"),
-  Schema22.Literal("runner_secret_provider")
+var RepoBindingAccessMode = Schema23.Union([
+  Schema23.Literal("local_checkout"),
+  Schema23.Literal("managed_clone"),
+  Schema23.Literal("runner_secret_provider")
 ]);
-var RepoBindingCredentialRef = Schema22.Union([
-  Schema22.Struct({ kind: Schema22.Literal("none") }),
-  Schema22.Struct({ kind: Schema22.Literal("local_env"), envName: Schema22.String.check(Schema22.isMinLength(1)) }),
-  Schema22.Struct({
-    kind: Schema22.Literal("runner_secret"),
-    runnerSecretName: Schema22.String.check(Schema22.isMinLength(1)),
+var RepoBindingCredentialRef = Schema23.Union([
+  Schema23.Struct({ kind: Schema23.Literal("none") }),
+  Schema23.Struct({ kind: Schema23.Literal("local_env"), envName: Schema23.String.check(Schema23.isMinLength(1)) }),
+  Schema23.Struct({
+    kind: Schema23.Literal("runner_secret"),
+    runnerSecretName: Schema23.String.check(Schema23.isMinLength(1)),
     providerType: RepoBindingCredentialProviderType
   }),
-  Schema22.Struct({ kind: Schema22.Literal("ssh_agent") })
+  Schema23.Struct({ kind: Schema23.Literal("ssh_agent") })
 ]);
-var RepoBinding = Schema22.Struct({
+var RepoBinding = Schema23.Struct({
   id: Id,
   workspaceId: Id,
-  teamId: Schema22.optionalKey(Id),
+  teamId: Schema23.optionalKey(Id),
   provider: RepoBindingProvider,
-  host: Schema22.String.check(Schema22.isMinLength(1)),
-  owner: Schema22.String.check(Schema22.isMinLength(1)),
-  name: Schema22.String.check(Schema22.isMinLength(1)),
-  repositoryUrl: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1))),
-  pathPrefix: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1), Schema22.isPattern(new RegExp(RepoBindingPathPrefixPattern, "u")))),
-  defaultTargetBranch: Schema22.String.check(Schema22.isMinLength(1)),
-  expectedBranch: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1))),
-  expectedCommitSha: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1))),
-  credentialRefs: Schema22.Array(RepoBindingCredentialRef),
+  host: Schema23.String.check(Schema23.isMinLength(1)),
+  owner: Schema23.String.check(Schema23.isMinLength(1)),
+  name: Schema23.String.check(Schema23.isMinLength(1)),
+  repositoryUrl: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1))),
+  pathPrefix: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1), Schema23.isPattern(new RegExp(RepoBindingPathPrefixPattern, "u")))),
+  defaultTargetBranch: Schema23.String.check(Schema23.isMinLength(1)),
+  expectedBranch: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1))),
+  expectedCommitSha: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1))),
+  credentialRefs: Schema23.Array(RepoBindingCredentialRef),
   status: RepoBindingStatus,
-  webhook: Schema22.optionalKey(Schema22.Struct({
-    status: Schema22.Literals(["active", "missing", "unavailable"]),
-    message: Schema22.optionalKey(Schema22.String.check(Schema22.isMaxLength(240)))
+  webhook: Schema23.optionalKey(Schema23.Struct({
+    status: Schema23.Literals(["active", "missing", "unavailable"]),
+    message: Schema23.optionalKey(Schema23.String.check(Schema23.isMaxLength(240)))
   })),
   createdAt: Timestamp,
   updatedAt: Timestamp
 });
-var RepoBindingCreate = Schema22.Struct({
-  teamId: Schema22.optionalKey(Id),
+var RepoBindingCreate = Schema23.Struct({
+  teamId: Schema23.optionalKey(Id),
   provider: RepoBindingProvider,
-  host: Schema22.String.check(Schema22.isMinLength(1)),
-  owner: Schema22.String.check(Schema22.isMinLength(1)),
-  name: Schema22.String.check(Schema22.isMinLength(1)),
-  repositoryUrl: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1))),
-  pathPrefix: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1), Schema22.isPattern(new RegExp(RepoBindingPathPrefixPattern, "u")))),
-  defaultTargetBranch: Schema22.String.check(Schema22.isMinLength(1)),
-  expectedBranch: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1))),
-  expectedCommitSha: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1))),
-  credentialRefs: Schema22.optionalKey(Schema22.Array(RepoBindingCredentialRef))
-});
-var RepoBindingTargetOverride = Schema22.Struct({
-  targetBranch: Schema22.optionalKey(Schema22.String.check(Schema22.isMinLength(1)))
-});
-var RepoBindingList = Schema22.Struct({ items: Schema22.Array(RepoBinding) });
-var RunnerRepoBindingCapability = Schema22.Struct({
+  host: Schema23.String.check(Schema23.isMinLength(1)),
+  owner: Schema23.String.check(Schema23.isMinLength(1)),
+  name: Schema23.String.check(Schema23.isMinLength(1)),
+  repositoryUrl: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1))),
+  pathPrefix: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1), Schema23.isPattern(new RegExp(RepoBindingPathPrefixPattern, "u")))),
+  defaultTargetBranch: Schema23.String.check(Schema23.isMinLength(1)),
+  expectedBranch: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1))),
+  expectedCommitSha: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1))),
+  credentialRefs: Schema23.optionalKey(Schema23.Array(RepoBindingCredentialRef))
+});
+var RepoBindingTargetOverride = Schema23.Struct({
+  targetBranch: Schema23.optionalKey(Schema23.String.check(Schema23.isMinLength(1)))
+});
+var RepoBindingList = Schema23.Struct({ items: Schema23.Array(RepoBinding) });
+var RunnerRepoBindingCapability = Schema23.Struct({
   repoBindingId: Id,
   provider: RepoBindingProvider,
-  host: Schema22.String.check(Schema22.isMinLength(1)),
-  accessModes: Schema22.Array(RepoBindingAccessMode),
-  credentialProviderTypes: Schema22.Array(RepoBindingCredentialProviderType),
-  authenticated: Schema22.Boolean,
-  canPush: Schema22.optionalKey(Schema22.Boolean)
+  host: Schema23.String.check(Schema23.isMinLength(1)),
+  accessModes: Schema23.Array(RepoBindingAccessMode),
+  credentialProviderTypes: Schema23.Array(RepoBindingCredentialProviderType),
+  authenticated: Schema23.Boolean,
+  canPush: Schema23.optionalKey(Schema23.Boolean)
 });
 
 // packages/core/src/network-host.ts
-import * as Schema23 from "effect/Schema";
+import * as Schema24 from "effect/Schema";
 var label = "[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?";
 var port = "(?:[1-9][0-9]{0,3}|[1-5][0-9]{4}|6[0-4][0-9]{3}|65[0-4][0-9]{2}|655[0-2][0-9]|6553[0-5])";
-var NetworkHost = Schema23.String.check(Schema23.isMaxLength(260), Schema23.isPattern(new RegExp(`^(?:localhost|${label}(?:\\.${label})+|\\*\\.${label}\\.${label}(?:\\.${label})*)(?::${port})?$`, "u")));
-var NetworkHostScope = Schema23.Union([Schema23.Struct({ teamId: Id }), Schema23.Struct({ repoBindingId: Id })]);
-var NetworkHostSummary = Schema23.Struct({
+var NetworkHost = Schema24.String.check(Schema24.isMaxLength(260), Schema24.isPattern(new RegExp(`^(?:localhost|${label}(?:\\.${label})+|\\*\\.${label}\\.${label}(?:\\.${label})*)(?::${port})?$`, "u")));
+var NetworkHostScope = Schema24.Union([Schema24.Struct({ teamId: Id }), Schema24.Struct({ repoBindingId: Id })]);
+var NetworkHostSummary = Schema24.Struct({
   host: NetworkHost,
-  teamId: Schema23.optionalKey(Id),
-  repoBindingId: Schema23.optionalKey(Id),
+  teamId: Schema24.optionalKey(Id),
+  repoBindingId: Schema24.optionalKey(Id),
   addedByActorType: ActorType,
-  addedByActorId: Schema23.String,
+  addedByActorId: Schema24.String,
   addedAt: Timestamp
 });
-var NetworkHostList = Schema23.Struct({ items: Schema23.Array(NetworkHostSummary) });
-var NetworkHostQuery = Schema23.Struct({
-  teamId: Schema23.optionalKey(Id),
-  repoBindingId: Schema23.optionalKey(Id)
+var NetworkHostList = Schema24.Struct({ items: Schema24.Array(NetworkHostSummary) });
+var NetworkHostQuery = Schema24.Struct({
+  teamId: Schema24.optionalKey(Id),
+  repoBindingId: Schema24.optionalKey(Id)
 });
 
 // packages/core/src/test-report.ts
-import * as Schema24 from "effect/Schema";
+import * as Schema25 from "effect/Schema";
 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 TestId = Schema25.String.check(Schema25.isMinLength(1), Schema25.isMaxLength(1000));
+var CheckTests = Schema25.Struct({
+  reports: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0)),
+  passed: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0)),
+  failed: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0)),
+  skipped: Schema25.Int.check(Schema25.isGreaterThanOrEqualTo(0)),
+  skippedTests: Schema25.Array(TestId).check(Schema25.isMaxLength(maxSkippedTests)),
+  ranDigests: Schema25.Array(Schema25.String.check(Schema25.isMaxLength(16))).check(Schema25.isMaxLength(maxRanDigests))
 });
 var entities = new Map([
   ["amp", "&"],
@@ -3723,34 +3811,6 @@ var entities = new Map([
   ["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 referencePattern = /secret:\/\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+/;
-var placeholderMarker = "kitmanref";
-var tokenCharacter = "[A-Za-z0-9._~+/-]";
-var placeholderPattern = new RegExp(`(?<!${tokenCharacter})(?:proxy-ep=[A-Za-z0-9.-]+;)?${tokenCharacter}*${placeholderMarker}((?:[0-9a-f]{2})+)`);
-var anyReference = new RegExp(`${referencePattern.source}|${placeholderPattern.source}`, "g");
-var SecretSummary = Schema25.Struct({
-  name: SecretName2,
-  scope: SecretScope,
-  teamId: Schema25.optionalKey(Id),
-  hosts: SecretHosts,
-  setByActorType: ActorType,
-  setByActorId: Schema25.String,
-  setAt: Timestamp
-});
-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 = Schema25.Struct({ teamId: Schema25.optionalKey(Id) });
-
 // packages/core/src/work-unit.ts
 var WorkUnitLease = Schema26.Struct({
   leaseOwnerId: Id,
@@ -3914,14 +3974,14 @@ var WorkUnitHeartbeatInput = Schema26.Struct({
   workUnitId: Id,
   lease: WorkUnitLeaseInput,
   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)))
+  secrets: Schema26.optionalKey(Schema26.Array(Schema26.Struct({ name: SecretName, version: Schema26.String.check(Schema26.isMinLength(1), Schema26.isMaxLength(128)) })).check(Schema26.isMaxLength(256)))
 });
 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))
+  revokedSecrets: Schema26.optionalKey(Schema26.Array(SecretName))
 });
 var WorkUnitReleaseInput = Schema26.Struct({
   workUnitId: Id,