@kitman-sh/sdk 0.0.0-stage → 0.7.0

package/dist/chunk-zp7s46pz.js

@@ -0,0 +1,3966 @@
+// @bun
+// packages/core/src/package-declarations.ts
+import * as Schema14 from "effect/Schema";
+
+// packages/core/src/agent-sandbox-policy.ts
+import * as Schema from "effect/Schema";
+var Path = Schema.String.check(Schema.isMinLength(1));
+var AgentSandboxNetwork = Schema.Union([
+  Schema.Struct({ hosts: Schema.Array(Schema.String.check(Schema.isMinLength(1))) }),
+  Schema.Literal("open")
+]);
+var AgentSandboxPolicy = Schema.Struct({
+  writablePaths: Schema.Array(Path),
+  readDeniedPaths: Schema.Array(Path),
+  readAllowedPaths: Schema.Array(Path),
+  network: AgentSandboxNetwork,
+  environment: Schema.Record(Schema.String.check(Schema.isMinLength(1)), Schema.String),
+  dockerImageDigest: Schema.optionalKey(Schema.String.check(Schema.isPattern(new RegExp("^sha256:[a-f0-9]{64}$", "u"))))
+});
+
+// packages/core/src/loop-version.ts
+import * as Schema4 from "effect/Schema";
+
+// packages/core/src/common.ts
+import * as Schema3 from "effect/Schema";
+
+// packages/core/src/schema.ts
+import * as Exit from "effect/Exit";
+import * as JsonSchema from "effect/JsonSchema";
+import * as Predicate from "effect/Predicate";
+import * as Schema2 from "effect/Schema";
+var Days = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var DatePattern = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+var TimePattern = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:([Zz])|([+-])(\d\d):(\d\d))$/;
+function isRfc3339Date(value) {
+  const match = DatePattern.exec(value);
+  if (match === null)
+    return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && leap ? 29 : Days[month] ?? 0);
+}
+function isRfc3339Time(value) {
+  const match = TimePattern.exec(value);
+  if (match === null)
+    return false;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3]);
+  if (hour > 23 || minute > 59 || second > 60)
+    return false;
+  if (match[5] !== undefined && (Number(match[6]) > 23 || Number(match[7]) > 59))
+    return false;
+  if (second < 60)
+    return true;
+  const sign = match[5] === "-" ? -1 : 1;
+  const utcMinutes = hour * 60 + minute - sign * (Number(match[6] ?? 0) * 60 + Number(match[7] ?? 0));
+  return (utcMinutes % 1440 + 1440) % 1440 === 1439;
+}
+var isDateTime = Schema2.makeFilter((value) => {
+  const parts = value.split(/T/i);
+  return parts.length === 2 && isRfc3339Date(parts[0] ?? "") && isRfc3339Time(parts[1] ?? "");
+}, { expected: "an RFC 3339 date-time", toJsonSchema: () => ({ format: "date-time" }) });
+var Numeric = Schema2.Union([Schema2.Finite, Schema2.FiniteFromString]);
+var isWholeNumber = Schema2.makeFilter(Number.isInteger, {
+  expected: "an integer",
+  toJsonSchema: () => ({ multipleOf: 1 })
+});
+function guard(schema) {
+  const cached = guards.get(schema);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const decode = Schema2.decodeUnknownExit(Schema2.toType(schema));
+  const created = (input) => Exit.isSuccess(decode(input, { onExcessProperty: "error" })) || hasUndefinedProperty(input) && Exit.isSuccess(decode(withoutUndefined(input), { onExcessProperty: "error" }));
+  guards.set(schema, created);
+  return created;
+}
+var guards = new WeakMap;
+function hasUndefinedProperty(value) {
+  if (Array.isArray(value))
+    return value.some(hasUndefinedProperty);
+  if (!Predicate.isObject(value))
+    return false;
+  return Object.values(value).some((entry) => entry === undefined || hasUndefinedProperty(entry));
+}
+function withoutUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.map(withoutUndefined);
+  }
+  if (!Predicate.isObject(value) || Object.getPrototypeOf(value) !== Object.prototype)
+    return value;
+  return Object.fromEntries(Object.entries(value).flatMap(([key, entry]) => entry === undefined ? [] : [[key, withoutUndefined(entry)]]));
+}
+
+// packages/core/src/common.ts
+var Id = Schema3.String.check(Schema3.isMinLength(1));
+var Slug = Schema3.String.check(Schema3.isMinLength(1), Schema3.isPattern(new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")));
+var Timestamp = Schema3.String.check(isDateTime);
+var ApiError = Schema3.Struct({
+  error: Schema3.Struct({
+    code: Schema3.String,
+    message: Schema3.String,
+    details: Schema3.optionalKey(Schema3.Record(Schema3.String, Schema3.Unknown))
+  })
+});
+var ActorType = Schema3.Union([
+  Schema3.Literal("human"),
+  Schema3.Literal("delegated_agent"),
+  Schema3.Literal("agent")
+]);
+
+// packages/core/src/loop-version.ts
+var LoopReferenceSchema = Schema4.Union([
+  Schema4.Struct({ loopId: Id, alias: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(120)) }),
+  Schema4.Struct({ loopId: Id, versionId: Id }),
+  Schema4.Struct({ loopId: Id, version: Schema4.Int.check(Schema4.isGreaterThanOrEqualTo(1)) }),
+  Schema4.Struct({
+    loopId: Id,
+    digest: Schema4.String.check(Schema4.isMinLength(64), Schema4.isMaxLength(64), Schema4.isPattern(new RegExp("^[a-f0-9]{64}$", "u")))
+  }),
+  Schema4.Struct({
+    slug: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(240)),
+    alias: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(120))
+  }),
+  Schema4.Struct({
+    slug: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(240)),
+    version: Schema4.Int.check(Schema4.isGreaterThanOrEqualTo(1))
+  }),
+  Schema4.Struct({
+    slug: Schema4.String.check(Schema4.isMinLength(1), Schema4.isMaxLength(240)),
+    digest: Schema4.String.check(Schema4.isMinLength(64), Schema4.isMaxLength(64), Schema4.isPattern(new RegExp("^[a-f0-9]{64}$", "u")))
+  })
+]);
+
+// packages/core/src/agent-environment.ts
+import * as Schema5 from "effect/Schema";
+var AgentEnvironmentPolicy = Schema5.Union([Schema5.Literal("recommended"), Schema5.Literal("required")]);
+var AgentHarnessId = Schema5.Union([
+  Schema5.Literal("opencode"),
+  Schema5.Literal("claude-code"),
+  Schema5.Literal("codex"),
+  Schema5.Literal("pi")
+]);
+var Sha256 = Schema5.String.check(Schema5.isPattern(new RegExp("^[a-fA-F0-9]{64}$", "u")));
+var relativePathPattern = "^(?!/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.\\.?($|/)).+$";
+var skillNamePattern = "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$";
+var SourcePath = Schema5.String.check(Schema5.isMinLength(1), Schema5.isPattern(new RegExp(relativePathPattern, "u")));
+var SkillSource = Schema5.Union([
+  Schema5.Struct({
+    kind: Schema5.Literal("skills_sh"),
+    slug: Schema5.String.check(Schema5.isMinLength(1)),
+    version: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("kitman"),
+    skillId: Schema5.optionalKey(Id),
+    name: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1))),
+    contentMarkdown: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1))),
+    files: Schema5.optionalKey(Schema5.Record(SourcePath, Schema5.String))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("git"),
+    url: Schema5.String.check(Schema5.isMinLength(1)),
+    ref: Schema5.String.check(Schema5.isMinLength(1)),
+    path: Schema5.optionalKey(SourcePath),
+    sha256: Schema5.optionalKey(Sha256)
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("package"),
+    packageName: Schema5.String.check(Schema5.isMinLength(1)),
+    version: Schema5.String.check(Schema5.isMinLength(1)),
+    path: Schema5.optionalKey(SourcePath),
+    sha256: Schema5.optionalKey(Sha256)
+  }),
+  Schema5.Struct({ kind: Schema5.Literal("url"), url: Schema5.String.check(Schema5.isMinLength(1)), sha256: Sha256 }),
+  Schema5.Struct({ kind: Schema5.Literal("local_path"), path: Schema5.String.check(Schema5.isMinLength(1)) })
+]);
+var PluginSource = Schema5.Union([
+  Schema5.Struct({
+    kind: Schema5.Literal("package"),
+    packageName: Schema5.String.check(Schema5.isMinLength(1)),
+    version: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("git"),
+    url: Schema5.String.check(Schema5.isMinLength(1)),
+    ref: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("url"),
+    url: Schema5.String.check(Schema5.isMinLength(1)),
+    sha256: Schema5.String.check(Schema5.isPattern(new RegExp("^[a-fA-F0-9]{64}$", "u")))
+  }),
+  Schema5.Struct({ kind: Schema5.Literal("local_path"), path: Schema5.String.check(Schema5.isMinLength(1)) })
+]);
+var McpServerTransport = Schema5.Union([
+  Schema5.Struct({
+    kind: Schema5.Literal("stdio"),
+    command: Schema5.String.check(Schema5.isMinLength(1)),
+    args: Schema5.optionalKey(Schema5.Array(Schema5.String)),
+    env: Schema5.optionalKey(Schema5.Record(Schema5.String, Schema5.String))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("streamable_http"),
+    url: Schema5.String.check(Schema5.isMinLength(1)),
+    headers: Schema5.optionalKey(Schema5.Record(Schema5.String, Schema5.String))
+  })
+]);
+var ProviderAuthRef = Schema5.Union([
+  Schema5.Struct({
+    provider: Schema5.String.check(Schema5.isMinLength(1)),
+    policy: AgentEnvironmentPolicy,
+    kind: Schema5.Literal("existing_harness_login"),
+    accountHint: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    provider: Schema5.String.check(Schema5.isMinLength(1)),
+    policy: AgentEnvironmentPolicy,
+    kind: Schema5.Literal("local_env"),
+    envName: Schema5.String.check(Schema5.isMinLength(1))
+  }),
+  Schema5.Struct({
+    provider: Schema5.String.check(Schema5.isMinLength(1)),
+    policy: AgentEnvironmentPolicy,
+    kind: Schema5.Literal("runner_secret"),
+    runnerSecretName: Schema5.String.check(Schema5.isMinLength(1))
+  }),
+  Schema5.Struct({
+    provider: Schema5.String.check(Schema5.isMinLength(1)),
+    policy: AgentEnvironmentPolicy,
+    kind: Schema5.Literal("managed_oauth"),
+    grantId: Schema5.optionalKey(Id)
+  })
+]);
+var RunnerSecretSource = Schema5.Union([
+  Schema5.Struct({ kind: Schema5.Literal("env"), envName: Schema5.String.check(Schema5.isMinLength(1)) }),
+  Schema5.Struct({ kind: Schema5.Literal("file"), pathRef: Schema5.String.check(Schema5.isMinLength(1)) }),
+  Schema5.Struct({ kind: Schema5.Literal("exec"), commandRef: Schema5.String.check(Schema5.isMinLength(1)) })
+]);
+var RunnerSecretRef = Schema5.Struct({
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  source: RunnerSecretSource,
+  capabilities: Schema5.optionalKey(Schema5.Array(Schema5.String.check(Schema5.isMinLength(1))))
+});
+var AgentSkillRequirement = Schema5.Struct({
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  source: SkillSource
+});
+var AgentPluginRequirement = Schema5.Struct({
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  source: PluginSource
+});
+var AgentMcpServerRequirement = Schema5.Struct({
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  transport: McpServerTransport
+});
+var AgentHarnessSetting = Schema5.Struct({
+  harness: AgentHarnessId,
+  key: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  value: Schema5.Unknown
+});
+var AgentRuntimeConstraint = Schema5.Struct({
+  key: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  value: Schema5.Unknown
+});
+var AgentPermissionRequirement = Schema5.Struct({
+  key: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  value: Schema5.Unknown
+});
+var AgentHookRequirement = Schema5.Struct({
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  event: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  command: Schema5.String.check(Schema5.isMinLength(1)),
+  args: Schema5.optionalKey(Schema5.Array(Schema5.String)),
+  timeoutMs: Schema5.optionalKey(Schema5.Finite.check(Schema5.isGreaterThanOrEqualTo(1)))
+});
+var AgentSandboxPolicyRequirement = Schema5.Struct({
+  key: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  value: Schema5.Unknown
+});
+var AgentEnvironmentFragment = Schema5.Struct({
+  skills: Schema5.optionalKey(Schema5.Array(AgentSkillRequirement)),
+  plugins: Schema5.optionalKey(Schema5.Array(AgentPluginRequirement)),
+  mcpServers: Schema5.optionalKey(Schema5.Array(AgentMcpServerRequirement)),
+  harnessSettings: Schema5.optionalKey(Schema5.Array(AgentHarnessSetting)),
+  providerAuthRefs: Schema5.optionalKey(Schema5.Array(ProviderAuthRef)),
+  runnerSecretRefs: Schema5.optionalKey(Schema5.Array(RunnerSecretRef)),
+  permissions: Schema5.optionalKey(Schema5.Array(AgentPermissionRequirement)),
+  hooks: Schema5.optionalKey(Schema5.Array(AgentHookRequirement)),
+  runtimeConstraints: Schema5.optionalKey(Schema5.Array(AgentRuntimeConstraint)),
+  sandboxPolicyRequirements: Schema5.optionalKey(Schema5.Array(AgentSandboxPolicyRequirement))
+});
+var HarnessKitActivation = Schema5.Struct({
+  harness: AgentHarnessId,
+  kitId: Id,
+  enabled: Schema5.Boolean,
+  policy: Schema5.optionalKey(AgentEnvironmentPolicy)
+});
+var AgentModelPreference = Schema5.Struct({
+  harness: AgentHarnessId,
+  profileRef: Schema5.String.check(Schema5.isMinLength(1)),
+  provider: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1))),
+  model: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+});
+var UserAgentPreferences = Schema5.Struct({
+  userId: Schema5.optionalKey(Id),
+  defaultHarness: Schema5.optionalKey(AgentHarnessId),
+  perHarnessKitActivations: Schema5.optionalKey(Schema5.Array(HarnessKitActivation)),
+  modelPreferences: Schema5.optionalKey(Schema5.Array(AgentModelPreference)),
+  providerAuthRefs: Schema5.optionalKey(Schema5.Array(ProviderAuthRef)),
+  ui: Schema5.optionalKey(Schema5.Record(Schema5.String, Schema5.Unknown)),
+  agentEnvironment: Schema5.optionalKey(AgentEnvironmentFragment)
+});
+var AgentSyncProfileSource = Schema5.Union([
+  Schema5.Struct({
+    kind: Schema5.Literal("personal_kit_defaults"),
+    harness: Schema5.optionalKey(AgentHarnessId),
+    enabled: Schema5.Boolean
+  }),
+  Schema5.Struct({ kind: Schema5.Literal("workspace_assignments"), workspaceId: Id, enabled: Schema5.Boolean }),
+  Schema5.Struct({
+    kind: Schema5.Literal("team_defaults"),
+    workspaceId: Id,
+    teamId: Schema5.optionalKey(Id),
+    enabled: Schema5.Boolean
+  }),
+  Schema5.Struct({ kind: Schema5.Literal("project_kits"), projectId: Id, enabled: Schema5.Boolean })
+]);
+var AgentSyncProfile = Schema5.Struct({
+  id: Schema5.optionalKey(Id),
+  userId: Id,
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  default: Schema5.optionalKey(Schema5.Boolean),
+  harnesses: Schema5.optionalKey(Schema5.Array(AgentHarnessId)),
+  sources: Schema5.Array(AgentSyncProfileSource)
+});
+var AgentKitSourceFields = {
+  kitRef: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1), Schema5.isMaxLength(240))),
+  kitVersion: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1), Schema5.isMaxLength(120))),
+  kitSha256: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(64), Schema5.isMaxLength(64), Schema5.isPattern(new RegExp("^[a-fA-F0-9]{64}$", "u")))),
+  kitActivationId: Schema5.optionalKey(Id),
+  kitActivationType: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1), Schema5.isMaxLength(80)))
+};
+var AgentEnvironmentSource = Schema5.Union([
+  Schema5.Struct({
+    kind: Schema5.Literal("built_in"),
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("user_preferences"),
+    userId: Id,
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("user_kit"),
+    userId: Id,
+    kitId: Id,
+    ...AgentKitSourceFields,
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("agent_sync_profile"),
+    profileId: Schema5.optionalKey(Id),
+    userId: Id,
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("device_local"),
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("workspace_kit"),
+    kitId: Id,
+    ...AgentKitSourceFields,
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("team_default_kit"),
+    teamId: Id,
+    kitId: Id,
+    ...AgentKitSourceFields,
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("project_kit"),
+    kitId: Id,
+    ...AgentKitSourceFields,
+    provenance: Schema5.optionalKey(Schema5.Union([
+      Schema5.Literal("explicit"),
+      Schema5.Literal("workspace_default"),
+      Schema5.Literal("workspace_mandatory")
+    ])),
+    policyRevision: Schema5.optionalKey(Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1))),
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("marketplace_kit"),
+    kitSourceId: Id,
+    kitVersionId: Schema5.optionalKey(Id),
+    kitInstallationId: Schema5.optionalKey(Id),
+    kitActivationId: Schema5.optionalKey(Id),
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("step_attempt_override"),
+    stepAttemptId: Id,
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  }),
+  Schema5.Struct({
+    kind: Schema5.Literal("command_override"),
+    label: Schema5.optionalKey(Schema5.String.check(Schema5.isMinLength(1)))
+  })
+]);
+var ResolvedAgentSkillRequirement = Schema5.Struct({
+  item: AgentSkillRequirement,
+  source: AgentEnvironmentSource
+});
+var ResolvedAgentPluginRequirement = Schema5.Struct({
+  item: AgentPluginRequirement,
+  source: AgentEnvironmentSource
+});
+var ResolvedAgentMcpServerRequirement = Schema5.Struct({
+  item: AgentMcpServerRequirement,
+  source: AgentEnvironmentSource
+});
+var ResolvedAgentHarnessSetting = Schema5.Struct({ item: AgentHarnessSetting, source: AgentEnvironmentSource });
+var ResolvedProviderAuthRef = Schema5.Struct({ item: ProviderAuthRef, source: AgentEnvironmentSource });
+var ResolvedRunnerSecretRef = Schema5.Struct({ item: RunnerSecretRef, source: AgentEnvironmentSource });
+var ResolvedAgentPermissionRequirement = Schema5.Struct({
+  item: AgentPermissionRequirement,
+  source: AgentEnvironmentSource
+});
+var ResolvedAgentHookRequirement = Schema5.Struct({ item: AgentHookRequirement, source: AgentEnvironmentSource });
+var ResolvedAgentRuntimeConstraint = Schema5.Struct({
+  item: AgentRuntimeConstraint,
+  source: AgentEnvironmentSource
+});
+var ResolvedAgentSandboxPolicyRequirement = Schema5.Struct({
+  item: AgentSandboxPolicyRequirement,
+  source: AgentEnvironmentSource
+});
+var AgentEnvironment = Schema5.Struct({
+  harness: AgentHarnessId,
+  skills: Schema5.Array(ResolvedAgentSkillRequirement),
+  plugins: Schema5.Array(ResolvedAgentPluginRequirement),
+  mcpServers: Schema5.Array(ResolvedAgentMcpServerRequirement),
+  harnessSettings: Schema5.Array(ResolvedAgentHarnessSetting),
+  providerAuthRefs: Schema5.Array(ResolvedProviderAuthRef),
+  runnerSecretRefs: Schema5.Array(ResolvedRunnerSecretRef),
+  permissions: Schema5.Array(ResolvedAgentPermissionRequirement),
+  hooks: Schema5.Array(ResolvedAgentHookRequirement),
+  runtimeConstraints: Schema5.Array(ResolvedAgentRuntimeConstraint),
+  sandboxPolicyRequirements: Schema5.Array(ResolvedAgentSandboxPolicyRequirement),
+  warnings: Schema5.Array(Schema5.String)
+});
+var KitMarketplaceAgentEnvironmentSyncStates = ["ready", "needs_sync", "blocked"];
+var KitMarketplaceAgentEnvironmentEffectKinds = [
+  "skill",
+  "plugin",
+  "mcp_server",
+  "harness_setting",
+  "provider_auth_ref",
+  "runner_secret_ref",
+  "permission",
+  "hook",
+  "runtime_constraint",
+  "sandbox_policy_requirement"
+];
+var KitMarketplaceAgentEnvironmentMaterializerRequirements = [
+  "config_writer",
+  "provider_auth",
+  "runner_secret",
+  "bun",
+  "sandbox_policy"
+];
+var KitMarketplaceAgentEnvironmentEffect = Schema5.Struct({
+  kind: Schema5.Literals(KitMarketplaceAgentEnvironmentEffectKinds),
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  source: AgentEnvironmentSource,
+  materializerRequirements: Schema5.Array(Schema5.Literals(KitMarketplaceAgentEnvironmentMaterializerRequirements))
+});
+var KitMarketplaceAgentEnvironmentSyncPreview = Schema5.Struct({
+  state: Schema5.Literals(KitMarketplaceAgentEnvironmentSyncStates),
+  agentEnvironment: AgentEnvironment,
+  effects: Schema5.Array(KitMarketplaceAgentEnvironmentEffect),
+  blockers: Schema5.Array(Schema5.String),
+  drift: Schema5.Array(Schema5.String)
+});
+var AgentEnvironmentSyncPlanStatuses = ["ready", "needs_apply", "blocked"];
+var AgentEnvironmentSyncPlanItemKinds = [
+  "skill",
+  "plugin",
+  "mcp_server",
+  "harness_setting",
+  "provider_auth_ref",
+  "runner_secret_ref",
+  "permission",
+  "hook",
+  "runtime_constraint",
+  "sandbox_policy_requirement"
+];
+var AgentEnvironmentSyncPlanApplyModes = ["automatic", "manual", "verify_only"];
+var AgentEnvironmentSyncPlanItem = Schema5.Struct({
+  kind: Schema5.Literals(AgentEnvironmentSyncPlanItemKinds),
+  name: Schema5.String.check(Schema5.isMinLength(1)),
+  policy: AgentEnvironmentPolicy,
+  source: AgentEnvironmentSource,
+  materializerRequirements: Schema5.Array(Schema5.Literals(KitMarketplaceAgentEnvironmentMaterializerRequirements)),
+  applyMode: Schema5.Literals(AgentEnvironmentSyncPlanApplyModes)
+});
+var AgentEnvironmentSyncPlan = Schema5.Struct({
+  status: Schema5.Literals(AgentEnvironmentSyncPlanStatuses),
+  targetHarness: AgentHarnessId,
+  agentEnvironment: AgentEnvironment,
+  items: Schema5.Array(AgentEnvironmentSyncPlanItem),
+  blockers: Schema5.Array(Schema5.String),
+  drift: Schema5.Array(Schema5.String)
+});
+
+// packages/core/src/kit.ts
+import * as Schema6 from "effect/Schema";
+import * as Struct6 from "effect/Struct";
+var KitKinds = ["technology", "brand", "domain", "process", "other"];
+var ProjectKitProvenanceKinds = ["explicit", "workspace_default", "workspace_mandatory"];
+var KitKind = Schema6.Union([
+  Schema6.Literal("technology"),
+  Schema6.Literal("brand"),
+  Schema6.Literal("domain"),
+  Schema6.Literal("process"),
+  Schema6.Literal("other")
+]);
+var Kit = Schema6.Struct({
+  id: Id,
+  workspaceId: Id,
+  name: Schema6.String,
+  slug: Slug,
+  kind: KitKind,
+  description: Schema6.optionalKey(Schema6.String),
+  contentMarkdown: Schema6.String,
+  metadata: Schema6.Record(Schema6.String, Schema6.Unknown),
+  projectAttachment: Schema6.optionalKey(Schema6.Struct({
+    provenance: Schema6.Literals(ProjectKitProvenanceKinds),
+    workspaceKitAssignmentId: Schema6.optionalKey(Id),
+    policyRevision: Schema6.optionalKey(Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1))),
+    package: Schema6.optionalKey(Schema6.String)
+  })),
+  package: Schema6.optionalKey(Schema6.String),
+  agentEnvironment: Schema6.optionalKey(AgentEnvironmentFragment),
+  agentInstructions: Schema6.optionalKey(Schema6.String),
+  doNotDo: Schema6.optionalKey(Schema6.String),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var KitPublisherIdentity = Schema6.Struct({
+  name: Schema6.String.check(Schema6.isMinLength(1)),
+  type: Schema6.optionalKey(Schema6.Union([
+    Schema6.Literal("kitman"),
+    Schema6.Literal("workspace"),
+    Schema6.Literal("organization"),
+    Schema6.Literal("individual")
+  ])),
+  url: Schema6.optionalKey(Schema6.String),
+  verified: Schema6.optionalKey(Schema6.Boolean)
+});
+var KitSourceType = Schema6.Union([
+  Schema6.Literal("hosted"),
+  Schema6.Literal("git"),
+  Schema6.Literal("package"),
+  Schema6.Literal("url"),
+  Schema6.Literal("skills_sh")
+]);
+var KitTrustStatus = Schema6.Union([
+  Schema6.Literal("unreviewed"),
+  Schema6.Literal("trusted"),
+  Schema6.Literal("reviewed"),
+  Schema6.Literal("rejected"),
+  Schema6.Literal("deprecated")
+]);
+var KitReviewStatus = Schema6.Union([
+  Schema6.Literal("pending"),
+  Schema6.Literal("approved"),
+  Schema6.Literal("rejected"),
+  Schema6.Literal("deprecated")
+]);
+var KitSourceVisibility = Schema6.Union([
+  Schema6.Literal("public"),
+  Schema6.Literal("organization"),
+  Schema6.Literal("workspace")
+]);
+var SpdxLicenseExpression = Schema6.String.check(Schema6.isMinLength(1), Schema6.isMaxLength(240), Schema6.isPattern(new RegExp("^[A-Za-z0-9][A-Za-z0-9.+:()\\-\\s]*$", "u")));
+var KitLifecycleStatus = Schema6.Union([
+  Schema6.Literal("active"),
+  Schema6.Literal("deprecated"),
+  Schema6.Literal("rejected")
+]);
+var KitMarketplaceInstallState = Schema6.Union([
+  Schema6.Literal("not_installed"),
+  Schema6.Literal("installed"),
+  Schema6.Literal("active"),
+  Schema6.Literal("update_available")
+]);
+var KitMarketplaceRuntimeState = Schema6.Union([
+  Schema6.Literal("ready"),
+  Schema6.Literal("needs_sync"),
+  Schema6.Literal("proposal_required"),
+  Schema6.Literal("deprecated"),
+  Schema6.Literal("blocked")
+]);
+var KitMarketplaceLifecycleOperation = Schema6.Union([
+  Schema6.Literal("install"),
+  Schema6.Literal("activate"),
+  Schema6.Literal("update"),
+  Schema6.Literal("rollback"),
+  Schema6.Literal("disable"),
+  Schema6.Literal("uninstall")
+]);
+var KitCompatibility = Schema6.Struct({
+  harnesses: Schema6.optionalKey(Schema6.Array(Schema6.String)),
+  capabilities: Schema6.optionalKey(Schema6.Array(Schema6.String)),
+  minimumKitmanVersion: Schema6.optionalKey(Schema6.String),
+  runtimeRequirements: Schema6.optionalKey(Schema6.Array(Schema6.String))
+});
+var Sha2562 = Schema6.String.check(Schema6.isPattern(new RegExp("^[a-fA-F0-9]{64}$", "u")));
+var SourcePath2 = Schema6.String.check(Schema6.isMinLength(1), Schema6.isPattern(new RegExp("^(?!/)(?!.*\\\\)(?!.*//)(?!.*(?:^|/)\\.\\.?($|/))(?!.*\\s).+$", "u")));
+var HostedKitSourceProvenance = Schema6.Struct({
+  sourceType: Schema6.Literal("hosted"),
+  path: Schema6.optionalKey(SourcePath2),
+  sha256: Schema6.optionalKey(Sha2562)
+});
+var GitKitSourceProvenance = Schema6.Struct({
+  sourceType: Schema6.Literal("git"),
+  repositoryUrl: Schema6.String.check(Schema6.isMinLength(1)),
+  ref: Schema6.String.check(Schema6.isMinLength(1)),
+  path: Schema6.optionalKey(SourcePath2),
+  sha256: Schema6.optionalKey(Sha2562)
+});
+var PackageKitSourceProvenance = Schema6.Struct({
+  sourceType: Schema6.Literal("package"),
+  packageName: Schema6.String.check(Schema6.isMinLength(1)),
+  version: Schema6.String.check(Schema6.isMinLength(1)),
+  path: Schema6.optionalKey(SourcePath2),
+  sha256: Schema6.optionalKey(Sha2562)
+});
+var UrlKitSourceProvenance = Schema6.Struct({
+  sourceType: Schema6.Literal("url"),
+  url: Schema6.String.check(Schema6.isMinLength(1)),
+  sha256: Sha2562
+});
+var SkillsShKitSourceProvenance = Schema6.Struct({
+  sourceType: Schema6.Literal("skills_sh"),
+  skillsSlug: Schema6.String.check(Schema6.isMinLength(1)),
+  version: Schema6.optionalKey(Schema6.String.check(Schema6.isMinLength(1))),
+  sha256: Schema6.optionalKey(Sha2562)
+});
+var KitSourceProvenance = Schema6.Union([
+  HostedKitSourceProvenance,
+  GitKitSourceProvenance,
+  PackageKitSourceProvenance,
+  UrlKitSourceProvenance,
+  SkillsShKitSourceProvenance
+]);
+var KitSourceBase = Schema6.Struct({
+  id: Id,
+  workspaceId: Schema6.optionalKey(Id),
+  name: Schema6.String,
+  slug: Slug,
+  summary: Schema6.String,
+  publisher: KitPublisherIdentity,
+  visibility: KitSourceVisibility,
+  licenseExpression: Schema6.optionalKey(SpdxLicenseExpression),
+  tags: Schema6.Array(Schema6.String),
+  compatibleHarnesses: Schema6.Array(Schema6.String),
+  capabilitySummaries: Schema6.Array(Schema6.String),
+  trustStatus: KitTrustStatus,
+  reviewStatus: KitReviewStatus,
+  lifecycleStatus: KitLifecycleStatus,
+  installable: Schema6.Boolean,
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var KitSource = Schema6.Union([
+  Schema6.Struct({
+    ...KitSourceBase.fields,
+    ...Schema6.Struct({ sourceType: Schema6.Literal("hosted"), provenance: HostedKitSourceProvenance }).fields
+  }),
+  Schema6.Struct({
+    ...KitSourceBase.fields,
+    ...Schema6.Struct({ sourceType: Schema6.Literal("git"), provenance: GitKitSourceProvenance }).fields
+  }),
+  Schema6.Struct({
+    ...KitSourceBase.fields,
+    ...Schema6.Struct({ sourceType: Schema6.Literal("package"), provenance: PackageKitSourceProvenance }).fields
+  }),
+  Schema6.Struct({
+    ...KitSourceBase.fields,
+    ...Schema6.Struct({ sourceType: Schema6.Literal("url"), provenance: UrlKitSourceProvenance }).fields
+  }),
+  Schema6.Struct({
+    ...KitSourceBase.fields,
+    ...Schema6.Struct({ sourceType: Schema6.Literal("skills_sh"), provenance: SkillsShKitSourceProvenance }).fields
+  })
+]);
+var KitVersion = Schema6.Struct({
+  id: Id,
+  kitSourceId: Id,
+  version: Schema6.String,
+  provenance: KitSourceProvenance,
+  contentKitId: Schema6.optionalKey(Id),
+  compatibility: KitCompatibility,
+  trustStatus: KitTrustStatus,
+  reviewStatus: KitReviewStatus,
+  lifecycleStatus: KitLifecycleStatus,
+  reviewMetadata: Schema6.Record(Schema6.String, Schema6.Unknown),
+  publishedAt: Schema6.optionalKey(Timestamp),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var KitInstallationScope = Schema6.Union([
+  Schema6.Literal("user"),
+  Schema6.Literal("workspace"),
+  Schema6.Literal("team"),
+  Schema6.Literal("project")
+]);
+var KitInstallationBase = Schema6.Struct({
+  id: Id,
+  kitSourceId: Id,
+  scopeType: KitInstallationScope,
+  scopeId: Id,
+  trustStatus: KitTrustStatus,
+  reviewStatus: KitReviewStatus,
+  lifecycleStatus: KitLifecycleStatus,
+  installedByActorType: Schema6.optionalKey(Schema6.String),
+  installedByActorId: Schema6.optionalKey(Id),
+  enabled: Schema6.Boolean,
+  package: Schema6.optionalKey(Schema6.String),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var KitInstallation = Schema6.Union([
+  Schema6.Struct({
+    ...KitInstallationBase.fields,
+    ...Schema6.Struct({ pinned: Schema6.Literal(true), kitVersionId: Id }).fields
+  }),
+  Schema6.Struct({
+    ...KitInstallationBase.fields,
+    ...Schema6.Struct({ pinned: Schema6.Literal(false), kitVersionId: Schema6.optionalKey(Id) }).fields
+  })
+]);
+var KitRegistrySearchItem = Schema6.Struct({
+  id: Id,
+  name: Schema6.String,
+  slug: Slug,
+  summary: Schema6.String,
+  publisher: KitPublisherIdentity,
+  visibility: KitSourceVisibility,
+  licenseExpression: Schema6.optionalKey(SpdxLicenseExpression),
+  sourceType: KitSourceType,
+  versions: Schema6.Array(Schema6.String),
+  tags: Schema6.Array(Schema6.String),
+  compatibleHarnesses: Schema6.Array(Schema6.String),
+  capabilitySummaries: Schema6.Array(Schema6.String),
+  trustStatus: KitTrustStatus,
+  reviewStatus: KitReviewStatus,
+  lifecycleStatus: KitLifecycleStatus,
+  installable: Schema6.Boolean
+});
+var KitActivation = Schema6.Struct({
+  id: Id,
+  kitInstallationId: Id,
+  kitSourceId: Id,
+  kitVersionId: Schema6.optionalKey(Id),
+  scopeType: KitInstallationScope,
+  scopeId: Id,
+  activationType: Schema6.Union([
+    Schema6.Literal("workspace_default"),
+    Schema6.Literal("team_default"),
+    Schema6.Literal("project_attachment"),
+    Schema6.Literal("personal_default"),
+    Schema6.Literal("harness")
+  ]),
+  active: Schema6.Boolean,
+  activeThrough: Schema6.optionalKey(Schema6.String),
+  metadata: Schema6.Record(Schema6.String, Schema6.Unknown),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var KitRegistrySearch = Schema6.Struct({
+  items: Schema6.Array(KitRegistrySearchItem)
+});
+var KitMarketplaceCatalogItem = Schema6.Struct({
+  id: Id,
+  name: Schema6.String,
+  slug: Slug,
+  summary: Schema6.String,
+  publisher: KitPublisherIdentity,
+  visibility: KitSourceVisibility,
+  licenseExpression: Schema6.optionalKey(SpdxLicenseExpression),
+  sourceType: KitSourceType,
+  trustStatus: KitTrustStatus,
+  reviewStatus: KitReviewStatus,
+  lifecycleStatus: KitLifecycleStatus,
+  installable: Schema6.Boolean,
+  latestVersion: Schema6.optionalKey(Schema6.String),
+  installedVersion: Schema6.optionalKey(Schema6.String),
+  installState: KitMarketplaceInstallState,
+  runtimeState: KitMarketplaceRuntimeState,
+  activeThrough: Schema6.optionalKey(Schema6.String),
+  compatibleHarnesses: Schema6.Array(Schema6.String),
+  capabilitySummaries: Schema6.Array(Schema6.String),
+  tags: Schema6.Array(Schema6.String),
+  installedByPackage: Schema6.optionalKey(Schema6.String)
+});
+var KitMarketplacePageInfo = Schema6.Struct({
+  hasNextPage: Schema6.Boolean,
+  endCursor: Schema6.optionalKey(Schema6.String.check(Schema6.isMinLength(1)))
+});
+var KitMarketplaceCatalog = Schema6.Struct({
+  items: Schema6.Array(KitMarketplaceCatalogItem).check(Schema6.isMaxLength(100)),
+  total: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  pageInfo: KitMarketplacePageInfo
+});
+var KitMarketplaceDetail = Schema6.Struct({
+  ...KitMarketplaceCatalogItem.fields,
+  ...Schema6.Struct({
+    provenance: KitSourceProvenance,
+    versions: Schema6.Array(KitVersion),
+    installations: Schema6.Array(KitInstallation),
+    activations: Schema6.Array(KitActivation)
+  }).fields
+});
+var KitMarketplaceCatalogValidator = guard(KitMarketplaceCatalog);
+var KitMarketplaceDetailValidator = guard(KitMarketplaceDetail);
+var KitMarketplacePreviewInput = Schema6.Struct({
+  operation: KitMarketplaceLifecycleOperation,
+  source: Schema6.String.check(Schema6.isMinLength(1)),
+  version: Schema6.optionalKey(Schema6.String.check(Schema6.isMinLength(1))),
+  scopeType: Schema6.optionalKey(KitInstallationScope),
+  scopeId: Schema6.optionalKey(Id),
+  activationType: Schema6.optionalKey(Schema6.Union([
+    Schema6.Literal("workspace_default"),
+    Schema6.Literal("team_default"),
+    Schema6.Literal("project_attachment"),
+    Schema6.Literal("personal_default"),
+    Schema6.Literal("harness")
+  ]))
+});
+var KitMarketplaceSyncReadiness = Schema6.Struct({
+  state: Schema6.Union([Schema6.Literal("ready"), Schema6.Literal("needs_sync"), Schema6.Literal("blocked")]),
+  blockers: Schema6.Array(Schema6.String)
+});
+var KitMarketplacePreview = Schema6.Struct({
+  previewToken: Schema6.String.check(Schema6.isMinLength(1)),
+  operation: KitMarketplaceLifecycleOperation,
+  sourceId: Id,
+  sourceSlug: Slug,
+  scopeType: KitInstallationScope,
+  scopeId: Id,
+  fromVersion: Schema6.optionalKey(Schema6.String),
+  toVersion: Schema6.optionalKey(Schema6.String),
+  installState: KitMarketplaceInstallState,
+  runtimeState: KitMarketplaceRuntimeState,
+  contextImpact: Schema6.Array(Schema6.String),
+  agentEnvironmentEffects: Schema6.Array(Schema6.String),
+  activeThrough: Schema6.optionalKey(Schema6.String),
+  conflicts: Schema6.Array(Schema6.String),
+  warnings: Schema6.Array(Schema6.String),
+  syncReadiness: KitMarketplaceSyncReadiness,
+  requiresProposal: Schema6.Boolean
+});
+var KitMarketplaceApplyPreviewInput = Schema6.Struct({
+  ...KitMarketplacePreviewInput.fields,
+  ...Schema6.Struct({ previewToken: Schema6.String.check(Schema6.isMinLength(1)) }).fields
+});
+var KitMarketplaceLifecycleResult = Schema6.Struct({
+  status: Schema6.Union([
+    Schema6.Literal("installed"),
+    Schema6.Literal("activated"),
+    Schema6.Literal("updated"),
+    Schema6.Literal("rolled_back"),
+    Schema6.Literal("disabled"),
+    Schema6.Literal("uninstalled")
+  ]),
+  previewToken: Schema6.String.check(Schema6.isMinLength(1)),
+  installation: Schema6.optionalKey(KitInstallation),
+  activation: Schema6.optionalKey(KitActivation),
+  syncReadiness: KitMarketplaceSyncReadiness
+});
+var KitCreate = Schema6.Struct({
+  name: Schema6.String.check(Schema6.isMinLength(1), Schema6.isMaxLength(160)),
+  slug: Schema6.optionalKey(Slug),
+  kind: Schema6.optionalKey(KitKind),
+  description: Schema6.optionalKey(Schema6.String),
+  contentMarkdown: Schema6.String.check(Schema6.isMinLength(1)),
+  metadata: Schema6.optionalKey(Schema6.Record(Schema6.String, Schema6.Unknown)),
+  agentEnvironment: Schema6.optionalKey(AgentEnvironmentFragment),
+  agentInstructions: Schema6.optionalKey(Schema6.String),
+  doNotDo: Schema6.optionalKey(Schema6.String)
+});
+var KitUpdate = Schema6.Struct(Struct6.map(KitCreate.fields, Schema6.optionalKey));
+var KitDeleteResult = Schema6.Struct({ deleted: Schema6.Boolean });
+var KitList = Schema6.Struct({
+  items: Schema6.Array(Kit),
+  policyOptOuts: Schema6.optionalKey(Schema6.Array(Schema6.Struct({
+    workspaceKitAssignmentId: Id,
+    kitId: Id,
+    policyRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1))
+  })))
+});
+var ProjectKitAttachResult = Schema6.Struct({
+  status: Schema6.Union([Schema6.Literal("attached"), Schema6.Literal("already_attached")]),
+  projectId: Id,
+  kitId: Id
+});
+var ProjectKitDetachResult = Schema6.Struct({
+  status: Schema6.Union([Schema6.Literal("detached"), Schema6.Literal("not_attached")]),
+  projectId: Id,
+  kitId: Id
+});
+var WorkspacePolicyKitMode = Schema6.Union([Schema6.Literal("default"), Schema6.Literal("mandatory")]);
+var ProjectKitProvenanceKind = Schema6.Union([
+  Schema6.Literal("explicit"),
+  Schema6.Literal("workspace_default"),
+  Schema6.Literal("workspace_mandatory")
+]);
+var WorkspacePolicyKitAssignment = Schema6.Struct({
+  id: Id,
+  workspaceId: Id,
+  kitId: Id,
+  mode: WorkspacePolicyKitMode,
+  revision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1)),
+  createdByActorType: Schema6.optionalKey(ActorType),
+  createdByActorId: Schema6.optionalKey(Id),
+  package: Schema6.optionalKey(Schema6.String),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var WorkspacePolicyKitAssignmentList = Schema6.Struct({
+  items: Schema6.Array(WorkspacePolicyKitAssignment)
+});
+var WorkspacePolicyKitCandidate = Schema6.Struct({
+  kitId: Id,
+  name: Schema6.String,
+  kind: KitKind,
+  trustStatus: KitTrustStatus,
+  installationState: Schema6.Literal("active")
+});
+var WorkspacePolicyKitCandidateList = Schema6.Struct({ items: Schema6.Array(WorkspacePolicyKitCandidate) });
+var WorkspacePolicyKitAssignmentCreate = Schema6.Struct({
+  kitId: Id,
+  mode: WorkspacePolicyKitMode
+});
+var WorkspacePolicyKitAssignmentUpdate = Schema6.Struct({
+  mode: WorkspacePolicyKitMode,
+  expectedRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1))
+});
+var WorkspacePolicyKitAssignmentDelete = Schema6.Struct({
+  expectedRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1))
+});
+var WorkspacePolicyKitAssignmentDeleteResult = Schema6.Struct({
+  deleted: Schema6.Boolean,
+  assignmentId: Id
+});
+var ProjectKitPolicyOverride = Schema6.Struct({
+  id: Id,
+  workspaceId: Id,
+  projectId: Id,
+  workspaceKitAssignmentId: Id,
+  kind: Schema6.Literal("opt_out"),
+  reason: Schema6.optionalKey(Schema6.String),
+  createdByActorType: ActorType,
+  createdByActorId: Id,
+  createdAt: Timestamp
+});
+var ProjectKitPolicyOverrideCreate = Schema6.Struct({
+  expectedRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1)),
+  reason: Schema6.optionalKey(Schema6.String.check(Schema6.isMinLength(1), Schema6.isMaxLength(1000)))
+});
+var ProjectKitPolicyOverrideDelete = Schema6.Struct({
+  expectedRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1))
+});
+var ProjectKitPolicyOverrideDeleteResult = Schema6.Struct({
+  deleted: Schema6.Boolean,
+  projectId: Id,
+  workspaceKitAssignmentId: Id
+});
+var ProjectPolicyKitConvergenceResult = Schema6.Struct({
+  projectId: Id,
+  state: Schema6.Union([Schema6.Literal("current"), Schema6.Literal("degraded")]),
+  highestPolicyRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  scanned: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0), Schema6.isLessThanOrEqualTo(100)),
+  applied: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0), Schema6.isLessThanOrEqualTo(100)),
+  replayed: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0), Schema6.isLessThanOrEqualTo(100)),
+  explicitAttachmentsPreserved: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0), Schema6.isLessThanOrEqualTo(100)),
+  hasMore: Schema6.Boolean,
+  retry: Schema6.Boolean,
+  repairAvailable: Schema6.Boolean,
+  nextCursor: Schema6.optionalKey(Id)
+});
+var ProjectPolicyKitConvergenceInput = Schema6.Struct({ cursor: Schema6.optionalKey(Id) });
+var WorkspacePolicyKitBackfillPreviewKinds = [
+  "affected",
+  "unchanged",
+  "opted_out",
+  "inaccessible",
+  "conflict"
+];
+var WorkspacePolicyKitBackfillApplyStatuses = [
+  "pending",
+  "applied",
+  "skipped",
+  "conflict",
+  "retryable_failure",
+  "cancelled"
+];
+var WorkspacePolicyKitBackfillStates = ["previewed", "running", "partial", "completed", "cancelled"];
+var WorkspacePolicyKitBackfillPreviewKind = Schema6.Literals(WorkspacePolicyKitBackfillPreviewKinds);
+var WorkspacePolicyKitBackfillApplyStatus = Schema6.Literals(WorkspacePolicyKitBackfillApplyStatuses);
+var WorkspacePolicyKitBackfillState = Schema6.Literals(WorkspacePolicyKitBackfillStates);
+var WorkspacePolicyKitBackfillCounts = Schema6.Struct({
+  affected: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  unchanged: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  optedOut: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  inaccessible: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  conflict: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  pending: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  applied: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  skipped: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  retryableFailure: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  cancelled: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0))
+});
+var WorkspacePolicyKitBackfillItem = Schema6.Struct({
+  projectId: Id,
+  projectName: Schema6.String,
+  previewKind: WorkspacePolicyKitBackfillPreviewKind,
+  applyStatus: WorkspacePolicyKitBackfillApplyStatus,
+  attempts: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  errorCode: Schema6.optionalKey(Schema6.String),
+  errorMessage: Schema6.optionalKey(Schema6.String)
+});
+var WorkspacePolicyKitBackfillPage = Schema6.Struct({
+  backfillId: Id,
+  workspaceId: Id,
+  policyRevision: Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(0)),
+  previewToken: Schema6.String.check(Schema6.isMinLength(1)),
+  state: WorkspacePolicyKitBackfillState,
+  counts: WorkspacePolicyKitBackfillCounts,
+  items: Schema6.Array(WorkspacePolicyKitBackfillItem).check(Schema6.isMaxLength(100)),
+  hasMore: Schema6.Boolean,
+  nextCursor: Schema6.optionalKey(Id),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var WorkspacePolicyKitBackfillPreviewInput = Schema6.Struct({
+  limit: Schema6.optionalKey(Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1), Schema6.isLessThanOrEqualTo(100))),
+  cursor: Schema6.optionalKey(Id)
+});
+var WorkspacePolicyKitBackfillApplyInput = Schema6.Struct({
+  previewToken: Schema6.String.check(Schema6.isMinLength(1)),
+  limit: Schema6.optionalKey(Schema6.Int.check(Schema6.isGreaterThanOrEqualTo(1), Schema6.isLessThanOrEqualTo(100))),
+  cursor: Schema6.optionalKey(Id)
+});
+var WorkspacePolicyKitBackfillStatusQuery = Schema6.Struct({
+  limit: Schema6.optionalKey(Numeric.check(isWholeNumber, Schema6.isGreaterThanOrEqualTo(1), Schema6.isLessThanOrEqualTo(100))),
+  cursor: Schema6.optionalKey(Id)
+});
+var WorkspacePolicyKitBackfillCancelResult = Schema6.Struct({
+  backfillId: Id,
+  state: Schema6.Literal("cancelled")
+});
+
+// packages/core/src/loop-layers.ts
+var LoopLayers = ["project", "workspace", "shipped"];
+var AgentEfforts = ["low", "medium", "high", "xhigh"];
+
+// packages/core/src/schedule.ts
+import * as Schema13 from "effect/Schema";
+import * as DateTime from "effect/DateTime";
+import * as Option from "effect/Option";
+
+// packages/core/src/loop.ts
+import * as Effect from "effect/Effect";
+import * as Schema12 from "effect/Schema";
+
+// packages/core/src/context-pack.ts
+import * as Schema7 from "effect/Schema";
+var ContextPackIndexEntryKinds = [
+  "task",
+  "project",
+  "kit",
+  "memory",
+  "decision",
+  "session",
+  "session_update",
+  "proposal",
+  "task_dependency",
+  "repo_binding",
+  "agent_environment",
+  "loop_step"
+];
+var ContextPackRetrievalRefKinds = [
+  "kit",
+  "memory",
+  "decision",
+  "session",
+  "session_update",
+  "proposal",
+  "task_dependency",
+  "repo_binding",
+  "agent_environment",
+  "loop_step"
+];
+var ContextPackMode = Schema7.Union([
+  Schema7.Literal("planning"),
+  Schema7.Literal("implementation"),
+  Schema7.Literal("debugging"),
+  Schema7.Literal("review"),
+  Schema7.Literal("handoff")
+]);
+var ContextPackIndexEntryKind = Schema7.Literals(ContextPackIndexEntryKinds);
+var ContextPackRetrievalRefKind = Schema7.Literals(ContextPackRetrievalRefKinds);
+var ContextPackLaunchBrief = Schema7.Struct({
+  mode: ContextPackMode,
+  taskTitle: Schema7.String.check(Schema7.isMinLength(1)),
+  projectName: Schema7.optionalKey(Schema7.String.check(Schema7.isMinLength(1))),
+  summary: Schema7.String.check(Schema7.isMinLength(1))
+});
+var ContextPackIndexEntry = Schema7.Struct({
+  kind: ContextPackIndexEntryKind,
+  id: Id,
+  title: Schema7.String.check(Schema7.isMinLength(1)),
+  reason: Schema7.String.check(Schema7.isMinLength(1))
+});
+var ContextPackRetrievalRef = Schema7.Struct({
+  kind: ContextPackRetrievalRefKind,
+  id: Id,
+  label: Schema7.String.check(Schema7.isMinLength(1))
+});
+var ContextPackReadinessEvidence = Schema7.Struct({
+  scopeAvailable: Schema7.Boolean,
+  acceptanceCriteriaAvailable: Schema7.Boolean,
+  dependenciesSatisfied: Schema7.Boolean,
+  executionPlanAvailable: Schema7.Boolean,
+  repoBindingAvailable: Schema7.Boolean,
+  verificationCommands: Schema7.Array(Schema7.String.check(Schema7.isMinLength(1), Schema7.isMaxLength(500))).check(Schema7.isMaxLength(50)),
+  deliveryTargetAvailable: Schema7.Boolean
+});
+var ContextPackRelevanceSummary = Schema7.Struct({
+  included: Schema7.Array(Schema7.String.check(Schema7.isMinLength(1))),
+  omitted: Schema7.Array(Schema7.String.check(Schema7.isMinLength(1))),
+  notes: Schema7.Array(Schema7.String.check(Schema7.isMinLength(1))),
+  readiness: Schema7.optionalKey(ContextPackReadinessEvidence)
+});
+var ContextPackBudget = Schema7.Struct({
+  maxMarkdownChars: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(1)),
+  markdownChars: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0)),
+  indexedItemCount: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0)),
+  retrievalRefCount: Schema7.Int.check(Schema7.isGreaterThanOrEqualTo(0))
+});
+var ContextPack = Schema7.Struct({
+  contextPackId: Id,
+  workspaceId: Id,
+  projectId: Schema7.optionalKey(Id),
+  taskId: Id,
+  mode: ContextPackMode,
+  contentMarkdown: Schema7.String.check(Schema7.isMinLength(1)),
+  launchBrief: ContextPackLaunchBrief,
+  contextIndex: Schema7.Array(ContextPackIndexEntry),
+  retrievalRefs: Schema7.Array(ContextPackRetrievalRef),
+  relevanceSummary: ContextPackRelevanceSummary,
+  budget: ContextPackBudget,
+  includedKitIds: Schema7.Array(Id),
+  includedMemoryIds: Schema7.Array(Id),
+  includedDecisionIds: Schema7.Array(Id),
+  includedProposalIds: Schema7.Array(Id),
+  includedSessionIds: Schema7.Array(Id),
+  createdByActorType: ActorType,
+  createdByActorId: Id,
+  createdAt: Timestamp
+});
+var ContextPackGenerate = Schema7.Struct({
+  mode: Schema7.optionalKey(ContextPackMode)
+});
+var ContextPackLatestQuery = Schema7.Struct({
+  mode: Schema7.optionalKey(ContextPackMode)
+});
+var ContextPackResult = Schema7.Struct({
+  contextPackId: Id,
+  mode: ContextPackMode,
+  contentMarkdown: Schema7.String.check(Schema7.isMinLength(1)),
+  launchBrief: Schema7.optionalKey(ContextPackLaunchBrief),
+  contextIndex: Schema7.optionalKey(Schema7.Array(ContextPackIndexEntry)),
+  retrievalRefs: Schema7.optionalKey(Schema7.Array(ContextPackRetrievalRef)),
+  relevanceSummary: Schema7.optionalKey(ContextPackRelevanceSummary),
+  budget: Schema7.optionalKey(ContextPackBudget),
+  includedDecisionIds: Schema7.optionalKey(Schema7.Array(Id)),
+  includedProposalIds: Schema7.optionalKey(Schema7.Array(Id))
+});
+var ContextPackRetrievalInput = Schema7.Struct({
+  contextPackId: Id,
+  ref: ContextPackRetrievalRef
+});
+var ContextPackRetrievedContext = Schema7.Struct({
+  contextPackId: Id,
+  ref: ContextPackRetrievalRef,
+  contentMarkdown: Schema7.String.check(Schema7.isMinLength(1)),
+  safety: Schema7.Struct({
+    rawContentIncluded: Schema7.Boolean,
+    notes: Schema7.Array(Schema7.String.check(Schema7.isMinLength(1)))
+  })
+});
+
+// packages/core/src/extension.ts
+import * as Schema10 from "effect/Schema";
+
+// packages/core/src/run.ts
+import * as Schema9 from "effect/Schema";
+
+// packages/core/src/redaction.ts
+import * as Schema8 from "effect/Schema";
+import * as Data from "effect/Data";
+var EvidenceRefContractVersion = "evidence-ref.v1";
+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 = Schema8.Struct({
+  path: Schema8.String.check(Schema8.isMinLength(1), Schema8.isMaxLength(512)),
+  classification: RedactionClassificationSchema,
+  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")))
+});
+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 = 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: 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) {
+    super({ message: "Durable surface scanner rejected unsafe or unknown content", findings });
+  }
+}
+var LIVE_CANONICAL_ID_KEYS = new Set([
+  "workspace_id",
+  "project_id",
+  "task_id",
+  "session_id",
+  "step_attempt_id",
+  "agent_identity_id",
+  "memory_id",
+  "context_pack_id",
+  "loop_id",
+  "run_id",
+  "loop_change_id",
+  "approval_id",
+  "subject_id",
+  "item_id",
+  "runner_id",
+  "runner_replica_id",
+  "work_unit_id",
+  "placement_id",
+  "dependency_id",
+  "detail_id",
+  "run_event_id",
+  "run_message_id",
+  "run_result_id",
+  "sender_run_id",
+  "recipient_run_id",
+  "lease_id",
+  "client_mutation_id"
+]);
+var LOCAL_PATH_KEYS = new Set([
+  "path",
+  "local_path",
+  "host_path",
+  "checkout_path",
+  "worktree_path",
+  "directory",
+  "dir",
+  "socket",
+  "docker_socket",
+  "ssh_agent_socket"
+]);
+var VALUE_RULES = [
+  ["secret", /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/u, "private-key"],
+  ["credential", /\bBearer\s+[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"]
+];
+var normalizedKeys = new Map;
+var CREDENTIAL_RULES = VALUE_RULES.flatMap(([classification, pattern]) => classification === "secret" || classification === "credential" ? [[classification, new RegExp(pattern.source, `${pattern.flags}g`)]] : []);
+
+// packages/core/src/run.ts
+var RunContractVersion = Schema9.Literal("run.v1");
+var ImmutableExecutionClosureContractVersion = Schema9.Literal("immutable-execution-closure.v1");
+var Sha2563 = 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,
+  Schema9.Array(Schema9.suspend(() => SafeJson)).check(Schema9.isMaxLength(200)),
+  Schema9.Record(SafeKey, Schema9.suspend(() => SafeJson)).check(Schema9.isMaxProperties(200))
+]).annotate({ identifier: "RunSafeJson" });
+var RunActorRef = Schema9.Struct({
+  actorType: Schema9.Union([ActorType, Schema9.Literal("runner")]),
+  actorId: Id,
+  delegatedByUserId: Schema9.optionalKey(Id),
+  agentIdentityId: Schema9.optionalKey(Id),
+  runnerId: Schema9.optionalKey(Id)
+});
+var RunResourceRef = Schema9.Struct({
+  kind: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)),
+  id: Id
+});
+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: Sha2563
+});
+var AgentPinnedKitRef = Schema9.Struct({
+  kitId: Id,
+  version: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
+  sha256: Sha2563,
+  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(Sha2563),
+  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: Sha2563 })
+]);
+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("project"),
+    Schema9.Literal("git"),
+    Schema9.Literal("package"),
+    Schema9.Literal("import")
+  ]),
+  sourceRef: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(240))),
+  sourceCommitSha: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(128))),
+  contentSha256: Sha2563,
+  reviewedBy: Schema9.optionalKey(Schema9.Array(RunActorRef).check(Schema9.isMaxLength(20)))
+});
+var Agent = Schema9.Struct({
+  contractVersion: RunContractVersion,
+  id: Id,
+  workspaceId: Id,
+  projectId: 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,
+  updatedAt: Timestamp
+});
+var RunMessageTypes = [
+  "progress",
+  "question",
+  "answer",
+  "context_request",
+  "context_response",
+  "finding",
+  "partial_result",
+  "handoff",
+  "instruction",
+  "notice"
+];
+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: 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 = Schema9.Struct({
+  type: Schema9.Literal("question"),
+  questionId: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160)),
+  prompt: BoundedText,
+  answerSchema: RunSchemaRef,
+  urgency: Schema9.Union([Schema9.Literal("normal"), Schema9.Literal("blocking")]),
+  waitId: Id
+});
+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 = 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 = 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: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)),
+  summary: BoundedText,
+  evidenceRefs: MessageEvidenceRefs
+});
+var MessagePartialResultPayload = Schema9.Struct({
+  type: Schema9.Literal("partial_result"),
+  outputSchema: RunSchemaRef,
+  data: SafeJson,
+  complete: Schema9.Literal(false)
+});
+var MessageHandoffPayload = Schema9.Struct({
+  type: Schema9.Literal("handoff"),
+  summary: BoundedText,
+  nextAction: Schema9.optionalKey(Schema9.String.check(Schema9.isMaxLength(4000))),
+  evidenceRefs: Schema9.optionalKey(MessageEvidenceRefs)
+});
+var MessageInstructionPayload = Schema9.Struct({
+  type: Schema9.Literal("instruction"),
+  instruction: BoundedText,
+  authority: Schema9.Union([Schema9.Literal("normal"), Schema9.Literal("operator")])
+});
+var MessageNoticePayload = Schema9.Struct({
+  type: Schema9.Literal("notice"),
+  code: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)),
+  summary: BoundedText
+});
+var RunMessagePayload = Schema9.Union([
+  MessageProgressPayload,
+  MessageQuestionPayload,
+  MessageAnswerPayload,
+  MessageContextRequestPayload,
+  MessageContextResponsePayload,
+  MessageFindingPayload,
+  MessagePartialResultPayload,
+  MessageHandoffPayload,
+  MessageInstructionPayload,
+  MessageNoticePayload
+]);
+var RunMessage = Schema9.Struct({
+  contractVersion: RunContractVersion,
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema9.optionalKey(Id),
+  rootRunId: Id,
+  sender: Schema9.Union([
+    Schema9.Struct({ kind: Schema9.Union([Schema9.Literal("run"), Schema9.Literal("step_attempt")]), id: Id }),
+    RunActorRef
+  ]),
+  recipient: Schema9.Struct({ kind: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(80)), id: Id }),
+  type: RunMessageType,
+  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: Schema9.Union([
+    Schema9.Literal("created"),
+    Schema9.Literal("queued"),
+    Schema9.Literal("delivered"),
+    Schema9.Literal("acknowledged"),
+    Schema9.Literal("expired"),
+    Schema9.Literal("failed")
+  ]),
+  idempotencyKey: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(240)),
+  expiresAt: Schema9.optionalKey(Timestamp),
+  createdAt: Timestamp,
+  acknowledgedAt: Schema9.optionalKey(Timestamp)
+});
+var RunResult = Schema9.Struct({
+  contractVersion: RunContractVersion,
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema9.optionalKey(Id),
+  runId: Id,
+  rootRunId: Id,
+  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: Schema9.optionalKey(Schema9.Struct({ schema: RunSchemaRef, data: SafeJson, digest: Sha2563 })),
+  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: Schema9.Boolean,
+    details: Schema9.optionalKey(SafeJson)
+  })),
+  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: Schema9.optionalKey(Schema9.Record(SafeKey, SafeJson).check(Schema9.isMaxProperties(20))),
+  producedBy: Schema9.Struct({
+    workUnitId: Schema9.optionalKey(Id),
+    leaseId: Schema9.optionalKey(Id),
+    fencingTokenDigest: Schema9.optionalKey(Sha2563)
+  }),
+  createdAt: Timestamp,
+  finalizedAt: Timestamp
+});
+var RunEvent = Schema9.Struct({
+  contractVersion: RunContractVersion,
+  id: Id,
+  eventVersion: Schema9.Literal(1),
+  streamId: Id,
+  sequence: Schema9.Int.check(Schema9.isGreaterThanOrEqualTo(1)),
+  workspaceId: Id,
+  projectId: Schema9.optionalKey(Id),
+  subject: RunResourceRef,
+  rootRunId: 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: Schema9.Struct({ type: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(100)), value: SafeJson })
+});
+var WaitKinds = [
+  "timer",
+  "message",
+  "child_run",
+  "external_event",
+  "human_approval",
+  "provider_check",
+  "provider_quota",
+  "resource"
+];
+var WaitKind = Schema9.Literals(WaitKinds);
+var Wait = Schema9.Struct({
+  contractVersion: RunContractVersion,
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema9.optionalKey(Id),
+  runId: Id,
+  rootRunId: Id,
+  stepKey: Schema9.optionalKey(Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(160))),
+  kind: WaitKind,
+  state: Schema9.Union([
+    Schema9.Literal("open"),
+    Schema9.Literal("resolved"),
+    Schema9.Literal("expired"),
+    Schema9.Literal("canceled")
+  ]),
+  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: Schema9.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: Sha2563,
+    actor: Schema9.optionalKey(RunActorRef)
+  })),
+  createdAt: Timestamp,
+  resolvedAt: Schema9.optionalKey(Timestamp)
+});
+var ControlCommandKinds = [
+  "pause",
+  "resume",
+  "extend_budget",
+  "cancel",
+  "retry",
+  "rerun_latest",
+  "takeover",
+  "release_takeover",
+  "answer_wait",
+  "approve_wait",
+  "reject_wait",
+  "refresh_context",
+  "repair_readiness",
+  "sync_agent_environment",
+  "escalate_sandbox",
+  "rotate_secret_ref",
+  "rerun_verification",
+  "create_follow_up",
+  "drain_replica",
+  "discard_cache",
+  "request_status",
+  "request_handoff"
+];
+var ControlCommandKind = Schema9.Literals(ControlCommandKinds);
+var ControlCommand = Schema9.Struct({
+  contractVersion: RunContractVersion,
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema9.optionalKey(Id),
+  target: RunResourceRef,
+  kind: ControlCommandKind,
+  payload: Schema9.Struct({ kind: ControlCommandKind, data: SafeJson }),
+  requestedBy: RunActorRef,
+  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: Schema9.optionalKey(Schema9.Struct({ code: Schema9.String.check(Schema9.isMinLength(1), Schema9.isMaxLength(120)), summary: BoundedText })),
+  createdAt: Timestamp,
+  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,
+    projectId: Schema9.optionalKey(Id),
+    runId: Id
+  }),
+  capturedAt: Timestamp,
+  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 = Schema10.Literals(NativeExtensionTargets);
+var NativeExtensionPolicies = ["optional", "required"];
+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: Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(1), Schema10.isLessThanOrEqualTo(10)),
+  policy: NativeExtensionPolicy,
+  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 = Schema10.Struct({
+  extensionId: NativeExtensionIdentity,
+  version: Schema10.Int.check(Schema10.isGreaterThanOrEqualTo(1), Schema10.isLessThanOrEqualTo(10)),
+  target: NativeExtensionTarget,
+  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 Schema11 from "effect/Schema";
+var ProposalStatuses = [
+  "proposed",
+  "in_review",
+  "approved",
+  "rejected",
+  "applied",
+  "reverted",
+  "superseded",
+  "canceled"
+];
+var KitMarketplaceProposalTargetTypes = [
+  "kit_source",
+  "kit_version",
+  "kit_installation",
+  "kit_activation",
+  "kit_trust_policy"
+];
+var KitMarketplaceProposalActions = [
+  "source_publish",
+  "version_publish",
+  "source_update",
+  "trust_change",
+  "visibility_change",
+  "broad_activation",
+  "risky_agent_environment_effect",
+  "rollback"
+];
+var ProposalTargetTypes = [
+  "memory",
+  "kit",
+  "agent_environment_policy",
+  "decision",
+  "task",
+  "project_context",
+  "context_relevance",
+  ...KitMarketplaceProposalTargetTypes
+];
+var ProposalRiskLevels = ["low", "medium", "high"];
+var ProposalApprovalPolicyModes = [
+  "auto_approve_low_risk",
+  "require_other_project_member",
+  "require_workspace_owner_or_admin"
+];
+var ProposalPolicyViolationCodes = [
+  "autonomous_self_approval",
+  "self_capability_escalation",
+  "missing_required_approval",
+  "unsafe_payload",
+  "target_conflict"
+];
+var ProposalPolicyViolationSeverities = ["warning", "blocking"];
+var ProposalCheckKinds = ["schema", "policy", "preflight", "conflict", "safety"];
+var ProposalCheckStatuses = ["pending", "passed", "failed", "warning", "skipped"];
+var ProposalApplicationActions = ["applied", "rejected", "reverted"];
+var ProposalRenderedDiffFormats = ["summary", "field_diff", "markdown"];
+var ProposalRenderedDiffSectionRisks = ["low", "medium", "high"];
+var ProposalRenderedDiffRefKinds = [
+  "memory",
+  "kit",
+  "loop",
+  "agent",
+  "agent_environment_policy",
+  "decision",
+  "task",
+  "project_context",
+  "context_relevance",
+  ...KitMarketplaceProposalTargetTypes,
+  "session",
+  "step_attempt",
+  "change_request"
+];
+var ForbiddenProposalNormalizedKeys = [
+  "raw_code",
+  "source_code",
+  "raw_source",
+  "source_snapshot",
+  "source_archive",
+  "file_content",
+  "raw_diff",
+  "diff",
+  "patch",
+  "raw_patch",
+  "raw_log",
+  "raw_logs",
+  "terminal_log",
+  "raw_terminal_log",
+  "stdout",
+  "stderr",
+  "raw_stdout",
+  "raw_stderr",
+  "transcript",
+  "raw_transcript",
+  "raw_provider_payload",
+  "provider_payload",
+  "provider_webhook_payload",
+  "raw_webhook",
+  "provider_comment_body",
+  "comment_body",
+  "raw_comment",
+  "raw_comments",
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "private_key",
+  "secret",
+  "secret_value",
+  "client_secret",
+  "api_key",
+  "authorization",
+  "cookie",
+  "durable_asset_url",
+  "asset_url",
+  "download_url",
+  "upload_url",
+  "presigned_url",
+  "signed_url"
+];
+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 = 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,
+  Schema11.Array(ProposalSafeMetadataScalar).check(Schema11.isMaxLength(100))
+]);
+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),
+  project_context: Schema11.optionalKey(ProposalSafeMetadata),
+  context_relevance: Schema11.optionalKey(ProposalSafeMetadata)
+});
+var ProposalTargetRef = Schema11.Struct({
+  type: ProposalTargetType,
+  id: Schema11.optionalKey(Id),
+  scopeType: Schema11.optionalKey(Schema11.Union([
+    Schema11.Literal("workspace"),
+    Schema11.Literal("project"),
+    Schema11.Literal("task"),
+    Schema11.Literal("kit")
+  ])),
+  scopeId: Schema11.optionalKey(Id)
+});
+var ProposalApprovalPolicy = Schema11.Struct({
+  mode: ProposalApprovalPolicyMode,
+  requireDifferentApprover: Schema11.optionalKey(Schema11.Boolean),
+  autonomousAgentApprovalAllowed: Schema11.Literal(false),
+  deniedViolationCodes: Schema11.Array(ProposalPolicyViolationCode)
+});
+var ProposalPolicyViolation = Schema11.Struct({
+  code: ProposalPolicyViolationCode,
+  severity: ProposalPolicyViolationSeverity,
+  message: ProposalSafeString,
+  actorId: Schema11.optionalKey(Id),
+  target: Schema11.optionalKey(ProposalTargetRef),
+  metadata: Schema11.optionalKey(ProposalSafeMetadata)
+});
+var ProposalRenderedDiffRef = Schema11.Struct({
+  kind: ProposalRenderedDiffRefKind,
+  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 = Schema11.Struct({
+  format: ProposalRenderedDiffFormat,
+  title: Schema11.String.check(Schema11.isMinLength(1), Schema11.isMaxLength(240), Schema11.isPattern(new RegExp(ProposalSafeStringPattern, "u"))),
+  summary: ProposalSafeString,
+  sections: Schema11.Array(ProposalRenderedDiffSection),
+  refs: Schema11.Array(ProposalRenderedDiffRef)
+});
+var ProposalRiskSummary = Schema11.Struct({
+  level: ProposalRiskLevel,
+  summary: ProposalSafeString,
+  reasons: Schema11.Array(ProposalSafeString)
+});
+var KitMarketplaceProposalAction = Schema11.Literals(KitMarketplaceProposalActions);
+var KitMarketplaceProposalReview = Schema11.Struct({
+  action: KitMarketplaceProposalAction,
+  target: ProposalTargetRef,
+  payload: ProposalPayload,
+  renderedDiff: ProposalRenderedDiff,
+  riskSummary: ProposalRiskSummary,
+  validationFindings: Schema11.Array(ProposalPolicyViolation),
+  approvalPolicy: ProposalApprovalPolicy
+});
+var Proposal = Schema11.Struct({
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema11.optionalKey(Id),
+  taskId: Schema11.optionalKey(Id),
+  target: ProposalTargetRef,
+  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: Schema11.optionalKey(Id),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var ProposalRevision = Schema11.Struct({
+  id: Id,
+  proposalId: Id,
+  revisionNumber: Schema11.Int.check(Schema11.isGreaterThanOrEqualTo(1)),
+  payload: ProposalPayload,
+  renderedDiff: ProposalRenderedDiff,
+  riskSummary: ProposalRiskSummary,
+  createdByActorType: ActorType,
+  createdByActorId: Id,
+  createdAt: Timestamp
+});
+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 = Schema11.Struct({
+  id: Id,
+  proposalId: Id,
+  revisionId: Schema11.optionalKey(Id),
+  body: ProposalSafeString,
+  anchor: Schema11.optionalKey(ProposalCommentAnchor),
+  actorType: ActorType,
+  actorId: Id,
+  delegatedByUserId: Schema11.optionalKey(Id),
+  createdAt: Timestamp
+});
+var ProposalCheck = Schema11.Struct({
+  id: Id,
+  proposalId: Id,
+  revisionId: Schema11.optionalKey(Id),
+  kind: ProposalCheckKind,
+  status: ProposalCheckStatus,
+  summary: ProposalSafeString,
+  details: Schema11.optionalKey(ProposalSafeMetadata),
+  createdAt: Timestamp
+});
+var ProposalApplication = Schema11.Struct({
+  id: Id,
+  proposalId: Id,
+  revisionId: Id,
+  action: ProposalApplicationAction,
+  target: ProposalTargetRef,
+  appliedByActorType: ActorType,
+  appliedByActorId: Id,
+  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() {
+  return ForbiddenProposalNormalizedKeys.flatMap((key) => {
+    const camel = key.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+    const kebab = key.replaceAll("_", "-");
+    return [key, camel, kebab];
+  });
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// packages/core/src/loop.ts
+var LoopStatuses = ["draft", "active", "disabled", "archived"];
+var LoopStepImplementationKinds = [
+  "built_in_action",
+  "agent",
+  "wait_for_event",
+  "human_approval",
+  "runner_sandbox",
+  "package_ref",
+  "repeat_until",
+  "call_loop"
+];
+var RunStatuses = ["pending", "running", "blocked", "completed", "failed", "canceled", "expired"];
+var RunStepStatuses = [
+  "pending",
+  "running",
+  "waiting",
+  "blocked",
+  "completed",
+  "failed",
+  "skipped",
+  "canceled"
+];
+var StepAttemptStatuses = [
+  "pending",
+  "running",
+  "waiting",
+  "blocked",
+  "completed",
+  "failed",
+  "canceled"
+];
+var QuestionStatuses = [
+  "open",
+  "answered",
+  "resume_requested",
+  "resumed",
+  "resume_failed",
+  "expired",
+  "cancelled"
+];
+var LoopGuardSources = [
+  "trigger_event",
+  "task",
+  "project",
+  "proposal",
+  "decision",
+  "step_attempt",
+  "change_request",
+  "context_feedback",
+  "run",
+  "project_policy"
+];
+var LoopSourceModes = ["direct", "git_backed"];
+var LoopGuardOperators = ["equals", "not_equals", "in", "not_in", "exists", "not_exists"];
+var LoopCapabilityScopeKinds = [
+  "workspace",
+  "project",
+  "task",
+  "change_request",
+  "step_attempt",
+  "run",
+  "repo_binding",
+  "provider_host"
+];
+var LoopRetryBackoffKinds = ["none", "fixed", "exponential"];
+var LoopRequiredRunStepStatuses = [
+  "pending",
+  "running",
+  "waiting",
+  "blocked",
+  "completed",
+  "failed",
+  "canceled"
+];
+var LoopSafeRefKinds = [
+  "task",
+  "kit",
+  "memory",
+  "decision",
+  "knowledge_record",
+  "context_pack",
+  "step_attempt",
+  "change_request",
+  "change_request_review",
+  "provider_action",
+  "thread_entry",
+  "run",
+  "artifact"
+];
+var LoopBaseCapabilityKinds = [
+  "read_task",
+  "read_repo_binding",
+  "read_agent_environment",
+  "read_kit",
+  "update_task_status",
+  "read_change_request",
+  "read_change_request_review",
+  "read_task_link",
+  "refresh_change_request_metadata",
+  "record_change_request_review",
+  "record_session_update",
+  "create_task_link",
+  "create_task_dependency",
+  "create_task_asset",
+  "create_follow_up_task",
+  "execute_agent",
+  "read_step_attempt",
+  "record_task_thread_entry",
+  "write_provider_repository",
+  "write_provider_change_request",
+  "publish_provider_check",
+  "write_provider_comment",
+  "request_provider_changes",
+  "approve_provider_change_request",
+  "merge_provider_change_request",
+  "wait_for_event",
+  "request_human_approval",
+  "execute_package_ref"
+];
+var LoopCapabilityKinds = [
+  ...LoopBaseCapabilityKinds,
+  "read_context_feedback",
+  "read_session_update",
+  "read_repo_binding",
+  "read_agent_environment",
+  "read_kit",
+  "read_memory",
+  "read_decision",
+  "create_task_dependency",
+  "propose_memory",
+  "propose_kit",
+  "propose_decision",
+  "propose_agent_environment_policy",
+  "propose_project_context",
+  "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 LoopReferenceForbiddenContentPattern = "(?:^|[^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_-]+|[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+`;
+var LoopSafeReferencePattern = `^(?!.*(?:${LoopReferenceAndUrlForbiddenContentPattern})).*$`;
+var LoopScopeValueForbiddenContentPattern = LoopReferenceAndUrlForbiddenContentPattern;
+var LoopSafeScopeValuePattern = `^(?!.*(?:${LoopScopeValueForbiddenContentPattern})).*$`;
+var LoopSafeInternalReferencePattern = `^(?!.*(?:${LoopScopeValueForbiddenContentPattern})).*$`;
+var LoopForbiddenDataflowKeys = [
+  "raw_code",
+  "source_code",
+  "raw_source",
+  "source_snapshot",
+  "source_archive",
+  "file_content",
+  "raw_diff",
+  "diff",
+  "patch",
+  "raw_patch",
+  "raw_log",
+  "raw_logs",
+  "terminal_log",
+  "raw_terminal_log",
+  "stdout",
+  "stderr",
+  "raw_stdout",
+  "raw_stderr",
+  "transcript",
+  "raw_transcript",
+  "raw_provider_payload",
+  "provider_payload",
+  "provider_webhook_payload",
+  "raw_webhook",
+  "provider_comment_body",
+  "comment_body",
+  "raw_comment",
+  "raw_comments",
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "private_key",
+  "secret",
+  "secret_value",
+  "client_secret",
+  "api_key",
+  "credential",
+  "credentials",
+  "credential_value",
+  "resolved_value",
+  "authorization",
+  "cookie",
+  "durable_asset_url",
+  "asset_url",
+  "download_url",
+  "upload_url",
+  "presigned_url",
+  "signed_url",
+  "database_url",
+  "connection_string",
+  "postgres_url",
+  "redis_url",
+  "dsn"
+];
+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(LoopSafeReferencePattern, "u")));
+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")));
+function loopForbiddenKeyPattern(key) {
+  const words = key.split(/[_-]+/).filter(Boolean);
+  const separated = words.map((word) => loopCaseInsensitiveWordPattern(word)).join("[_-]+");
+  const camel = words.map((word, index) => index === 0 ? loopCaseInsensitiveWordPattern(word) : loopCaseInsensitiveWordPattern(word, true)).join("");
+  return `(?:(?:^|[_-])${separated}(?=$|[_-])|(?:^|[_-]|(?<=[a-z0-9])(?=[A-Z]))${camel}(?=$|[_-]|[A-Z]))`;
+}
+function loopCaseInsensitiveWordPattern(word, uppercaseFirst = false) {
+  return Array.from(word).map((char, index) => {
+    const lower = char.toLowerCase();
+    const upper = char.toUpperCase();
+    if (uppercaseFirst && index === 0)
+      return `[${upper}${lower}]`;
+    if (lower !== upper)
+      return `[${lower}${upper}]`;
+    return char.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  }).join("");
+}
+var LoopDataSchemaRef = Schema12.Struct({
+  kind: Schema12.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)
+});
+var LoopStepOutputDataValue = Schema12.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))
+]).annotate({ identifier: "LoopStepOutputDataValue" });
+var LoopSafeMetadata = Schema12.Record(LoopDataPathSegment, LoopStepOutputDataValue);
+var LoopGuardValue = Schema12.Union([LoopSafeOutputDataString, Schema12.Finite, Schema12.Boolean]);
+var LoopSafeRef = Schema12.Struct({
+  kind: LoopSafeRefKind,
+  id: Schema12.optionalKey(LoopSafeInternalReferenceString),
+  externalId: Schema12.optionalKey(LoopSafeInternalReferenceString),
+  provider: Schema12.optionalKey(LoopSafeInternalReferenceString),
+  title: Schema12.optionalKey(LoopSafeInternalReferenceString)
+});
+var LoopGuard = Schema12.Struct({
+  key: LoopSafeKey,
+  source: LoopGuardSource,
+  path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1)),
+  operator: LoopGuardOperator,
+  value: Schema12.optionalKey(LoopGuardValue),
+  values: Schema12.optionalKey(Schema12.Array(LoopGuardValue).check(Schema12.isMinLength(1)))
+});
+var LoopCapabilityScope = Schema12.Struct({
+  kind: LoopCapabilityScopeKind,
+  id: Schema12.optionalKey(Id),
+  idRef: Schema12.optionalKey(LoopSafeReferenceString),
+  value: Schema12.optionalKey(LoopSafeScopeValue)
+});
+var LoopCapabilityGrant = Schema12.Struct({
+  capability: LoopCapabilityKind,
+  scope: Schema12.optionalKey(LoopCapabilityScope),
+  reason: Schema12.optionalKey(LoopSafeText)
+});
+var LoopRequiredContextSlice = Schema12.Struct({
+  kind: ContextPackRetrievalRefKind,
+  id: Schema12.optionalKey(Id),
+  idRef: Schema12.optionalKey(LoopSafeReferenceString),
+  reason: LoopSafeText,
+  required: Schema12.Boolean.pipe(Schema12.withDecodingDefaultKey(Effect.succeed(true)))
+});
+var LoopRetryPolicy = Schema12.Struct({
+  maxAttempts: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(20)),
+  backoff: LoopRetryBackoffKind,
+  delaySeconds: Schema12.optionalKey(Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.isLessThanOrEqualTo(86400)))
+});
+var LoopTimeoutPolicy = Schema12.Struct({
+  timeoutSeconds: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1), Schema12.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 LoopGitBackedSource = Schema12.Struct({
+  mode: Schema12.Literal("git_backed"),
+  repoBindingId: Id,
+  gitRef: LoopGitRef,
+  commitSha: LoopGitCommitSha,
+  definitionPath: Schema12.optionalKey(LoopSourcePath),
+  packagePath: Schema12.optionalKey(LoopSourcePath),
+  metadata: Schema12.optionalKey(LoopSafeMetadata)
+});
+var LoopSource = Schema12.Union([LoopDirectSource, LoopGitBackedSource]);
+var LoopStepPackageMetadata = Schema12.Struct({
+  packageName: LoopSafePackageName,
+  version: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(120), Schema12.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)
+});
+var LoopStepInputBindingFields = {
+  key: LoopDataflowKey,
+  required: Schema12.optionalKey(Schema12.Boolean)
+};
+var LoopStepInputBinding = Schema12.Union([
+  Schema12.Struct({
+    ...LoopStepInputBindingFields,
+    source: Schema12.Literal("trigger_event"),
+    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+  }),
+  Schema12.Struct({
+    ...LoopStepInputBindingFields,
+    source: Schema12.Literal("subject"),
+    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+  }),
+  Schema12.Struct({
+    ...LoopStepInputBindingFields,
+    source: Schema12.Literal("context"),
+    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+  }),
+  Schema12.Struct({
+    ...LoopStepInputBindingFields,
+    source: Schema12.Literal("step_output"),
+    stepKey: LoopSafeKey,
+    outputKey: LoopDataflowKey,
+    path: Schema12.optionalKey(Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1)))
+  }),
+  Schema12.Struct({
+    ...LoopStepInputBindingFields,
+    source: Schema12.Literal("run"),
+    path: Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))
+  }),
+  Schema12.Struct({
+    ...LoopStepInputBindingFields,
+    source: Schema12.Literal("literal"),
+    value: LoopStepOutputDataValue
+  })
+]);
+var LoopStepOutputRef = Schema12.Struct({
+  key: LoopDataflowKey,
+  schemaRef: Schema12.optionalKey(LoopDataSchemaRef),
+  path: Schema12.optionalKey(Schema12.Array(LoopDataPathSegment).check(Schema12.isMinLength(1))),
+  required: Schema12.optionalKey(Schema12.Boolean)
+});
+var LoopBuiltInActionStepImplementation = Schema12.Struct({
+  kind: Schema12.Literal("built_in_action"),
+  action: LoopSafeReferenceString,
+  input: Schema12.optionalKey(LoopSafeMetadata)
+});
+var LoopAgentRuntimeComponentSelector = Schema12.Struct({
+  implementation: LoopSafeReferenceString,
+  kind: Schema12.Union([Schema12.Literal("preferred"), Schema12.Literal("required")])
+});
+var LoopAgentStepImplementation = Schema12.Struct({
+  kind: Schema12.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"),
+  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)
+  })),
+  cancellation: Schema12.optionalKey(Schema12.Union([Schema12.Literal("cancel"), Schema12.Literal("timeout")])),
+  releaseRunner: Schema12.optionalKey(Schema12.Boolean)
+});
+var LoopHumanApprovalStepImplementation = Schema12.Struct({
+  kind: Schema12.Literal("human_approval"),
+  prompt: LoopSafeText,
+  approvalPolicy: ProposalApprovalPolicy
+});
+var LoopRunnerSandboxStepImplementation = Schema12.Struct({
+  kind: Schema12.Literal("runner_sandbox"),
+  runnerSelector: LoopSafeMetadata,
+  entrypoint: LoopSafeReferenceString,
+  package: Schema12.optionalKey(LoopStepPackageMetadata)
+});
+var LoopPackageRefStepImplementation = Schema12.Struct({
+  kind: Schema12.Literal("package_ref"),
+  package: LoopStepPackageMetadata
+});
+var LoopCallStepImplementation = Schema12.Struct({
+  kind: Schema12.Literal("call_loop"),
+  loop: LoopReferenceSchema,
+  mode: Schema12.Literal("awaited")
+});
+var LoopConcreteActionImplementation = Schema12.Union([
+  LoopBuiltInActionStepImplementation,
+  LoopAgentStepImplementation,
+  LoopWaitForEventStepImplementation,
+  LoopHumanApprovalStepImplementation,
+  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 LoopRepeatUntilStepImplementation = Schema12.Struct({
+  kind: Schema12.Literal("repeat_until"),
+  body: LoopConcreteActionImplementation,
+  convergenceOutput: LoopDataflowKey,
+  safetyPolicy: LoopRepeatUntilSafetyPolicy
+});
+var LoopStepImplementation = Schema12.Union([
+  LoopConcreteActionImplementation,
+  LoopRepeatUntilStepImplementation,
+  LoopCallStepImplementation
+]);
+var LoopStep = Schema12.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),
+  implementation: LoopStepImplementation,
+  inputSchemaRef: LoopDataSchemaRef,
+  outputSchemaRef: LoopDataSchemaRef,
+  inputBindings: Schema12.Array(LoopStepInputBinding),
+  outputRefs: Schema12.Array(LoopStepOutputRef),
+  allowedCapabilities: Schema12.Array(LoopCapabilityGrant),
+  retryPolicy: LoopRetryPolicy,
+  timeoutPolicy: LoopTimeoutPolicy,
+  metadata: LoopSafeMetadata
+});
+var LoopStepOutput = Schema12.Struct({
+  stepKey: LoopSafeKey,
+  outputSchemaRef: LoopDataSchemaRef,
+  summary: LoopSafeText,
+  data: Schema12.Record(LoopDataflowKey, LoopStepOutputDataValue).check(Schema12.isMinProperties(1)),
+  metadata: Schema12.optionalKey(LoopSafeMetadata),
+  refs: Schema12.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),
+  updatedAt: Timestamp
+};
+var RunStepState = Schema12.Union([
+  Schema12.Struct({
+    ...RunStepStateFields,
+    required: Schema12.Literal(true),
+    status: LoopRequiredRunStepStatus
+  }),
+  Schema12.Struct({
+    ...RunStepStateFields,
+    required: Schema12.Literal(false),
+    status: RunStepStatus
+  })
+]);
+var RunState = Schema12.Struct({
+  stepStates: Schema12.Array(RunStepState),
+  summary: Schema12.optionalKey(LoopSafeText),
+  resultMetadata: LoopSafeMetadata
+});
+var RunTrigger = Schema12.Struct({
+  event: LoopSafeReferenceString,
+  eventId: Id,
+  subject: Schema12.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)),
+    firesAt: Timestamp
+  }),
+  Schema12.Struct({
+    kind: Schema12.Literal("event"),
+    name: Schema12.String.check(Schema12.isMinLength(1)),
+    event: Schema12.String.check(Schema12.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)),
+    verificationId: Id
+  })
+]);
+var RunEvidence = Schema12.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,
+  recordedAt: Timestamp
+});
+var ApprovedVerification = Schema12.Struct({
+  id: Id,
+  repoBindingId: Id,
+  name: Schema12.String,
+  command: Schema12.String,
+  workingDirectory: Schema12.optionalKey(Schema12.String),
+  approvedByUserId: Schema12.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({
+  id: Id,
+  runId: Id,
+  projectId: Schema12.optionalKey(Id),
+  taskId: Schema12.optionalKey(Id),
+  step: Schema12.String,
+  kind: Schema12.String,
+  title: Schema12.String,
+  text: Schema12.String,
+  data: Schema12.optionalKey(Schema12.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 RunArtifactSearchResult = Schema12.Struct({ items: Schema12.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))),
+  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 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)),
+  judgedAt: Timestamp
+});
+var Run = Schema12.Struct({
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema12.optionalKey(Id),
+  taskId: Schema12.optionalKey(Id),
+  sessionId: Schema12.optionalKey(Id),
+  loopId: Id,
+  packageVersionId: Schema12.optionalKey(Id),
+  resourceVersion: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+  status: RunStatus,
+  trigger: RunTrigger,
+  state: RunState,
+  loopDigest: Schema12.optionalKey(BundleDigest),
+  loopLayer: Schema12.optionalKey(Schema12.Literals(["project", "workspace", "shipped"])),
+  parentRunId: 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),
+  createdAt: Timestamp,
+  updatedAt: Timestamp
+});
+var StepAttemptInputKinds = ["kit", "memory", "decision", "knowledge_record", "context_pack"];
+var StepAttemptInputScopeKinds = ["workspace", "project", "task", "loop", "agent"];
+var StepAttemptInputKind = Schema12.Literals(StepAttemptInputKinds);
+var StepAttemptInputScopeKind = Schema12.Literals(StepAttemptInputScopeKinds);
+var StepAttemptInputScope = Schema12.Struct({
+  kind: StepAttemptInputScopeKind,
+  id: Id
+});
+var StepAttemptInputAvailability = Schema12.Union([
+  Schema12.Struct({
+    kind: Schema12.Literal("available"),
+    inspectRef: LoopSafeRef
+  }),
+  Schema12.Struct({
+    kind: Schema12.Union([Schema12.Literal("redacted"), Schema12.Literal("unavailable")]),
+    reason: LoopSafeText
+  })
+]);
+var StepAttemptInputBase = {
+  kind: StepAttemptInputKind,
+  sourceId: Id,
+  sourceScope: StepAttemptInputScope,
+  inclusionReason: LoopSafeText,
+  resolvedAt: Timestamp,
+  appliedToStepKey: LoopSafeKey,
+  availability: StepAttemptInputAvailability
+};
+var StepAttemptInput = Schema12.Union([
+  Schema12.Struct({
+    ...StepAttemptInputBase,
+    sourceVersion: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u")))
+  }),
+  Schema12.Struct({
+    ...StepAttemptInputBase,
+    contentSha256: LoopSha256
+  })
+]);
+var StepAttemptInputManifest = Schema12.Struct({
+  manifestVersion: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+  assembledAt: Timestamp,
+  entries: Schema12.Array(StepAttemptInput),
+  budget: Schema12.optionalKey(LoopSafeMetadata)
+});
+var StepAttemptAgent = Schema12.Struct({
+  id: Id,
+  version: Schema12.optionalKey(Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240), Schema12.isPattern(new RegExp(LoopSafeReferencePattern, "u"))))
+});
+var StepAttemptRunner = Schema12.Struct({
+  id: Id,
+  capabilitySnapshot: Schema12.optionalKey(LoopSafeMetadata)
+});
+var StepAttemptExecutionEnvironment = Schema12.Struct({
+  agent: Schema12.optionalKey(StepAttemptAgent),
+  runner: Schema12.optionalKey(StepAttemptRunner),
+  harness: Schema12.optionalKey(LoopSafeReferenceString),
+  model: Schema12.optionalKey(LoopSafeReferenceString),
+  metadata: LoopSafeMetadata
+});
+var StepAttemptLease = Schema12.Struct({
+  ownerId: Id,
+  runnerReplicaId: Schema12.optionalKey(Id),
+  leaseId: Id,
+  fencingToken: LoopSafeReferenceString,
+  capacitySlot: Schema12.optionalKey(LoopSafeReferenceString),
+  expiresAt: Timestamp,
+  lastHeartbeatAt: Schema12.optionalKey(Timestamp)
+});
+var JsonDocumentObject = Schema12.JsonObject;
+var StepBrief = Schema12.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))
+  })),
+  outputSchema: JsonDocumentObject,
+  skills: Schema12.optionalKey(Schema12.Array(Schema12.Struct({
+    name: Schema12.String.check(Schema12.isPattern(new RegExp(skillNamePattern, "u"))),
+    files: Schema12.Record(Schema12.String.check(Schema12.isPattern(new RegExp(relativePathPattern, "u"))), Schema12.String)
+  }))),
+  toolless: Schema12.optionalKey(Schema12.Literal(true))
+});
+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 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 StepAttempt = Schema12.Struct({
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema12.optionalKey(Id),
+  taskId: Schema12.optionalKey(Id),
+  sessionId: Schema12.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),
+  status: StepAttemptStatus,
+  inputManifest: StepAttemptInputManifest,
+  execution: StepAttemptExecutionEnvironment,
+  output: Schema12.optionalKey(LoopStepOutput),
+  brief: Schema12.optionalKey(StepBrief),
+  failureSummary: Schema12.optionalKey(LoopSafeText),
+  reviewEvidence: Schema12.Array(LoopSafeRef),
+  lease: Schema12.optionalKey(StepAttemptLease),
+  claimIdempotencyKey: Schema12.optionalKey(LoopSafeReferenceString),
+  terminalIdempotencyKey: Schema12.optionalKey(LoopSafeReferenceString),
+  startedAt: Schema12.optionalKey(Timestamp),
+  completedAt: Schema12.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({
+  value: LoopSafeText,
+  answeredByUserId: Id,
+  answeredAt: Timestamp,
+  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+});
+var Question = Schema12.Struct({
+  id: Id,
+  workspaceId: Id,
+  projectId: Schema12.optionalKey(Id),
+  taskId: Schema12.optionalKey(Id),
+  runId: Id,
+  stepKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240)),
+  waitId: Id,
+  taskThreadEntryId: Schema12.optionalKey(Id),
+  prompt: LoopSafeText,
+  options: Schema12.optionalKey(Schema12.Array(LoopSafeText)),
+  freeText: Schema12.optionalKey(Schema12.Boolean),
+  responderPolicy: QuestionResponderPolicy,
+  status: QuestionStatus,
+  answer: Schema12.optionalKey(QuestionAnswer),
+  resolutionOutcome: Schema12.optionalKey(LoopSafeText),
+  createdAt: Timestamp,
+  updatedAt: Timestamp,
+  resolvedAt: Schema12.optionalKey(Timestamp)
+});
+var QuestionAnswerCreate = Schema12.Struct({
+  value: LoopSafeText,
+  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+});
+var QuestionList = Schema12.Struct({ items: Schema12.Array(Question) });
+var RunLaunchContext = Schema12.Struct({
+  projectId: 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 RunStart = Schema12.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))),
+  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)))
+});
+var RunStarted = Schema12.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)
+  })
+});
+var RunStepSummary = Schema12.Struct({
+  name: Schema12.String,
+  status: StepAttemptStatus,
+  startedAt: Timestamp,
+  completedAt: Schema12.optionalKey(Timestamp),
+  output: Schema12.optionalKey(Schema12.Unknown),
+  attempts: Schema12.Array(Schema12.Struct({
+    id: Id,
+    attempt: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+    status: StepAttemptStatus,
+    failureSummary: Schema12.optionalKey(Schema12.String)
+  }))
+});
+var RunSteerDeliveries = ["queued", "delivered", "failed"];
+var RunSteer = Schema12.Struct({
+  id: Id,
+  text: LoopSafeText,
+  delivery: Schema12.Literals(RunSteerDeliveries),
+  step: Schema12.optionalKey(Schema12.String),
+  createdAt: Timestamp
+});
+var RunSteerInput = Schema12.Struct({
+  text: LoopSafeText,
+  idempotencyKey: Schema12.String.check(Schema12.isMinLength(1), Schema12.isMaxLength(240))
+});
+var RunSteerSent = Schema12.Struct({
+  steer: RunSteer,
+  target: Schema12.Literals(["session", "next_step"])
+});
+var RunShow = Schema12.Struct({
+  run: Run,
+  steps: Schema12.Array(RunStepSummary),
+  questions: Schema12.Array(Question),
+  children: Schema12.Array(Schema12.Struct({ runId: Id, name: Schema12.String, status: RunStatus, createdAt: Timestamp })),
+  activities: Schema12.Array(Schema12.Struct({
+    name: Schema12.String,
+    attempt: Schema12.Int.check(Schema12.isGreaterThanOrEqualTo(1)),
+    status: Schema12.Literals(["succeeded", "failed"]),
+    recordedAt: Timestamp
+  })),
+  artifacts: 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),
+  projectId: 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)
+  })
+});
+var ProgramLoop = Schema12.Struct({
+  id: Schema12.String,
+  title: Schema12.String,
+  layer: Schema12.Literals(["project", "workspace", "shipped"]),
+  digest: Schema12.String,
+  outcome: Schema12.optionalKey(Schema12.String),
+  offers: Schema12.Array(Schema12.Struct({ id: Schema12.String, title: Schema12.String, loop: Schema12.String })),
+  publishedAt: Timestamp,
+  package: Schema12.String
+});
+var LoopDetail = Schema12.Struct({ id: Schema12.String, resolved: Schema12.optionalKey(ProgramLoop) });
+var AutomaticStart = Schema12.Struct({
+  eventId: Schema12.String,
+  eventType: Schema12.String,
+  projectId: 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 ProgramAgent = Schema12.Struct({
+  id: Schema12.String,
+  layer: Schema12.Literals(["project", "workspace", "shipped"]),
+  package: 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)),
+  kits: 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)),
+    kits: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
+    network: Schema12.optionalKey(Schema12.Literals(LoopLayers)),
+    sandbox: Schema12.optionalKey(Schema12.Literals(LoopLayers))
+  }))
+});
+var ProgramAgentList = Schema12.Struct({ items: Schema12.Array(ProgramAgent) });
+var ProgramLoopList = Schema12.Struct({ items: Schema12.Array(ProgramLoop) });
+var RunList = Schema12.Struct({ items: Schema12.Array(Run) });
+var RunWaitReasons = ["question", "completed", "failed", "stopped", "timeout"];
+var RunWaitResult = Schema12.Struct({
+  reason: Schema12.Literals(RunWaitReasons),
+  run: Run,
+  questions: Schema12.Array(Question)
+});
+var RunAnswer = Schema12.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))
+});
+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 });
+
+// packages/core/src/schedule.ts
+var ScheduleFrequency = ["daily", "weekly"];
+var ScheduleMisfirePolicies = ["skip", "fire_once", "catch_up"];
+var ScheduleOverlapPolicies = ["allow", "skip", "coalesce"];
+var ScheduleVersionStatuses = ["draft", "published", "disabled", "archived"];
+var ScheduleCalendarRule = 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 ScheduleCronRule = Schema13.Struct({
+  cron: Schema13.String.check(Schema13.isMinLength(9), Schema13.isMaxLength(200), Schema13.isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
+});
+var ScheduleRule = Schema13.Union([ScheduleCalendarRule, ScheduleCronRule]);
+var cronBounds = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7]
+];
+function cronField(field, [min, max]) {
+  const values = new Set;
+  for (const part of field.split(",")) {
+    const match = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+    if (match === null)
+      return;
+    const from = match[1] === "*" ? min : Number(match[2]);
+    const to = match[1] === "*" ? max : match[3] === undefined ? match[4] === undefined ? from : max : Number(match[3]);
+    const step = match[4] === undefined ? 1 : Number(match[4]);
+    if (from < min || to > max || from > to || step < 1)
+      return;
+    for (let value = from;value <= to; value += step)
+      values.add(value);
+  }
+  return values;
+}
+function parseCron(cron) {
+  const fields = cron.split(" ");
+  const [minutes, hours, days, months, weekdays] = fields.map((field, index) => cronField(field, cronBounds[index] ?? [0, 0]));
+  if (fields.length !== 5 || !minutes || !hours || !days || !months || !weekdays)
+    return;
+  return {
+    minutes,
+    hours,
+    days,
+    months,
+    weekdays: new Set([...weekdays].map((value) => value % 7)),
+    dayRestricted: !(fields[2] ?? "").startsWith("*"),
+    weekdayRestricted: !(fields[4] ?? "").startsWith("*")
+  };
+}
+function isScheduleRule(value) {
+  return guard(ScheduleRule)(value) && (!("cron" in value) || parseCron(value.cron) !== undefined);
+}
+var ScheduleVersion = 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)),
+  projectId: 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)),
+  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))
+});
+var zones = new Map;
+var resolvedLocalDateTimes = new Map;
+
+// packages/core/src/package-declarations.ts
+var LoopCapabilities2 = [
+  "agent_work",
+  "ask",
+  "call",
+  "verify",
+  "change_request",
+  "write_back",
+  "post_comment",
+  "create_tasks",
+  "merge_change_request",
+  "publish_release"
+];
+var JsonObject2 = Schema14.Record(Schema14.String, Schema14.Json);
+var recordKeyedBy = (pattern, value) => Schema14.Record(Schema14.String, value).check(Schema14.makeFilter((record) => {
+  const bad = Object.keys(record).find((key) => !new RegExp(pattern).test(key));
+  return bad === undefined ? true : `${JSON.stringify(bad)} is not a valid name or relative path`;
+}));
+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,
+  input: JsonObject2,
+  output: JsonObject2,
+  outcome: Schema14.optionalKey(Schema14.Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"])),
+  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)
+  })),
+  offers: Schema14.Array(Schema14.Struct({ id: Schema14.String, title: Schema14.String, loop: Schema14.String })),
+  capabilities: Schema14.Array(Schema14.Literals(LoopCapabilities2)),
+  secrets: Schema14.optionalKey(Schema14.Array(SecretName)),
+  network: Schema14.optionalKey(AgentSandboxNetwork)
+});
+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)),
+  kits: Schema14.optionalKey(Schema14.Array(Schema14.String)),
+  network: Schema14.optionalKey(Schema14.Union([Schema14.Struct({ hosts: Schema14.Array(Schema14.String) }), Schema14.Literal("open")])),
+  sandbox: Schema14.optionalKey(Schema14.Literal("docker"))
+});
+var scheduleFields = {
+  name: Schema14.String.check(Schema14.isMinLength(1)),
+  loop: Schema14.String,
+  project: Schema14.optionalKey(Schema14.String),
+  input: Schema14.optionalKey(JsonObject2),
+  timezone: Schema14.String,
+  misfire: Schema14.optionalKey(Schema14.Literals(ScheduleMisfirePolicies)),
+  overlap: Schema14.optionalKey(Schema14.Literals(ScheduleOverlapPolicies))
+};
+var ScheduleDeclaration = Schema14.Union([
+  Schema14.Struct({
+    ...scheduleFields,
+    cron: Schema14.String.check(Schema14.makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
+  }),
+  Schema14.Struct({
+    ...scheduleFields,
+    rule: Schema14.declare((value) => isScheduleRule(value), {
+      expected: "a Schedule rule: frequency daily or weekly, hour, minute, and optionally second and daysOfWeek"
+    })
+  })
+]);
+var AuthoredKitDeclaration = Schema14.Struct({
+  name: Schema14.String.check(Schema14.isMinLength(1)),
+  kind: Schema14.optionalKey(Schema14.Literals(KitKinds)),
+  description: Schema14.optionalKey(Schema14.String),
+  context: Schema14.String,
+  skills: Schema14.optionalKey(recordKeyedBy(skillNamePattern, recordKeyedBy(relativePathPattern, Schema14.String)))
+});
+var KitInstallationDeclaration = Schema14.Struct({
+  source: Schema14.String.check(Schema14.isMinLength(1)),
+  version: Schema14.optionalKey(Schema14.String)
+});
+var KitAssignmentDeclaration = Schema14.Struct({
+  kit: Schema14.String.check(Schema14.isMinLength(1)),
+  workspace: Schema14.optionalKey(Schema14.Literals(["default", "mandatory"])),
+  projects: Schema14.optionalKey(Schema14.Array(Schema14.String))
+});
+var KitDeclaration = Schema14.Union([
+  KitInstallationDeclaration,
+  KitAssignmentDeclaration,
+  AuthoredKitDeclaration
+]);
+var PackageDeclarations = Schema14.Struct({
+  loops: Schema14.Array(LoopManifest),
+  agents: Schema14.Record(Schema14.String, AgentDeclaration),
+  schedules: Schema14.optionalKey(Schema14.Record(Schema14.String, ScheduleDeclaration)),
+  kits: Schema14.optionalKey(Schema14.Record(Schema14.String, KitDeclaration))
+});
+var sameLoop = Schema14.toEquivalence(LoopManifest);
+var sameAgent = Schema14.toEquivalence(AgentDeclaration);
+
+// packages/sdk/src/loop/define.ts
+import * as Effect2 from "effect/Effect";
+import * as Schema15 from "effect/Schema";
+var LoopOutcome2 = Schema15.Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"]);
+var defineLoop2 = (definition) => definition;
+
+class ManifestInvalid2 extends Schema15.TaggedError()("ManifestInvalid", {
+  loop: Schema15.String,
+  message: Schema15.String
+}) {
+}
+var jsonSchemaOf2 = (loop, schema) => Effect2.try({
+  try: () => Schema15.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)({
+  agents: definition.agents,
+  when: definition.when ?? [],
+  offers: definition.offers ?? []
+}).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);
+  return {
+    id: definition.id,
+    title: definition.title,
+    input: yield* jsonSchemaOf2(definition.id, definition.input),
+    output: yield* jsonSchemaOf2(definition.id, definition.output),
+    ...definition.outcome === undefined ? undefined : { outcome: definition.outcome },
+    agents: definition.agents,
+    checkout: definition.checkout,
+    when: definition.when ?? [],
+    offers: definition.offers ?? [],
+    capabilities: definition.capabilities,
+    ...definition.secrets === undefined ? undefined : { secrets: definition.secrets },
+    ...definition.network === undefined ? undefined : { network: definition.network }
+  };
+});
+// packages/sdk/src/loop/steps.ts
+import * as Cause from "effect/Cause";
+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 { Activity, DurableDeferred } from "effect/workflow";
+
+// 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
+});
+var VerifyResult2 = Schema16.Struct({
+  revision: Schema16.String,
+  tree: Schema16.String,
+  passed: Schema16.Boolean,
+  checks: Schema16.Array(EvidenceCheck2)
+});
+var OutcomeTable2 = {
+  feature: "Approved verifications pass on the head tree, and review says the scope was met",
+  bug: "A reproducing check fails on the base and passes on the head",
+  refactor: "Approved verifications pass on both base and head",
+  investigation: "A conclusion Output with its sources; no patch needed",
+  docs: "The documented commands run",
+  migration: "A rollback check passes",
+  none: "Only the approved verifications"
+};
+var verdict = (reasons) => reasons.length === 0 ? { settled: true } : { settled: false, reasons };
+var missing = (side) => `No verification evidence for the ${side}`;
+var allPass = (side, result) => {
+  if (result === undefined)
+    return [missing(side)];
+  if (result.checks.length === 0)
+    return [`No approved verification ran on the ${side} tree ${result.tree}`];
+  return result.checks.filter((check) => check.status === "failed" && !check.preExisting).map((check) => `${check.name} fails on the ${side} tree ${result.tree}`);
+};
+var checkOn = (side, result, name) => {
+  if (result === undefined)
+    return { reason: missing(side) };
+  if (name === undefined)
+    return { reason: `No check was named for the ${side}` };
+  const found = result.checks.find((check) => check.name === name);
+  return found === undefined ? { reason: `No evidence for ${name} on the ${side} tree ${result.tree}` } : { found };
+};
+var passesOnHead = (head, name) => {
+  const { found, reason } = checkOn("head", head, name);
+  if (found === undefined)
+    return [reason];
+  return found.status === "passed" ? [] : [`${found.name} fails on the head tree ${head?.tree}`];
+};
+var bugReasons = (input) => {
+  const base = checkOn("base", input.base, input.reproducing);
+  const head = checkOn("head", input.head, input.reproducing);
+  return [
+    ...base.found === undefined ? [base.reason] : base.found.status === "failed" ? [] : [`${base.found.name} does not fail on the base tree ${input.base?.tree}, so the bug is not reproduced`],
+    ...head.found === undefined ? [head.reason] : head.found.status === "passed" ? [] : [`${head.found.name} fails on the head tree ${input.head?.tree}`]
+  ];
+};
+var conclusionReasons = (conclusion) => {
+  if (conclusion === undefined || conclusion.text.trim() === "")
+    return ["No conclusion was given"];
+  return conclusion.sources.length === 0 ? ["The conclusion names no sources"] : [];
+};
+var scopeReasons = (scope) => {
+  if (scope === undefined)
+    return ["Review has not judged the scope"];
+  if (scope.met)
+    return [];
+  return scope.unmet.length === 0 ? ["Review found the scope unmet"] : scope.unmet.map((item) => `Review found the scope unmet: ${item}`);
+};
+var evidenceGate2 = (input) => {
+  switch (input.outcome) {
+    case "feature":
+      return verdict([...allPass("head", input.head), ...scopeReasons(input.review)]);
+    case "bug":
+      return verdict(bugReasons(input));
+    case "refactor":
+      return verdict([...allPass("base", input.base), ...allPass("head", input.head)]);
+    case "investigation":
+      return verdict(conclusionReasons(input.conclusion));
+    case "docs":
+      return verdict((input.documented ?? []).length === 0 ? ["No documented command was named"] : (input.documented ?? []).flatMap((name) => passesOnHead(input.head, name)));
+    case "migration":
+      return verdict(passesOnHead(input.head, input.rollback));
+    default:
+      return verdict(allPass("head", input.head));
+  }
+};
+
+// packages/sdk/src/loop/steps.ts
+class StepFailed2 extends Schema17.TaggedError()("StepFailed", {
+  step: Schema17.String,
+  reason: Schema17.String
+}) {
+  get message() {
+    return `Step "${this.step}" failed: ${this.reason}`;
+  }
+}
+
+class OutputInvalid2 extends Schema17.TaggedError()("OutputInvalid", {
+  step: Schema17.String,
+  message: Schema17.String
+}) {
+}
+
+class QuestionRefused2 extends Schema17.TaggedError()("QuestionRefused", {
+  step: Schema17.String,
+  answer: Schema17.String,
+  options: Schema17.Array(Schema17.String)
+}) {
+}
+
+class WaitTimedOut2 extends Schema17.TaggedError()("WaitTimedOut", {
+  step: Schema17.String,
+  event: Schema17.String
+}) {
+}
+
+class ChildFailed2 extends Schema17.TaggedError()("ChildFailed", {
+  step: Schema17.String,
+  loop: Schema17.String,
+  reason: Schema17.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)
+}) {
+  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 InputInvalid2 extends Schema17.TaggedError()("InputInvalid", {
+  loop: Schema17.String,
+  message: Schema17.String
+}) {
+}
+var LoopEvent2 = Schema17.Struct({ type: Schema17.String, payload: Schema17.Record(Schema17.String, Schema17.Json) });
+
+class LoopRun2 extends Context.Service()("@kitman-sh/sdk/loop/LoopRun") {
+}
+
+class LoopHost2 extends Context.Service()("@kitman-sh/sdk/loop/LoopHost") {
+}
+var agentWorkDeferred2 = (step) => DurableDeferred.make(`agent_work/${step}`, { success: Schema17.Json, error: StepFailed2 });
+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 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) => {
+  if (Exit2.isSuccess(exit))
+    return { name, kind, status: "succeeded", result: exit.value };
+  if (Cause.hasInterruptsOnly(exit.cause))
+    return;
+  return { name, kind, status: "failed", error: Cause.squash(exit.cause) };
+};
+var takeStep2 = (name, kind, capability, body) => Effect3.gen(function* () {
+  const run = yield* LoopRun2;
+  if (run.names.has(name))
+    return yield* new DuplicateStep2({ step: name });
+  if (capability !== undefined && !run.granted.has(capability))
+    return yield* new CapabilityDenied2({ step: name, capability });
+  run.names.add(name);
+  return yield* body.pipe(Effect3.onExit((exit) => Effect3.sync(() => {
+    const record = recordStep(name, kind, exit);
+    if (record !== undefined)
+      run.steps.push(record);
+  })));
+});
+var launch = (deferred, start) => Activity.make({
+  name: deferred.name,
+  error: StepFailed2,
+  execute: Effect3.gen(function* () {
+    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 agentWork2 = (name, options) => takeStep2(name, "agent_work", "agent_work", Effect3.gen(function* () {
+  const run = yield* LoopRun2;
+  const agent = run.agents[options.agent];
+  const undeclared = options.secrets?.find((secret) => !run.secrets.has(secret));
+  if (undeclared !== undefined)
+    return yield* new CapabilityDenied2({ step: name, capability: "agent_work", secret: undeclared });
+  if (agent === undefined)
+    return yield* new StepFailed2({ step: name, reason: `Agent role "${options.agent}" is not declared` });
+  const deferred = agentWorkDeferred2(name);
+  const output = yield* jsonSchemaOf2(run.loop, options.output).pipe(Effect3.mapError((error) => new StepFailed2({ step: name, reason: error.message })));
+  yield* launch(deferred, (host, token) => host.startAgentWork({
+    step: name,
+    role: options.agent,
+    agent,
+    prompt: options.prompt,
+    output,
+    ...options.secrets === undefined ? undefined : { secrets: options.secrets },
+    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 })));
+}));
+var ask2 = (name, question) => takeStep2(name, "ask", "ask", Effect3.gen(function* () {
+  const deferred = answerDeferred2(name);
+  const options = "options" in question ? question.options : undefined;
+  yield* launch(deferred, (host, token) => host.putQuestion({
+    step: name,
+    prompt: question.prompt,
+    ...options === undefined ? undefined : { options },
+    token
+  }));
+  const answer = yield* DurableDeferred.await(deferred);
+  if (options === undefined)
+    return answer;
+  const offered = options.find((option) => option === answer);
+  if (offered === undefined)
+    return yield* new QuestionRefused2({ step: name, answer, options });
+  return offered;
+}));
+var call2 = (name, loop, input) => takeStep2(name, "call", "call", Effect3.gen(function* () {
+  const deferred = childDeferred2(name);
+  const encoded = yield* toJson(name, loop.input, input);
+  yield* launch(deferred, (host, token) => host.admitChild({ step: name, loop: loop.id, input: encoded, 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 })));
+}));
+var waitFor2 = (name, wait) => takeStep2(name, "wait_for", undefined, Effect3.gen(function* () {
+  const deferred = eventDeferred2(name);
+  const timeoutMillis = Duration.toMillis(Duration.fromInputUnsafe(wait.timeout));
+  yield* launch(deferred, (host, token) => host.awaitEvent({
+    step: name,
+    event: wait.event,
+    ...wait.filter === undefined ? undefined : { filter: wait.filter },
+    timeoutMillis,
+    token
+  }));
+  return yield* DurableDeferred.await(deferred);
+}));
+var verify2 = (name, request) => takeStep2(name, "verify", "verify", Effect3.gen(function* () {
+  const deferred = verifyDeferred2(name);
+  yield* launch(deferred, (host, token) => host.startVerification({
+    step: name,
+    ...request.revision === undefined ? undefined : { revision: request.revision },
+    ...request.checks === undefined ? undefined : { checks: request.checks },
+    token
+  }));
+  return yield* DurableDeferred.await(deferred);
+}));
+var approval = ["Approve", "Reject"];
+var suggestVerification2 = (name, verification) => takeStep2(name, "ask", "ask", Effect3.gen(function* () {
+  const deferred = answerDeferred2(name);
+  yield* launch(deferred, (host, token) => host.putQuestion({
+    step: name,
+    prompt: `Approve the verification "${verification.name}" for this repository? It runs \`${verification.command}\`${verification.workingDirectory === undefined ? "" : ` in ${verification.workingDirectory}`}.`,
+    options: approval,
+    verification,
+    token
+  }));
+  return (yield* DurableDeferred.await(deferred)) === "Approve" ? "approved" : "rejected";
+}));
+// 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 { 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)
+});
+var cycleMessage = (keys) => `These tickets block each other in a cycle, so none can start: ${keys.join(", ")}`;
+var ticketsProblem = (tickets) => {
+  const keys = new Set;
+  for (const ticket of tickets) {
+    if (keys.has(ticket.key))
+      return `Two tickets have the key "${ticket.key}"`;
+    keys.add(ticket.key);
+  }
+  for (const ticket of tickets)
+    for (const blocker of ticket.blockedBy)
+      if (!keys.has(blocker))
+        return `Ticket "${ticket.key}" is blocked by "${blocker}", which is not a ticket`;
+  const { blocked } = wavesOf(tickets);
+  return blocked.length === 0 ? undefined : cycleMessage(blocked);
+};
+var PlanTickets2 = Schema18.Array(PlanTicket2).check(Schema18.makeFilter((tickets) => ticketsProblem(tickets) ?? true));
+
+class BlockingCycle2 extends Schema18.TaggedError()("BlockingCycle", {
+  tickets: Schema18.Array(Schema18.String)
+}) {
+  get message() {
+    return cycleMessage(this.tickets);
+  }
+}
+var byRepoBinding = (left, right) => (left.repoBindingId ?? "").localeCompare(right.repoBindingId ?? "");
+function wavesOf(tickets) {
+  const placed = new Set;
+  const waves = [];
+  let left = tickets;
+  while (left.length > 0) {
+    const ready = left.filter((ticket) => ticket.blockedBy.every((blocker) => placed.has(blocker)));
+    if (ready.length === 0)
+      break;
+    for (const ticket of ready)
+      placed.add(ticket.key);
+    waves.push(ready.toSorted(byRepoBinding));
+    left = left.filter((ticket) => !placed.has(ticket.key));
+  }
+  return { waves, blocked: left.map((ticket) => ticket.key) };
+}
+var planWaves2 = (tickets) => Effect4.suspend(() => {
+  const { waves, blocked } = wavesOf(tickets);
+  return blocked.length === 0 ? Effect4.succeed(waves) : Effect4.fail(new BlockingCycle2({ tickets: blocked }));
+});
+
+// packages/sdk/src/loop/activities.ts
+var ChangeRequestRequest2 = Schema19.Struct({
+  title: Schema19.String,
+  body: Schema19.String,
+  integration: Schema19.optional(Schema19.String)
+});
+var ChangeRequestResult2 = Schema19.Struct({ id: Schema19.String, number: Schema19.String, url: Schema19.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 ArtifactRequest2 = Schema19.Struct({
+  kind: Schema19.String,
+  title: Schema19.String,
+  text: Schema19.String,
+  data: Schema19.optional(Schema19.Json)
+});
+var ArtifactResult2 = Schema19.Struct({ artifactId: Schema19.String });
+var NoteRequest2 = Schema19.Struct({ text: Schema19.String, artifactId: Schema19.optional(Schema19.String) });
+var CreateTasksRequest2 = Schema19.Struct({ tickets: Schema19.Array(PlanTicket2) });
+var CreateTasksResult2 = Schema19.Struct({
+  tasks: Schema19.Array(Schema19.Struct({ key: Schema19.String, taskId: 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 });
+var MergeResult2 = Schema19.Union([
+  Schema19.Struct({ status: Schema19.Literal("merged"), revision: Schema19.String }),
+  Schema19.Struct({ status: Schema19.Literal("conflict") })
+]);
+var CommentRequest2 = Schema19.Struct({ changeRequestId: Schema19.String, body: Schema19.String });
+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 });
+
+class ChangeRequestActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/ChangeRequestActivity") {
+}
+
+class WriteBackActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/WriteBackActivity") {
+}
+
+class ArtifactActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/ArtifactActivity") {
+}
+
+class NoteActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/NoteActivity") {
+}
+
+class CommentActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/CommentActivity") {
+}
+
+class CreateTasksActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/CreateTasksActivity") {
+}
+
+class IntegrationBranchActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/IntegrationBranchActivity") {
+}
+
+class MergeChangeRequestActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/MergeChangeRequestActivity") {
+}
+
+class ReleaseActivity2 extends Context2.Service()("@kitman-sh/sdk/loop/ReleaseActivity") {
+}
+var hostActivity = (name, kind, capability, success, execute) => takeStep2(name, kind, capability, Activity2.make({ name: `${kind}/${name}`, success, error: StepFailed2, execute }));
+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* () {
+  return yield* (yield* WriteBackActivity2).run(request, name);
+}));
+var artifact2 = (name, request) => hostActivity(name, "artifact", undefined, ArtifactResult2, Effect5.gen(function* () {
+  return yield* (yield* ArtifactActivity2).run(request, name);
+}));
+var note2 = (name, request) => hostActivity(name, "note", undefined, Schema19.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* () {
+  return yield* (yield* CommentActivity2).run(request, name);
+}));
+var createTasks2 = (name, request) => hostActivity(name, "create_tasks", "create_tasks", CreateTasksResult2, Effect5.gen(function* () {
+  return yield* (yield* CreateTasksActivity2).run(request, name);
+}));
+var integrationBranch2 = (name, request) => hostActivity(name, "integration_branch", "merge_change_request", IntegrationBranch2, Effect5.gen(function* () {
+  return yield* (yield* IntegrationBranchActivity2).run(request, name);
+}));
+var mergeChangeRequest2 = (name, request) => hostActivity(name, "merge_change_request", "merge_change_request", MergeResult2, Effect5.gen(function* () {
+  return yield* (yield* MergeChangeRequestActivity2).run(request, name);
+}));
+var release2 = (name, request) => hostActivity(name, "release", "publish_release", ReleaseResult2, Effect5.gen(function* () {
+  return yield* (yield* ReleaseActivity2).run(request, name);
+}));
+// packages/sdk/src/loop/test-loop.ts
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Context3 from "effect/Context";
+import * as Data2 from "effect/Data";
+import * as Effect6 from "effect/Effect";
+import * as Exit3 from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Option2 from "effect/Option";
+import * as Schema20 from "effect/Schema";
+import { DurableDeferred as DurableDeferred2, Workflow, WorkflowEngine } from "effect/workflow";
+var LoopJournal2 = Schema20.Struct({
+  activities: Schema20.Record(Schema20.String, Schema20.Json),
+  deferreds: Schema20.Record(Schema20.String, Schema20.Json)
+});
+
+class ScriptedFailure2 extends Data2.TaggedClass("ScriptedFailure") {
+}
+var scriptedFailure2 = (reason) => new ScriptedFailure2({ reason });
+var defaultActivities = {
+  changeRequest: {
+    run: () => Effect6.succeed({ id: "change-request-1", number: "1", url: "test://change-requests/1" })
+  },
+  writeBack: { run: () => Effect6.void },
+  artifact: { run: (request) => Effect6.succeed({ artifactId: request.title }) },
+  note: { run: () => Effect6.void },
+  comment: { run: () => Effect6.void },
+  createTasks: {
+    run: (request) => Effect6.succeed({ tasks: request.tickets.map((ticket) => ({ key: ticket.key, taskId: `task-${ticket.key}` })) })
+  },
+  integrationBranch: {
+    run: (request) => Effect6.succeed({
+      repoBindingId: request.repoBindingId ?? "repo",
+      branch: "kitman/run/integration",
+      revision: "integration-head"
+    })
+  },
+  mergeChangeRequest: {
+    run: (request) => Effect6.succeed({ status: "merged", revision: `merged-${request.changeRequestId}` })
+  },
+  release: {
+    run: (request) => Effect6.succeed({
+      tag: request.tag,
+      revision: request.revision ?? "base-head",
+      url: `test://releases/${request.tag}`
+    })
+  }
+};
+var withoutServices = (effect) => Effect6.orDie(Effect6.provide(effect, Context3.empty()));
+var deferredExit = (deferred) => Schema20.Exit(Schema20.toCodecJson(deferred.successSchema), Schema20.toCodecJson(deferred.errorSchema), Schema20.toCodecJson(Schema20.Defect()));
+var journaled = (engine, journal, ran) => ({
+  ...engine,
+  activityExecute: (activity, attempt) => Effect6.gen(function* () {
+    const key = `${activity.name}/${attempt}`;
+    const recorded = journal.activities[key];
+    if (recorded !== undefined)
+      return new Workflow.Complete({
+        exit: yield* withoutServices(Schema20.decodeEffect(Schema20.toCodecJson(activity.exitSchema))(recorded))
+      });
+    const result = yield* engine.activityExecute(activity, attempt);
+    if (result instanceof Workflow.Complete) {
+      ran.push(activity.name);
+      journal.activities[key] = yield* withoutServices(Schema20.encodeEffect(Schema20.toCodecJson(activity.exitSchema))(result.exit));
+    }
+    return result;
+  }),
+  deferredResult: (deferred) => Effect6.gen(function* () {
+    const recorded = journal.deferreds[deferred.name];
+    if (recorded !== undefined)
+      return Option2.some(yield* withoutServices(Schema20.decodeEffect(Schema20.toCodecJson(deferredExit(deferred)))(recorded)));
+    const result = yield* engine.deferredResult(deferred);
+    if (Option2.isSome(result))
+      journal.deferreds[deferred.name] = yield* withoutServices(Schema20.encodeEffect(Schema20.toCodecJson(deferredExit(deferred)))(result.value));
+    return result;
+  })
+});
+var scriptedExit = (scripted, failure) => scripted === undefined ? Exit3.fail(failure("nothing was scripted for this Step")) : scripted instanceof ScriptedFailure2 ? Exit3.fail(failure(scripted.reason)) : Exit3.succeed(scripted);
+var scriptedHost = (script, engine, agentLaunches, childLaunches) => {
+  const resolve = (deferred, token, exit) => DurableDeferred2.done(deferred, { token, exit }).pipe(Effect6.provideService(WorkflowEngine.WorkflowEngine, engine));
+  return {
+    startAgentWork: (launch) => Effect6.andThen(Effect6.sync(() => agentLaunches.push({
+      step: launch.step,
+      agent: launch.agent,
+      prompt: launch.prompt,
+      ...launch.secrets === undefined ? undefined : { secrets: launch.secrets }
+    })), resolve(agentWorkDeferred2(launch.step), launch.token, scriptedExit(script.outputs?.[launch.step], (reason) => new StepFailed2({ step: launch.step, reason })))),
+    putQuestion: (launch) => {
+      const answer = script.answers?.[launch.step];
+      return resolve(answerDeferred2(launch.step), launch.token, answer === undefined ? Exit3.fail(new StepFailed2({ step: launch.step, reason: "no answer was scripted" })) : Exit3.succeed(answer));
+    },
+    admitChild: (launch) => Effect6.andThen(Effect6.sync(() => childLaunches.push({ step: launch.step, loop: launch.loop, input: launch.input })), resolve(childDeferred2(launch.step), launch.token, scriptedExit(script.children?.[launch.step], (reason) => new ChildFailed2({ step: launch.step, loop: launch.loop, reason })))),
+    awaitEvent: (launch) => {
+      const event = script.events?.[launch.step];
+      return resolve(eventDeferred2(launch.step), launch.token, event === undefined ? Exit3.fail(new WaitTimedOut2({ step: launch.step, event: launch.event })) : Exit3.succeed(event));
+    },
+    startVerification: (launch) => {
+      const scripted = script.verifications?.[launch.step];
+      return resolve(verifyDeferred2(launch.step), launch.token, scripted instanceof ScriptedFailure2 ? Exit3.fail(new StepFailed2({ step: launch.step, reason: scripted.reason })) : Exit3.succeed(scripted ?? {
+        revision: launch.revision ?? "head",
+        tree: launch.revision ?? "head",
+        passed: true,
+        checks: []
+      }));
+    }
+  };
+};
+var loopWorkflow2 = (loop) => Workflow.make(`kitman-loop/${loop.id}`, {
+  payload: { input: Schema20.Json },
+  idempotencyKey: () => loop.id,
+  success: loop.output,
+  error: Schema20.declare((_error) => true)
+});
+var executeLoop2 = (loop, runtime) => ({ input }) => Effect6.gen(function* () {
+  const decoded = yield* Schema20.decodeEffect(Schema20.toCodecJson(loop.input))(input).pipe(Effect6.mapError((error) => new InputInvalid2({ loop: loop.id, message: error.message })));
+  const run = LoopRun2.of({
+    loop: loop.id,
+    agents: loop.agents,
+    granted: runtime.granted,
+    secrets: new Set(loop.secrets),
+    names: new Set,
+    steps: []
+  });
+  runtime.onRun?.(run);
+  return yield* loop.run(decoded).pipe(Effect6.provideService(LoopRun2, run), Effect6.provideService(LoopHost2, runtime.host), Effect6.provideService(ChangeRequestActivity2, runtime.activities.changeRequest), Effect6.provideService(WriteBackActivity2, runtime.activities.writeBack), Effect6.provideService(ArtifactActivity2, runtime.activities.artifact), Effect6.provideService(NoteActivity2, runtime.activities.note), Effect6.provideService(CommentActivity2, runtime.activities.comment), Effect6.provideService(CreateTasksActivity2, runtime.activities.createTasks), Effect6.provideService(IntegrationBranchActivity2, runtime.activities.integrationBranch), Effect6.provideService(MergeChangeRequestActivity2, runtime.activities.mergeChangeRequest), Effect6.provideService(ReleaseActivity2, runtime.activities.release));
+});
+var testLoop2 = (loop, script) => {
+  const journal = {
+    activities: { ...script.journal?.activities },
+    deferreds: { ...script.journal?.deferreds }
+  };
+  const ran = [];
+  const agentLaunches = [];
+  const childLaunches = [];
+  let latestSteps = [];
+  const granted = new Set((script.grant ?? loop.capabilities).filter((capability) => loop.capabilities.includes(capability)));
+  const activities = { ...defaultActivities, ...script.activities };
+  const workflow = loopWorkflow2(loop);
+  const execute = (payload) => Effect6.gen(function* () {
+    const engine = yield* WorkflowEngine.WorkflowEngine;
+    return yield* executeLoop2(loop, {
+      host: scriptedHost(script, engine, agentLaunches, childLaunches),
+      activities,
+      granted,
+      onRun: (run) => {
+        latestSteps = run.steps;
+      }
+    })(payload).pipe(Effect6.provideService(WorkflowEngine.WorkflowEngine, journaled(engine, journal, ran)));
+  });
+  return Effect6.gen(function* () {
+    const result = yield* Effect6.exit(workflow.execute({ input: script.input }).pipe(Effect6.provideService(ConfigProvider.ConfigProvider, ConfigProvider.fromUnknown(script.secrets ?? {}))));
+    return { result, steps: latestSteps, journal, activities: ran, agentLaunches, childLaunches };
+  }).pipe(Effect6.provide(workflow.toLayer(execute).pipe(Layer.provideMerge(WorkflowEngine.layerMemory))));
+};
+// packages/sdk/src/loop/review.ts
+import * as Schema21 from "effect/Schema";
+var Severity2 = Schema21.Literals(["blocker", "major", "minor"]);
+var Finding2 = Schema21.Struct({
+  severity: Severity2,
+  file: Schema21.String,
+  line: Schema21.Int,
+  detail: Schema21.String
+});
+var MergedFinding2 = Schema21.Struct({
+  id: Schema21.String,
+  ...Finding2.fields,
+  seats: Schema21.Array(Schema21.String)
+});
+var Rebuttal2 = Schema21.Struct({ findingId: Schema21.String, reason: Schema21.String });
+var RebuttalVerdict2 = Schema21.Struct({ findingId: Schema21.String, accepted: Schema21.Boolean });
+var ScopeJudgement2 = Schema21.Struct({ met: Schema21.Boolean, unmet: Schema21.Array(Schema21.String) });
+var rank = { blocker: 0, major: 1, minor: 2 };
+var isBlocking2 = (finding) => finding.severity !== "minor";
+var mergeFindings2 = (bySeat) => {
+  const merged = new Map;
+  for (const [seat, findings] of Object.entries(bySeat))
+    for (const finding of findings) {
+      const id = `${finding.file}:${finding.line}`;
+      const known = merged.get(id);
+      const seats = [...new Set([...known?.seats ?? [], seat])];
+      const worst = known === undefined || rank[finding.severity] < rank[known.severity] ? finding : known;
+      merged.set(id, { id, severity: worst.severity, file: worst.file, line: worst.line, detail: worst.detail, seats });
+    }
+  return [...merged.values()].toSorted((left, right) => rank[left.severity] - rank[right.severity]);
+};
+var splitDisputed2 = (findings, rebuttals) => {
+  const disputed = [];
+  const undisputed = [];
+  for (const finding of findings) {
+    const rebuttal = rebuttals.find((entry) => entry.findingId === finding.id);
+    if (rebuttal === undefined)
+      undisputed.push(finding);
+    else
+      disputed.push({ finding, rebuttal });
+  }
+  return { disputed, undisputed };
+};
+var settleRound2 = (round) => {
+  const { disputed, undisputed } = splitDisputed2(round.findings, round.rebuttals);
+  const accepted = (entry) => {
+    const verdicts = round.verdicts.filter((verdict) => verdict.findingId === entry.finding.id);
+    return verdicts.length > 0 && verdicts.every((verdict) => verdict.accepted);
+  };
+  return {
+    open: undisputed,
+    withdrawn: disputed.filter(accepted),
+    standing: disputed.filter((entry) => !accepted(entry))
+  };
+};
+var rallyStop2 = (input) => {
+  const open = input.settled.open.filter(isBlocking2).map((finding) => finding.id);
+  const standing = input.settled.standing.flatMap((entry) => isBlocking2(entry.finding) ? [entry.finding.id] : []);
+  const unsettled = [...open, ...standing];
+  const stop = (reason) => ({ stop: true, reason, unsettled });
+  if (unsettled.length === 0)
+    return stop("settled");
+  if (standing.length > 0)
+    return stop("dispute_stands");
+  if (input.previous !== undefined && sameIds(input.previous, unsettled))
+    return stop("findings_returned");
+  return input.round >= input.maxRounds ? stop("round_cap") : { stop: false };
+};
+var sameIds = (left, right) => left.length === right.length && left.every((id) => right.includes(id));
+// packages/sdk/src/loop/check.ts
+import * as Cause2 from "effect/Cause";
+import * as Effect7 from "effect/Effect";
+import * as Exit5 from "effect/Exit";
+import * as Predicate2 from "effect/Predicate";
+import * as Schema22 from "effect/Schema";
+class CheckFailed2 extends Schema22.TaggedError()("CheckFailed", {
+  loop: Schema22.String,
+  check: Schema22.String,
+  reason: Schema22.String
+}) {
+  get detail() {
+    return `Check "${this.check}": ${this.reason}`;
+  }
+  get message() {
+    return `Loop "${this.loop}": ${this.detail}`;
+  }
+}
+
+class StepNamedTwice2 extends Schema22.TaggedError()("StepNamedTwice", {
+  loop: Schema22.String,
+  check: Schema22.String,
+  step: Schema22.String
+}) {
+  get detail() {
+    return `Check "${this.check}": Step "${this.step}" is named twice`;
+  }
+  get message() {
+    return `Loop "${this.loop}": ${this.detail}`;
+  }
+}
+
+class ReplayDiverged2 extends Schema22.TaggedError()("ReplayDiverged", {
+  loop: Schema22.String,
+  check: Schema22.String,
+  first: Schema22.Array(Schema22.String),
+  replay: Schema22.Array(Schema22.String),
+  rerun: Schema22.Array(Schema22.String)
+}) {
+  get detail() {
+    const steps = (names) => names.join(", ") || "no Steps";
+    return `Check "${this.check}": its replay from the journal diverged; it took ${steps(this.first)} and then ${steps(this.replay)}${this.rerun.length > 0 ? `, running ${this.rerun.join(", ")} again` : ""}. Keep effects and randomness inside Activities.`;
+  }
+  get message() {
+    return `Loop "${this.loop}": ${this.detail}`;
+  }
+}
+var LoopCheckError2 = Schema22.Union([CheckFailed2, StepNamedTwice2, ReplayDiverged2]);
+var checkLoop2 = (loop, check) => Effect7.gen(function* () {
+  const first = yield* testLoop2(loop, check.script);
+  if (Exit5.isFailure(first.result)) {
+    const error = Cause2.squash(first.result.cause);
+    if (Predicate2.isTagged(error, "DuplicateStep") && Predicate2.hasProperty(error, "step"))
+      return yield* new StepNamedTwice2({ loop: loop.id, check: check.name, step: String(error.step) });
+    return yield* new CheckFailed2({
+      loop: loop.id,
+      check: check.name,
+      reason: error instanceof Error ? error.message : String(error)
+    });
+  }
+  const replay = yield* testLoop2(loop, { ...check.script, journal: first.journal });
+  const names = (steps) => steps.map((step) => step.name);
+  if (replay.activities.length > 0 || names(replay.steps).join() !== names(first.steps).join())
+    return yield* new ReplayDiverged2({
+      loop: loop.id,
+      check: check.name,
+      first: names(first.steps),
+      replay: names(replay.steps),
+      rerun: replay.activities
+    });
+});
+// packages/sdk/src/loop/config.ts
+var defineConfig2 = (config) => config;
+export { AgentSandboxNetwork, guard, Id, Timestamp, LoopStepOutput, StepBrief, LoopCapabilities2, LoopManifest, AgentDeclaration, KitInstallationDeclaration, KitAssignmentDeclaration, PackageDeclarations, LoopOutcome2, defineLoop2, ManifestInvalid2, jsonSchemaOf2, loopManifest2, EvidenceCheck2, VerifyResult2, OutcomeTable2, evidenceGate2, StepFailed2, OutputInvalid2, QuestionRefused2, WaitTimedOut2, ChildFailed2, CapabilityDenied2, DuplicateStep2, InputInvalid2, LoopEvent2, LoopRun2, LoopHost2, agentWorkDeferred2, answerDeferred2, childDeferred2, eventDeferred2, verifyDeferred2, takeStep2, agentWork2, ask2, call2, waitFor2, verify2, suggestVerification2, PlanTicket2, PlanTickets2, BlockingCycle2, planWaves2, ChangeRequestRequest2, ChangeRequestResult2, WriteBackMilestones2, WriteBackRequest2, ArtifactRequest2, ArtifactResult2, NoteRequest2, CreateTasksRequest2, CreateTasksResult2, IntegrationBranchRequest2, IntegrationBranch2, MergeChangeRequestRequest2, MergeResult2, CommentRequest2, ReleaseRequest2, ReleaseResult2, ChangeRequestActivity2, WriteBackActivity2, ArtifactActivity2, NoteActivity2, CommentActivity2, CreateTasksActivity2, IntegrationBranchActivity2, MergeChangeRequestActivity2, ReleaseActivity2, changeRequest2, writeBack2, artifact2, note2, comment2, createTasks2, integrationBranch2, mergeChangeRequest2, release2, LoopJournal2, ScriptedFailure2, scriptedFailure2, loopWorkflow2, executeLoop2, testLoop2, Severity2, Finding2, MergedFinding2, Rebuttal2, RebuttalVerdict2, ScopeJudgement2, isBlocking2, mergeFindings2, splitDisputed2, settleRound2, rallyStop2, CheckFailed2, StepNamedTwice2, ReplayDiverged2, LoopCheckError2, checkLoop2, defineConfig2 };