@h-rig/contracts 0.0.6-alpha.8 → 0.0.6-alpha.81

package/dist/src/index.js

@@ -1153,12 +1153,14 @@ var RunStatus = Schema6.Literals([
   "running",
   "waiting-approval",
   "waiting-user-input",
+  "paused",
   "validating",
   "reviewing",
+  "closing-out",
+  "needs-attention",
   "completed",
   "failed",
-  "cancelled",
-  "paused"
+  "stopped"
 ]);
 var EngineSandboxMode = Schema6.Literals([
   "read-only",
@@ -1258,58 +1260,499 @@ var WorktreeSummary = Schema6.Struct({
   createdAt: IsoDateTime,
   cleanedAt: Schema6.NullOr(IsoDateTime)
 });
-// packages/contracts/src/conversation.ts
+// packages/contracts/src/run-journal.ts
 import { Schema as Schema7 } from "effect";
-var EngineMessageRole = Schema7.Literals(["user", "assistant", "system"]);
-var EngineMessageState = Schema7.Literals([
+var RunActor = Schema7.Struct({
+  kind: Schema7.Literals(["operator", "agent", "server", "system"]),
+  id: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString))
+});
+var RunCloseoutPhase = Schema7.Literals([
+  "queued",
+  "commit",
+  "push",
+  "pr-review-merge",
+  "pr-opened",
+  "merge",
+  "close-source",
+  "completed"
+]);
+var RunCloseoutPhaseOutcome = Schema7.Literals(["started", "completed", "failed"]);
+var RunCloseoutStatus = Schema7.Literals([
+  "pending",
+  "running",
+  "completed",
+  "needs-attention",
+  "failed"
+]);
+var RunCloseoutState = Schema7.Struct({
+  phase: RunCloseoutPhase,
+  status: RunCloseoutStatus,
+  updatedAt: IsoDateTime,
+  taskId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  runtimeWorkspace: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  branch: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  prUrl: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  artifactRoot: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  iterations: Schema7.optional(Schema7.NullOr(Schema7.Int)),
+  feedback: Schema7.optional(Schema7.Array(Schema7.String)),
+  error: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  reason: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  merged: Schema7.optional(Schema7.Boolean),
+  resumedAt: Schema7.optional(Schema7.NullOr(IsoDateTime)),
+  completedAt: Schema7.optional(Schema7.NullOr(IsoDateTime))
+});
+var ApprovalDecision = Schema7.Literals(["approve", "reject"]);
+var runRecordFields = {
+  runId: TrimmedNonEmptyString,
+  workspaceId: TrimmedNonEmptyString,
+  taskId: Schema7.NullOr(TrimmedNonEmptyString),
+  threadId: Schema7.NullOr(TrimmedNonEmptyString),
+  mode: Schema7.Literals(["local", "remote"]),
+  runtimeAdapter: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  startedAt: Schema7.NullOr(IsoDateTime),
+  completedAt: Schema7.NullOr(IsoDateTime),
+  endpointId: Schema7.NullOr(TrimmedNonEmptyString),
+  hostId: Schema7.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema7.NullOr(TrimmedNonEmptyString),
+  artifactRoot: Schema7.NullOr(TrimmedNonEmptyString),
+  logRoot: Schema7.NullOr(TrimmedNonEmptyString),
+  sessionPath: Schema7.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema7.NullOr(TrimmedNonEmptyString),
+  pid: Schema7.optional(Schema7.NullOr(Schema7.Int)),
+  piSession: Schema7.optional(Schema7.Unknown),
+  piSessionPrivate: Schema7.optional(Schema7.Unknown),
+  updatedAt: IsoDateTime,
+  title: TrimmedNonEmptyString,
+  projectRoot: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  errorText: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  latestMessageId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  prUrl: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  leaseId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  serverCloseout: Schema7.optional(Schema7.NullOr(RunCloseoutState)),
+  model: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  runtimeMode: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  interactionMode: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  runMode: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  initialPrompt: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  baselineMode: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  prMode: Schema7.optional(Schema7.NullOr(Schema7.Literals(["auto", "ask", "off"]))),
+  initiatedBy: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  sourceTask: Schema7.optional(Schema7.Unknown),
+  serverPid: Schema7.optional(Schema7.NullOr(Schema7.Int)),
+  latestSteeringAt: Schema7.optional(Schema7.NullOr(IsoDateTime)),
+  latestSteeringDeliveredAt: Schema7.optional(Schema7.NullOr(IsoDateTime)),
+  statusDetail: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  planning: Schema7.optional(Schema7.Unknown),
+  branch: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString))
+};
+var RunJournalRecord = Schema7.Struct({
+  ...runRecordFields,
+  status: RunStatus
+});
+var RunRecordPatch = Schema7.Struct({
+  runId: Schema7.optional(runRecordFields.runId),
+  workspaceId: Schema7.optional(runRecordFields.workspaceId),
+  taskId: Schema7.optional(runRecordFields.taskId),
+  threadId: Schema7.optional(runRecordFields.threadId),
+  mode: Schema7.optional(runRecordFields.mode),
+  runtimeAdapter: Schema7.optional(runRecordFields.runtimeAdapter),
+  createdAt: Schema7.optional(runRecordFields.createdAt),
+  startedAt: Schema7.optional(runRecordFields.startedAt),
+  completedAt: Schema7.optional(runRecordFields.completedAt),
+  endpointId: Schema7.optional(runRecordFields.endpointId),
+  hostId: Schema7.optional(runRecordFields.hostId),
+  worktreePath: Schema7.optional(runRecordFields.worktreePath),
+  artifactRoot: Schema7.optional(runRecordFields.artifactRoot),
+  logRoot: Schema7.optional(runRecordFields.logRoot),
+  sessionPath: Schema7.optional(runRecordFields.sessionPath),
+  sessionLogPath: Schema7.optional(runRecordFields.sessionLogPath),
+  pid: runRecordFields.pid,
+  piSession: runRecordFields.piSession,
+  piSessionPrivate: runRecordFields.piSessionPrivate,
+  updatedAt: Schema7.optional(runRecordFields.updatedAt),
+  title: Schema7.optional(runRecordFields.title),
+  projectRoot: runRecordFields.projectRoot,
+  errorText: runRecordFields.errorText,
+  latestMessageId: runRecordFields.latestMessageId,
+  prUrl: runRecordFields.prUrl,
+  leaseId: runRecordFields.leaseId,
+  serverCloseout: runRecordFields.serverCloseout,
+  model: runRecordFields.model,
+  runtimeMode: runRecordFields.runtimeMode,
+  interactionMode: runRecordFields.interactionMode,
+  runMode: runRecordFields.runMode,
+  initialPrompt: runRecordFields.initialPrompt,
+  baselineMode: runRecordFields.baselineMode,
+  prMode: runRecordFields.prMode,
+  initiatedBy: runRecordFields.initiatedBy,
+  sourceTask: runRecordFields.sourceTask,
+  serverPid: runRecordFields.serverPid,
+  latestSteeringAt: runRecordFields.latestSteeringAt,
+  latestSteeringDeliveredAt: runRecordFields.latestSteeringDeliveredAt,
+  statusDetail: runRecordFields.statusDetail,
+  planning: runRecordFields.planning,
+  branch: runRecordFields.branch
+});
+var journalEnvelopeFields = {
+  v: Schema7.Literal(1),
+  seq: PositiveInt,
+  at: IsoDateTime,
+  runId: RunId
+};
+var RunStatusChangedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("status-changed"),
+  from: Schema7.NullOr(RunStatus),
+  to: RunStatus,
+  reason: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  actor: Schema7.optional(RunActor)
+});
+var RunRecordPatchEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("record-patch"),
+  patch: RunRecordPatch
+});
+var RunTimelineEntryEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("timeline-entry"),
+  payload: Schema7.Unknown
+});
+var RunLogEntryEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("log-entry"),
+  payload: Schema7.Unknown
+});
+var RunApprovalRequestedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("approval-requested"),
+  requestId: TrimmedNonEmptyString,
+  requestKind: TrimmedNonEmptyString,
+  actionId: Schema7.optional(Schema7.NullOr(TrimmedNonEmptyString)),
+  payload: Schema7.Unknown
+});
+var RunApprovalResolvedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("approval-resolved"),
+  requestId: TrimmedNonEmptyString,
+  decision: ApprovalDecision,
+  note: Schema7.optional(Schema7.NullOr(Schema7.String)),
+  actor: RunActor
+});
+var RunInputRequestedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("input-requested"),
+  requestId: TrimmedNonEmptyString,
+  payload: Schema7.Unknown
+});
+var RunInputResolvedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("input-resolved"),
+  requestId: TrimmedNonEmptyString,
+  answers: Schema7.Record(Schema7.String, Schema7.String),
+  actor: RunActor
+});
+var RunSteeringEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("steering"),
+  actor: RunActor,
+  text: Schema7.String
+});
+var RunAdoptedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("adopted"),
+  pid: Schema7.NullOr(Schema7.Int),
+  serverPid: Schema7.Int
+});
+var RunStallDetectedEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("stall-detected"),
+  detail: Schema7.String
+});
+var RunCloseoutPhaseEvent = Schema7.Struct({
+  ...journalEnvelopeFields,
+  type: Schema7.Literal("closeout-phase"),
+  phase: RunCloseoutPhase,
+  outcome: RunCloseoutPhaseOutcome,
+  detail: Schema7.optional(Schema7.NullOr(Schema7.String))
+});
+var RunJournalEvent = Schema7.Union([
+  RunStatusChangedEvent,
+  RunRecordPatchEvent,
+  RunTimelineEntryEvent,
+  RunLogEntryEvent,
+  RunApprovalRequestedEvent,
+  RunApprovalResolvedEvent,
+  RunInputRequestedEvent,
+  RunInputResolvedEvent,
+  RunSteeringEvent,
+  RunAdoptedEvent,
+  RunStallDetectedEvent,
+  RunCloseoutPhaseEvent
+]);
+var decodeRunJournalEvent = Schema7.decodeUnknownSync(RunJournalEvent);
+var RUN_STATUS_TRANSITIONS = {
+  created: ["queued", "preparing", "running", "failed", "stopped"],
+  queued: ["preparing", "running", "failed", "stopped"],
+  preparing: ["queued", "running", "needs-attention", "failed", "stopped"],
+  running: [
+    "queued",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ],
+  "waiting-approval": ["running", "needs-attention", "failed", "stopped"],
+  "waiting-user-input": ["running", "needs-attention", "failed", "stopped"],
+  paused: ["running", "failed", "stopped"],
+  validating: ["running", "reviewing", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  reviewing: ["running", "validating", "closing-out", "needs-attention", "completed", "failed", "stopped"],
+  "closing-out": ["running", "needs-attention", "completed", "failed", "stopped"],
+  "needs-attention": ["queued", "preparing", "running", "closing-out", "completed", "failed", "stopped"],
+  completed: [],
+  failed: ["queued", "preparing", "running", "closing-out"],
+  stopped: ["queued", "preparing", "running", "closing-out"]
+};
+var TERMINAL_RUN_STATUSES = ["completed", "failed", "stopped"];
+var ACTIVE_RUN_STATUSES = Object.keys(RUN_STATUS_TRANSITIONS).filter((status) => !TERMINAL_RUN_STATUSES.includes(status));
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+function isActiveRunStatus(status) {
+  return !isTerminalRunStatus(status);
+}
+function canTransitionRunStatus(from, to) {
+  if (from === null)
+    return true;
+  if (from === to)
+    return true;
+  return RUN_STATUS_TRANSITIONS[from].includes(to);
+}
+function assertRunStatusTransition(from, to) {
+  if (!canTransitionRunStatus(from, to)) {
+    throw new Error(`Illegal run status transition: ${from ?? "(none)"} -> ${to}. ` + `Allowed from ${from ?? "(none)"}: ${from ? RUN_STATUS_TRANSITIONS[from].join(", ") : "(any)"}.`);
+  }
+}
+function reduceRunJournal(events) {
+  let record = {};
+  let status = null;
+  const statusHistory = [];
+  const pendingApprovals = new Map;
+  const resolvedApprovals = [];
+  const pendingUserInputs = new Map;
+  const resolvedUserInputs = [];
+  const closeoutPhases = [];
+  const anomalies = [];
+  let steeringCount = 0;
+  let stallCount = 0;
+  let lastSeq = 0;
+  let lastEventAt = null;
+  for (const event of events) {
+    lastSeq = event.seq;
+    lastEventAt = event.at;
+    switch (event.type) {
+      case "status-changed": {
+        if (!canTransitionRunStatus(status, event.to)) {
+          anomalies.push({
+            seq: event.seq,
+            kind: "illegal-transition",
+            detail: `${status ?? "(none)"} -> ${event.to}`
+          });
+        }
+        statusHistory.push({
+          seq: event.seq,
+          at: event.at,
+          from: status,
+          to: event.to,
+          reason: event.reason ?? null
+        });
+        const wasTerminal = status !== null && isTerminalRunStatus(status);
+        status = event.to;
+        record = { ...record, updatedAt: event.at };
+        if (isTerminalRunStatus(event.to) && !record.completedAt) {
+          record = { ...record, completedAt: event.at };
+        }
+        if (!isTerminalRunStatus(event.to) && wasTerminal) {
+          record = { ...record, completedAt: null };
+        }
+        if (event.to === "running" && !record.startedAt) {
+          record = { ...record, startedAt: event.at };
+        }
+        break;
+      }
+      case "record-patch": {
+        const next = { ...record };
+        for (const [key, value] of Object.entries(event.patch)) {
+          if (value !== undefined) {
+            next[key] = value;
+          }
+        }
+        next.updatedAt = event.patch.updatedAt ?? event.at;
+        record = next;
+        break;
+      }
+      case "approval-requested": {
+        pendingApprovals.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: event.requestKind,
+          actionId: event.actionId ?? null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "approval-resolved": {
+        const pending = pendingApprovals.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedApprovals.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({
+            seq: event.seq,
+            kind: alreadyResolved ? "duplicate-resolution" : "unknown-request",
+            detail: `approval ${event.requestId}`
+          });
+          break;
+        }
+        pendingApprovals.delete(event.requestId);
+        resolvedApprovals.push({
+          ...pending,
+          decision: event.decision,
+          note: event.note ?? null,
+          actor: event.actor,
+          resolvedAt: event.at
+        });
+        break;
+      }
+      case "input-requested": {
+        pendingUserInputs.set(event.requestId, {
+          requestId: event.requestId,
+          requestKind: "user-input",
+          actionId: null,
+          payload: event.payload,
+          requestedAt: event.at
+        });
+        break;
+      }
+      case "input-resolved": {
+        const pending = pendingUserInputs.get(event.requestId);
+        if (!pending) {
+          const alreadyResolved = resolvedUserInputs.some((entry) => entry.requestId === event.requestId);
+          anomalies.push({
+            seq: event.seq,
+            kind: alreadyResolved ? "duplicate-resolution" : "unknown-request",
+            detail: `user-input ${event.requestId}`
+          });
+          break;
+        }
+        pendingUserInputs.delete(event.requestId);
+        resolvedUserInputs.push({
+          ...pending,
+          answers: event.answers,
+          actor: event.actor,
+          resolvedAt: event.at
+        });
+        break;
+      }
+      case "steering": {
+        steeringCount += 1;
+        break;
+      }
+      case "adopted": {
+        record = { ...record, pid: event.pid, updatedAt: event.at };
+        break;
+      }
+      case "stall-detected": {
+        stallCount += 1;
+        break;
+      }
+      case "closeout-phase": {
+        closeoutPhases.push({
+          seq: event.seq,
+          at: event.at,
+          phase: event.phase,
+          outcome: event.outcome,
+          detail: event.detail ?? null
+        });
+        break;
+      }
+      case "timeline-entry":
+      case "log-entry":
+        break;
+    }
+  }
+  return {
+    record,
+    status,
+    statusHistory,
+    pendingApprovals: [...pendingApprovals.values()],
+    resolvedApprovals,
+    pendingUserInputs: [...pendingUserInputs.values()],
+    resolvedUserInputs,
+    steeringCount,
+    stallCount,
+    closeoutPhases,
+    lastSeq,
+    lastEventAt,
+    anomalies
+  };
+}
+// packages/contracts/src/conversation.ts
+import { Schema as Schema8 } from "effect";
+var EngineMessageRole = Schema8.Literals(["user", "assistant", "system"]);
+var EngineMessageState = Schema8.Literals([
   "streaming",
   "completed",
   "interrupted",
   "errored"
 ]);
-var ConversationSummary = Schema7.Struct({
+var ConversationSummary = Schema8.Struct({
   id: ConversationId,
   runId: RunId,
   title: TrimmedNonEmptyString,
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime
 });
-var EngineMessage = Schema7.Struct({
+var EngineMessage = Schema8.Struct({
   id: MessageId,
   conversationId: ConversationId,
   role: EngineMessageRole,
-  text: Schema7.String,
-  attachments: Schema7.Array(Schema7.Unknown),
+  text: Schema8.String,
+  attachments: Schema8.Array(Schema8.Unknown),
   state: EngineMessageState,
   createdAt: IsoDateTime,
-  completedAt: Schema7.NullOr(IsoDateTime)
+  completedAt: Schema8.NullOr(IsoDateTime)
 });
-var EngineAction = Schema7.Struct({
+var EngineAction = Schema8.Struct({
   id: ActionId,
   runId: RunId,
-  messageId: Schema7.NullOr(MessageId),
+  messageId: Schema8.NullOr(MessageId),
   actionType: TrimmedNonEmptyString,
   title: TrimmedNonEmptyString,
-  detail: Schema7.NullOr(Schema7.String),
+  detail: Schema8.NullOr(Schema8.String),
   state: TrimmedNonEmptyString,
-  payload: Schema7.Unknown,
+  payload: Schema8.Unknown,
   startedAt: IsoDateTime,
-  completedAt: Schema7.NullOr(IsoDateTime)
+  completedAt: Schema8.NullOr(IsoDateTime)
 });
-var EngineLogTone = Schema7.Literals(["thinking", "tool", "info", "error"]);
-var EngineRunLog = Schema7.Struct({
+var EngineLogTone = Schema8.Literals(["thinking", "tool", "info", "error"]);
+var EngineRunLog = Schema8.Struct({
   id: TrimmedNonEmptyString,
   runId: RunId,
   title: TrimmedNonEmptyString,
-  detail: Schema7.NullOr(Schema7.String),
+  detail: Schema8.NullOr(Schema8.String),
   tone: EngineLogTone,
-  status: Schema7.NullOr(TrimmedNonEmptyString),
-  payload: Schema7.Unknown,
+  status: Schema8.NullOr(TrimmedNonEmptyString),
+  payload: Schema8.Unknown,
   createdAt: IsoDateTime
 });
 // packages/contracts/src/plugin.ts
-import { Schema as Schema8 } from "effect";
-var ValidatorCategory = Schema8.Literals([
+import { Schema as Schema9 } from "effect";
+var ValidatorCategory = Schema9.Literals([
   "boundary",
   "contract",
   "integration",
@@ -1317,12 +1760,12 @@ var ValidatorCategory = Schema8.Literals([
   "external",
   "custom"
 ]);
-var ValidatorRegistration = Schema8.Struct({
-  id: Schema8.String,
+var ValidatorRegistration = Schema9.Struct({
+  id: Schema9.String,
   category: ValidatorCategory,
-  description: Schema8.optional(Schema8.String)
+  description: Schema9.optional(Schema9.String)
 });
-var HookEvent = Schema8.Literals([
+var HookEvent = Schema9.Literals([
   "PreToolUse",
   "PostToolUse",
   "UserPromptSubmit",
@@ -1330,254 +1773,280 @@ var HookEvent = Schema8.Literals([
   "SessionStart",
   "SessionEnd"
 ]);
-var HookMatcher = Schema8.Union([
-  Schema8.Struct({ kind: Schema8.Literal("all") }),
-  Schema8.Struct({ kind: Schema8.Literal("tool"), name: Schema8.String }),
-  Schema8.Struct({ kind: Schema8.Literal("glob"), pattern: Schema8.String })
+var HookMatcher = Schema9.Union([
+  Schema9.Struct({ kind: Schema9.Literal("all") }),
+  Schema9.Struct({ kind: Schema9.Literal("tool"), name: Schema9.String }),
+  Schema9.Struct({ kind: Schema9.Literal("glob"), pattern: Schema9.String })
 ]);
-var HookRegistration = Schema8.Struct({
-  id: Schema8.String,
+var HookRegistration = Schema9.Struct({
+  id: Schema9.String,
   event: HookEvent,
   matcher: HookMatcher,
-  command: Schema8.optional(Schema8.String),
-  description: Schema8.optional(Schema8.String)
-});
-var SkillRegistration = Schema8.Struct({
-  id: Schema8.String,
-  path: Schema8.String,
-  description: Schema8.optional(Schema8.String)
-});
-var RepoSourceRegistration = Schema8.Struct({
-  id: Schema8.String,
-  url: Schema8.String,
-  defaultPath: Schema8.optional(Schema8.String),
-  description: Schema8.optional(Schema8.String),
-  defaultBranch: Schema8.optional(Schema8.String),
-  remoteEnvVar: Schema8.optional(Schema8.String),
-  checkoutEnvVar: Schema8.optional(Schema8.String)
-});
-var AgentRoleRegistration = Schema8.Struct({
-  id: Schema8.String,
-  defaultModel: Schema8.optional(Schema8.String),
-  description: Schema8.optional(Schema8.String)
-});
-var TaskFieldExtension = Schema8.Struct({
-  id: Schema8.String,
-  fieldName: Schema8.String,
-  schemaJson: Schema8.String
-});
-var TaskSourceKind = Schema8.String;
-var TaskSourceRegistration = Schema8.Struct({
-  id: Schema8.String,
-  kind: Schema8.String,
-  description: Schema8.optional(Schema8.String)
-});
-var CliCommandRegistration = Schema8.Struct({
-  id: Schema8.String,
-  command: Schema8.String,
-  description: Schema8.optional(Schema8.String)
-});
-var PluginContributes = Schema8.Struct({
-  validators: Schema8.optional(Schema8.Array(ValidatorRegistration)),
-  hooks: Schema8.optional(Schema8.Array(HookRegistration)),
-  skills: Schema8.optional(Schema8.Array(SkillRegistration)),
-  repoSources: Schema8.optional(Schema8.Array(RepoSourceRegistration)),
-  agentRoles: Schema8.optional(Schema8.Array(AgentRoleRegistration)),
-  taskFieldSchemas: Schema8.optional(Schema8.Array(TaskFieldExtension)),
-  taskSources: Schema8.optional(Schema8.Array(TaskSourceRegistration)),
-  cliCommands: Schema8.optional(Schema8.Array(CliCommandRegistration))
-});
-var RigPlugin = Schema8.Struct({
-  name: Schema8.String,
-  version: Schema8.String,
-  contributes: Schema8.optional(PluginContributes)
+  command: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String)
+});
+var SkillRegistration = Schema9.Struct({
+  id: Schema9.String,
+  path: Schema9.String,
+  description: Schema9.optional(Schema9.String)
+});
+var RepoSourceRegistration = Schema9.Struct({
+  id: Schema9.String,
+  url: Schema9.String,
+  defaultPath: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String),
+  defaultBranch: Schema9.optional(Schema9.String),
+  remoteEnvVar: Schema9.optional(Schema9.String),
+  checkoutEnvVar: Schema9.optional(Schema9.String)
+});
+var AgentRoleRegistration = Schema9.Struct({
+  id: Schema9.String,
+  defaultModel: Schema9.optional(Schema9.String),
+  description: Schema9.optional(Schema9.String)
+});
+var TaskFieldExtension = Schema9.Struct({
+  id: Schema9.String,
+  fieldName: Schema9.String,
+  schemaJson: Schema9.String
+});
+var TaskSourceKind = Schema9.String;
+var TaskSourceRegistration = Schema9.Struct({
+  id: Schema9.String,
+  kind: Schema9.String,
+  description: Schema9.optional(Schema9.String)
+});
+var CliCommandRegistration = Schema9.Struct({
+  id: Schema9.String,
+  command: Schema9.String,
+  description: Schema9.optional(Schema9.String)
+});
+var PluginContributes = Schema9.Struct({
+  validators: Schema9.optional(Schema9.Array(ValidatorRegistration)),
+  hooks: Schema9.optional(Schema9.Array(HookRegistration)),
+  skills: Schema9.optional(Schema9.Array(SkillRegistration)),
+  repoSources: Schema9.optional(Schema9.Array(RepoSourceRegistration)),
+  agentRoles: Schema9.optional(Schema9.Array(AgentRoleRegistration)),
+  taskFieldSchemas: Schema9.optional(Schema9.Array(TaskFieldExtension)),
+  taskSources: Schema9.optional(Schema9.Array(TaskSourceRegistration)),
+  cliCommands: Schema9.optional(Schema9.Array(CliCommandRegistration))
+});
+var RigPlugin = Schema9.Struct({
+  name: Schema9.String,
+  version: Schema9.String,
+  contributes: Schema9.optional(PluginContributes)
+});
+// packages/contracts/src/plugin-hooks.ts
+import { Schema as Schema10 } from "effect";
+var HookToolInput = Schema10.Record(Schema10.String, Schema10.Unknown);
+var HookContext = Schema10.Struct({
+  event: HookEvent,
+  toolName: Schema10.optional(Schema10.String),
+  toolInput: HookToolInput,
+  filePaths: Schema10.Array(Schema10.String),
+  projectRoot: Schema10.String,
+  taskId: Schema10.String
+});
+var HookDecision = Schema10.Literals(["allow", "block"]);
+var HookResult = Schema10.Struct({
+  decision: HookDecision,
+  reason: Schema10.optional(Schema10.String),
+  systemMessage: Schema10.optional(Schema10.String)
 });
 // packages/contracts/src/config.ts
-import { Schema as Schema9 } from "effect";
-var WorkspaceIsolation = Schema9.Literals([
+import { Schema as Schema11 } from "effect";
+var WorkspaceIsolation = Schema11.Literals([
   "worktree",
   "directory"
 ]);
-var ScopeSearchPrefix = Schema9.Struct({
-  prefix: Schema9.String,
-  matchStartsWith: Schema9.optional(Schema9.Array(Schema9.String)),
-  matchExact: Schema9.optional(Schema9.Array(Schema9.String))
-});
-var ScopeNormalizationRules = Schema9.Struct({
-  stripPrefixes: Schema9.optional(Schema9.Array(Schema9.String)),
-  searchPrefixes: Schema9.optional(Schema9.Array(ScopeSearchPrefix))
-});
-var WorkspaceConfig = Schema9.Struct({
-  mainRepo: Schema9.String,
-  isolation: WorkspaceIsolation,
-  scopeNormalization: Schema9.optional(ScopeNormalizationRules)
-});
-var TaskSourceConfig = Schema9.Struct({
-  kind: Schema9.String,
-  path: Schema9.optional(Schema9.String),
-  owner: Schema9.optional(Schema9.String),
-  repo: Schema9.optional(Schema9.String),
-  labels: Schema9.optional(Schema9.Array(Schema9.String)),
-  state: Schema9.optional(Schema9.Literals(["open", "closed", "all"])),
-  url: Schema9.optional(Schema9.String),
-  options: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Unknown))
-});
-var RuntimeHarness = Schema9.Literals(["pi", "claude-code", "codex"]);
-var RigRuntimeMode = Schema9.Literals(["yolo", "approval-required"]);
-var RuntimeConfig = Schema9.Struct({
-  agentRoles: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Unknown)),
-  timeouts: Schema9.optional(Schema9.Record(Schema9.String, Schema9.Number)),
-  harness: Schema9.optional(RuntimeHarness),
-  model: Schema9.optional(Schema9.String),
-  mode: Schema9.optional(RigRuntimeMode)
-});
-var ProjectIdentity = Schema9.Struct({
-  name: Schema9.String,
-  repo: Schema9.optional(Schema9.String)
-});
-var PlanningConfig = Schema9.Struct({
-  mode: Schema9.optional(Schema9.Literals(["auto", "always", "off"])),
-  requireForLabels: Schema9.optional(Schema9.Array(Schema9.String)),
-  skipForLabels: Schema9.optional(Schema9.Array(Schema9.String))
-});
-var GitHubProjectStatusConfig = Schema9.Struct({
-  enabled: Schema9.optional(Schema9.Boolean),
-  projectId: Schema9.optional(Schema9.String),
-  statusFieldId: Schema9.optional(Schema9.String),
-  statuses: Schema9.optional(Schema9.Struct({
-    running: Schema9.optional(Schema9.String),
-    prOpen: Schema9.optional(Schema9.String),
-    ciFixing: Schema9.optional(Schema9.String),
-    done: Schema9.optional(Schema9.String),
-    needsAttention: Schema9.optional(Schema9.String)
+var WorkspaceCheckout = WorkspaceIsolation;
+var WorkspaceSandbox = Schema11.Literals(["enforce", "auto", "off"]);
+var ScopeSearchPrefix = Schema11.Struct({
+  prefix: Schema11.String,
+  matchStartsWith: Schema11.optional(Schema11.Array(Schema11.String)),
+  matchExact: Schema11.optional(Schema11.Array(Schema11.String))
+});
+var ScopeNormalizationRules = Schema11.Struct({
+  stripPrefixes: Schema11.optional(Schema11.Array(Schema11.String)),
+  searchPrefixes: Schema11.optional(Schema11.Array(ScopeSearchPrefix))
+});
+var WorkspaceConfig = Schema11.Struct({
+  mainRepo: Schema11.String,
+  checkout: Schema11.optional(WorkspaceCheckout),
+  isolation: Schema11.optional(WorkspaceIsolation),
+  sandbox: Schema11.optional(WorkspaceSandbox),
+  scopeNormalization: Schema11.optional(ScopeNormalizationRules)
+});
+var TaskSourceConfig = Schema11.Struct({
+  kind: Schema11.String,
+  path: Schema11.optional(Schema11.String),
+  owner: Schema11.optional(Schema11.String),
+  repo: Schema11.optional(Schema11.String),
+  labels: Schema11.optional(Schema11.Array(Schema11.String)),
+  state: Schema11.optional(Schema11.Literals(["open", "closed", "all"])),
+  url: Schema11.optional(Schema11.String),
+  options: Schema11.optional(Schema11.Record(Schema11.String, Schema11.Unknown))
+});
+var RuntimeHarness = Schema11.Literals(["pi", "claude-code", "codex"]);
+var RigRuntimeMode = Schema11.Literals(["yolo", "approval-required"]);
+var PiRuntimeConfig = Schema11.Struct({
+  packages: Schema11.optional(Schema11.Array(Schema11.String))
+});
+var RuntimeConfig = Schema11.Struct({
+  agentRoles: Schema11.optional(Schema11.Record(Schema11.String, Schema11.Unknown)),
+  timeouts: Schema11.optional(Schema11.Record(Schema11.String, Schema11.Number)),
+  harness: Schema11.optional(RuntimeHarness),
+  model: Schema11.optional(Schema11.String),
+  mode: Schema11.optional(RigRuntimeMode),
+  pi: Schema11.optional(PiRuntimeConfig)
+});
+var ProjectIdentity = Schema11.Struct({
+  name: Schema11.String,
+  repo: Schema11.optional(Schema11.String)
+});
+var PlanningConfig = Schema11.Struct({
+  mode: Schema11.optional(Schema11.Literals(["auto", "always", "off"])),
+  requireForLabels: Schema11.optional(Schema11.Array(Schema11.String)),
+  skipForLabels: Schema11.optional(Schema11.Array(Schema11.String))
+});
+var GitHubProjectStatusConfig = Schema11.Struct({
+  enabled: Schema11.optional(Schema11.Boolean),
+  projectId: Schema11.optional(Schema11.String),
+  statusFieldId: Schema11.optional(Schema11.String),
+  statuses: Schema11.optional(Schema11.Struct({
+    running: Schema11.optional(Schema11.String),
+    prOpen: Schema11.optional(Schema11.String),
+    ciFixing: Schema11.optional(Schema11.String),
+    merging: Schema11.optional(Schema11.String),
+    done: Schema11.optional(Schema11.String),
+    needsAttention: Schema11.optional(Schema11.String)
   }))
 });
-var GitHubConfig = Schema9.Struct({
-  issueUpdates: Schema9.optional(Schema9.Literals(["lifecycle", "minimal", "off"])),
-  projects: Schema9.optional(GitHubProjectStatusConfig)
-});
-var AutomationConfig = Schema9.Struct({
-  maxValidationAttempts: Schema9.optional(Schema9.Number),
-  maxPrFixIterations: Schema9.optional(Schema9.Number)
-});
-var PullRequestConfig = Schema9.Struct({
-  mode: Schema9.optional(Schema9.Literals(["auto", "ask", "off"])),
-  watchChecks: Schema9.optional(Schema9.Boolean),
-  autoFixChecks: Schema9.optional(Schema9.Boolean),
-  autoFixReview: Schema9.optional(Schema9.Boolean),
-  pendingTimeoutMs: Schema9.optional(Schema9.Number),
-  pendingPollMs: Schema9.optional(Schema9.Number)
-});
-var MergeConfig = Schema9.Struct({
-  mode: Schema9.optional(Schema9.Literals(["auto", "off", "pr-ready"])),
-  method: Schema9.optional(Schema9.Literals(["repo-default", "squash", "merge", "rebase"])),
-  deleteBranch: Schema9.optional(Schema9.Union([Schema9.Literal("repo-default"), Schema9.Boolean])),
-  allowedFailures: Schema9.optional(Schema9.Array(Schema9.String)),
-  bypass: Schema9.optional(Schema9.Boolean)
-});
-var IssueAnalysisConfig = Schema9.Struct({
-  enabled: Schema9.optional(Schema9.Boolean),
-  harness: Schema9.optional(Schema9.Literal("pi")),
-  model: Schema9.optional(Schema9.String),
-  mode: Schema9.optional(Schema9.Literals(["continuous", "off"]))
-});
-var ReviewConfig = Schema9.Struct({
-  mode: Schema9.optional(Schema9.Literals(["off", "advisory", "required"])),
-  provider: Schema9.optional(Schema9.Literal("greptile"))
-});
-var RigConfig = Schema9.Struct({
+var GitHubConfig = Schema11.Struct({
+  issueUpdates: Schema11.optional(Schema11.Literals(["lifecycle", "minimal", "off"])),
+  projects: Schema11.optional(GitHubProjectStatusConfig)
+});
+var AutomationConfig = Schema11.Struct({
+  maxValidationAttempts: Schema11.optional(Schema11.Number),
+  maxPrFixIterations: Schema11.optional(Schema11.Number)
+});
+var PullRequestConfig = Schema11.Struct({
+  mode: Schema11.optional(Schema11.Literals(["auto", "ask", "off"])),
+  watchChecks: Schema11.optional(Schema11.Boolean),
+  autoFixChecks: Schema11.optional(Schema11.Boolean),
+  autoFixReview: Schema11.optional(Schema11.Boolean),
+  pendingTimeoutMs: Schema11.optional(Schema11.Number),
+  pendingPollMs: Schema11.optional(Schema11.Number)
+});
+var MergeConfig = Schema11.Struct({
+  mode: Schema11.optional(Schema11.Literals(["auto", "off", "pr-ready"])),
+  method: Schema11.optional(Schema11.Literals(["repo-default", "squash", "merge", "rebase"])),
+  deleteBranch: Schema11.optional(Schema11.Union([Schema11.Literal("repo-default"), Schema11.Boolean])),
+  allowedFailures: Schema11.optional(Schema11.Array(Schema11.String)),
+  bypass: Schema11.optional(Schema11.Boolean)
+});
+var IssueAnalysisConfig = Schema11.Struct({
+  enabled: Schema11.optional(Schema11.Boolean),
+  harness: Schema11.optional(Schema11.Literal("pi")),
+  model: Schema11.optional(Schema11.String),
+  mode: Schema11.optional(Schema11.Literals(["continuous", "off"]))
+});
+var ReviewConfig = Schema11.Struct({
+  mode: Schema11.optional(Schema11.Literals(["off", "advisory", "required"])),
+  provider: Schema11.optional(Schema11.Literal("greptile"))
+});
+var RigConfig = Schema11.Struct({
   project: ProjectIdentity,
-  plugins: Schema9.Array(RigPlugin),
+  plugins: Schema11.Array(RigPlugin),
   taskSource: TaskSourceConfig,
   workspace: WorkspaceConfig,
-  runtime: Schema9.optional(RuntimeConfig),
-  planning: Schema9.optional(PlanningConfig),
-  github: Schema9.optional(GitHubConfig),
-  automation: Schema9.optional(AutomationConfig),
-  pr: Schema9.optional(PullRequestConfig),
-  merge: Schema9.optional(MergeConfig),
-  review: Schema9.optional(ReviewConfig),
-  issueAnalysis: Schema9.optional(IssueAnalysisConfig)
+  runtime: Schema11.optional(RuntimeConfig),
+  planning: Schema11.optional(PlanningConfig),
+  github: Schema11.optional(GitHubConfig),
+  automation: Schema11.optional(AutomationConfig),
+  pr: Schema11.optional(PullRequestConfig),
+  merge: Schema11.optional(MergeConfig),
+  review: Schema11.optional(ReviewConfig),
+  issueAnalysis: Schema11.optional(IssueAnalysisConfig)
 });
 // packages/contracts/src/policy.ts
-import { Schema as Schema10 } from "effect";
-var PolicyDecision = Schema10.Literals(["allow", "warn", "block"]);
-var PolicyMode = Schema10.Literals(["off", "observe", "enforce"]);
-var PolicyDecisionSummary = Schema10.Struct({
+import { Schema as Schema12 } from "effect";
+var PolicyDecision = Schema12.Literals(["allow", "warn", "block"]);
+var PolicyMode = Schema12.Literals(["off", "observe", "enforce"]);
+var PolicyDecisionSummary = Schema12.Struct({
   id: TrimmedNonEmptyString,
   runId: RunId,
-  actionId: Schema10.NullOr(ActionId),
+  actionId: Schema12.NullOr(ActionId),
   decision: PolicyDecision,
   mode: PolicyMode,
-  matchedRules: Schema10.Array(TrimmedNonEmptyString),
-  reason: Schema10.String,
+  matchedRules: Schema12.Array(TrimmedNonEmptyString),
+  reason: Schema12.String,
   createdAt: IsoDateTime
 });
 // packages/contracts/src/validation.ts
-import { Schema as Schema11 } from "effect";
-var ValidationStatus = Schema11.Literals([
+import { Schema as Schema13 } from "effect";
+var ValidationStatus = Schema13.Literals([
   "pending",
   "running",
   "passed",
   "failed",
   "skipped"
 ]);
-var ValidationSummary = Schema11.Struct({
+var ValidationSummary = Schema13.Struct({
   id: ValidationResultId,
   runId: RunId,
-  taskId: Schema11.NullOr(TaskId),
+  taskId: Schema13.NullOr(TaskId),
   validatorKey: TrimmedNonEmptyString,
   status: ValidationStatus,
-  output: Schema11.Unknown,
+  output: Schema13.Unknown,
   startedAt: IsoDateTime,
-  completedAt: Schema11.NullOr(IsoDateTime)
+  completedAt: Schema13.NullOr(IsoDateTime)
 });
 // packages/contracts/src/review.ts
-import { Schema as Schema12 } from "effect";
-var ReviewMode = Schema12.Literals(["off", "advisory", "required"]);
-var ReviewStatus = Schema12.Literals(["pending", "running", "approved", "rejected", "error"]);
-var ReviewSummary = Schema12.Struct({
+import { Schema as Schema14 } from "effect";
+var ReviewMode = Schema14.Literals(["off", "advisory", "required"]);
+var ReviewStatus = Schema14.Literals(["pending", "running", "approved", "rejected", "error"]);
+var ReviewSummary = Schema14.Struct({
   id: ReviewResultId,
   runId: RunId,
-  taskId: Schema12.NullOr(TaskId),
+  taskId: Schema14.NullOr(TaskId),
   provider: TrimmedNonEmptyString,
   mode: ReviewMode,
   status: ReviewStatus,
-  summary: Schema12.NullOr(Schema12.String),
-  output: Schema12.Unknown,
+  summary: Schema14.NullOr(Schema14.String),
+  output: Schema14.Unknown,
   createdAt: IsoDateTime,
-  completedAt: Schema12.NullOr(IsoDateTime)
+  completedAt: Schema14.NullOr(IsoDateTime)
 });
 // packages/contracts/src/artifact.ts
-import { Schema as Schema13 } from "effect";
-var ArtifactSummary = Schema13.Struct({
+import { Schema as Schema15 } from "effect";
+var ArtifactSummary = Schema15.Struct({
   id: ArtifactId,
   runId: RunId,
-  taskId: Schema13.NullOr(TaskId),
+  taskId: Schema15.NullOr(TaskId),
   kind: TrimmedNonEmptyString,
   label: TrimmedNonEmptyString,
-  path: Schema13.NullOr(TrimmedNonEmptyString),
-  url: Schema13.NullOr(TrimmedNonEmptyString),
-  metadata: Schema13.Record(Schema13.String, Schema13.Unknown),
+  path: Schema15.NullOr(TrimmedNonEmptyString),
+  url: Schema15.NullOr(TrimmedNonEmptyString),
+  metadata: Schema15.Record(Schema15.String, Schema15.Unknown),
   createdAt: IsoDateTime
 });
 // packages/contracts/src/engine.ts
-import { Schema as Schema15 } from "effect";
+import { Schema as Schema17 } from "effect";
 
 // packages/contracts/src/remote.ts
-import { Schema as Schema14 } from "effect";
-var RemoteEndpoint = Schema14.Struct({
+import { Schema as Schema16 } from "effect";
+var RemoteEndpoint = Schema16.Struct({
   id: RemoteEndpointId,
   alias: TrimmedNonEmptyString,
   host: TrimmedNonEmptyString,
-  port: Schema14.Int.check(Schema14.isGreaterThanOrEqualTo(1)).check(Schema14.isLessThanOrEqualTo(65535)),
-  token: Schema14.String,
-  tokenConfigured: Schema14.optional(Schema14.Boolean),
-  autoConnect: Schema14.optional(Schema14.Boolean),
+  port: Schema16.Int.check(Schema16.isGreaterThanOrEqualTo(1)).check(Schema16.isLessThanOrEqualTo(65535)),
+  token: Schema16.String,
+  tokenConfigured: Schema16.optional(Schema16.Boolean),
+  autoConnect: Schema16.optional(Schema16.Boolean),
   addedAt: IsoDateTime,
-  lastConnectedAt: Schema14.NullOr(IsoDateTime)
+  lastConnectedAt: Schema16.NullOr(IsoDateTime)
 });
-var RemoteConnectionStatus = Schema14.Literals([
+var RemoteConnectionStatus = Schema16.Literals([
   "disconnected",
   "connecting",
   "authenticating",
@@ -1585,157 +2054,157 @@ var RemoteConnectionStatus = Schema14.Literals([
   "reconnecting",
   "error"
 ]);
-var RemoteConnectionSummary = Schema14.Struct({
+var RemoteConnectionSummary = Schema16.Struct({
   endpointId: RemoteEndpointId,
   status: RemoteConnectionStatus,
-  error: Schema14.NullOr(Schema14.String),
-  connectedAt: Schema14.NullOr(IsoDateTime),
-  tokenExpiresAt: Schema14.NullOr(IsoDateTime),
-  latencyMs: Schema14.NullOr(Schema14.Number),
-  subscribedEvents: Schema14.Array(Schema14.String)
-});
-var RemoteConnectionStatusChanged = Schema14.Struct({
-  endpointId: Schema14.String,
-  endpointAlias: Schema14.String,
+  error: Schema16.NullOr(Schema16.String),
+  connectedAt: Schema16.NullOr(IsoDateTime),
+  tokenExpiresAt: Schema16.NullOr(IsoDateTime),
+  latencyMs: Schema16.NullOr(Schema16.Number),
+  subscribedEvents: Schema16.Array(Schema16.String)
+});
+var RemoteConnectionStatusChanged = Schema16.Struct({
+  endpointId: Schema16.String,
+  endpointAlias: Schema16.String,
   status: RemoteConnectionStatus,
   previousStatus: RemoteConnectionStatus,
-  error: Schema14.NullOr(Schema14.String),
-  connectedAt: Schema14.NullOr(Schema14.String),
-  latencyMs: Schema14.NullOr(Schema14.Number),
-  timestamp: Schema14.String
-});
-var EnrichedRemoteEvent = Schema14.Struct({
-  endpointId: Schema14.String,
-  endpointAlias: Schema14.String,
-  receivedAt: Schema14.String,
-  originalTimestamp: Schema14.optional(Schema14.NullOr(Schema14.String)),
-  event: Schema14.Unknown
-});
-var RemoteOrchestratorState = Schema14.Struct({
-  activeTaskId: Schema14.NullOr(Schema14.String),
-  activeIteration: Schema14.NullOr(Schema14.Number),
-  maxIterations: Schema14.Number,
-  isPaused: Schema14.Boolean,
-  isRunning: Schema14.Boolean,
+  error: Schema16.NullOr(Schema16.String),
+  connectedAt: Schema16.NullOr(Schema16.String),
+  latencyMs: Schema16.NullOr(Schema16.Number),
+  timestamp: Schema16.String
+});
+var EnrichedRemoteEvent = Schema16.Struct({
+  endpointId: Schema16.String,
+  endpointAlias: Schema16.String,
+  receivedAt: Schema16.String,
+  originalTimestamp: Schema16.optional(Schema16.NullOr(Schema16.String)),
+  event: Schema16.Unknown
+});
+var RemoteOrchestratorState = Schema16.Struct({
+  activeTaskId: Schema16.NullOr(Schema16.String),
+  activeIteration: Schema16.NullOr(Schema16.Number),
+  maxIterations: Schema16.Number,
+  isPaused: Schema16.Boolean,
+  isRunning: Schema16.Boolean,
   totalCompleted: NonNegativeInt,
   totalFailed: NonNegativeInt,
-  lastActivity: Schema14.NullOr(IsoDateTime)
+  lastActivity: Schema16.NullOr(IsoDateTime)
 });
-var RemoteOrchestrationSummary = Schema14.Struct({
+var RemoteOrchestrationSummary = Schema16.Struct({
   orchestrationId: TrimmedNonEmptyString,
   endpointId: RemoteEndpointId,
-  status: Schema14.Literals(["running", "paused", "stopped", "completed"]),
+  status: Schema16.Literals(["running", "paused", "stopped", "completed"]),
   totalTasks: NonNegativeInt,
   totalGroups: NonNegativeInt,
   maxParallelism: NonNegativeInt,
   startedAt: IsoDateTime
 });
-var RemoteIterationOutput = Schema14.Struct({
-  taskId: Schema14.optional(Schema14.String),
-  iteration: Schema14.optional(Schema14.Number),
-  output: Schema14.optional(Schema14.String),
-  startedAt: Schema14.optional(IsoDateTime),
-  endedAt: Schema14.optional(IsoDateTime),
-  durationMs: Schema14.optional(Schema14.Number),
-  isRunning: Schema14.optional(Schema14.Boolean)
+var RemoteIterationOutput = Schema16.Struct({
+  taskId: Schema16.optional(Schema16.String),
+  iteration: Schema16.optional(Schema16.Number),
+  output: Schema16.optional(Schema16.String),
+  startedAt: Schema16.optional(IsoDateTime),
+  endedAt: Schema16.optional(IsoDateTime),
+  durationMs: Schema16.optional(Schema16.Number),
+  isRunning: Schema16.optional(Schema16.Boolean)
 });
-var RemoteRunnerRegisterInput = Schema14.Struct({
+var RemoteRunnerRegisterInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   name: TrimmedNonEmptyString,
   baseUrl: TrimmedNonEmptyString,
-  workspacePath: Schema14.optional(TrimmedNonEmptyString),
-  transport: Schema14.optional(TrimmedNonEmptyString),
-  hostname: Schema14.optional(TrimmedNonEmptyString),
-  region: Schema14.optional(TrimmedNonEmptyString),
-  labels: Schema14.optional(Schema14.Array(TrimmedNonEmptyString)),
-  capabilities: Schema14.optional(Schema14.Array(TrimmedNonEmptyString)),
-  runtimeAdapters: Schema14.optional(Schema14.Array(TrimmedNonEmptyString)),
-  status: Schema14.optional(WorkspaceRemoteHostStatus),
-  currentLeaseCount: Schema14.optional(Schema14.Number)
-});
-var RemoteRunnerHeartbeatInput = Schema14.Struct({
+  workspacePath: Schema16.optional(TrimmedNonEmptyString),
+  transport: Schema16.optional(TrimmedNonEmptyString),
+  hostname: Schema16.optional(TrimmedNonEmptyString),
+  region: Schema16.optional(TrimmedNonEmptyString),
+  labels: Schema16.optional(Schema16.Array(TrimmedNonEmptyString)),
+  capabilities: Schema16.optional(Schema16.Array(TrimmedNonEmptyString)),
+  runtimeAdapters: Schema16.optional(Schema16.Array(TrimmedNonEmptyString)),
+  status: Schema16.optional(WorkspaceRemoteHostStatus),
+  currentLeaseCount: Schema16.optional(Schema16.Number)
+});
+var RemoteRunnerHeartbeatInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   status: WorkspaceRemoteHostStatus,
-  currentLeaseCount: Schema14.optional(Schema14.Number),
-  observedAt: Schema14.optional(IsoDateTime)
+  currentLeaseCount: Schema16.optional(Schema16.Number),
+  observedAt: Schema16.optional(IsoDateTime)
 });
-var RemoteRunnerLifecycleResult = Schema14.Struct({
-  ok: Schema14.Boolean,
+var RemoteRunnerLifecycleResult = Schema16.Struct({
+  ok: Schema16.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime,
-  heartbeatIntervalMs: Schema14.Number
+  heartbeatIntervalMs: Schema16.Number
 });
-var RemoteRunClaimInput = Schema14.Struct({
+var RemoteRunClaimInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
-  runtimeAdapters: Schema14.optional(Schema14.Array(TrimmedNonEmptyString))
+  runtimeAdapters: Schema16.optional(Schema16.Array(TrimmedNonEmptyString))
 });
-var RemoteRunLeaseSummary = Schema14.Struct({
+var RemoteRunLeaseSummary = Schema16.Struct({
   leaseId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   workspaceId: WorkspaceId,
   title: TrimmedNonEmptyString,
   runtimeAdapter: TrimmedNonEmptyString,
-  model: Schema14.NullOr(TrimmedNonEmptyString),
+  model: Schema16.NullOr(TrimmedNonEmptyString),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
   executionTarget: RunExecutionTarget,
-  remoteHostId: Schema14.NullOr(TrimmedNonEmptyString),
+  remoteHostId: Schema16.NullOr(TrimmedNonEmptyString),
   claimedAt: IsoDateTime
 });
-var RemoteRunConversationEntry = Schema14.Struct({
-  role: Schema14.Literals(["user", "assistant", "system"]),
-  text: Schema14.String,
+var RemoteRunConversationEntry = Schema16.Struct({
+  role: Schema16.Literals(["user", "assistant", "system"]),
+  text: Schema16.String,
   createdAt: IsoDateTime
 });
-var RemoteRunExecutionBundle = Schema14.Struct({
+var RemoteRunExecutionBundle = Schema16.Struct({
   workspaceId: WorkspaceId,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  workspacePath: Schema14.NullOr(TrimmedNonEmptyString),
+  workspacePath: Schema16.NullOr(TrimmedNonEmptyString),
   runtimeAdapter: TrimmedNonEmptyString,
-  model: Schema14.NullOr(TrimmedNonEmptyString),
+  model: Schema16.NullOr(TrimmedNonEmptyString),
   runtimeMode: RuntimeMode,
   interactionMode: ProviderInteractionMode,
-  prompt: Schema14.String,
-  conversation: Schema14.Array(RemoteRunConversationEntry),
-  taskId: Schema14.NullOr(TrimmedNonEmptyString),
-  taskTitle: Schema14.NullOr(TrimmedNonEmptyString)
+  prompt: Schema16.String,
+  conversation: Schema16.Array(RemoteRunConversationEntry),
+  taskId: Schema16.NullOr(TrimmedNonEmptyString),
+  taskTitle: Schema16.NullOr(TrimmedNonEmptyString)
 });
-var RemoteRunClaimResult = Schema14.Struct({
-  ok: Schema14.Boolean,
+var RemoteRunClaimResult = Schema16.Struct({
+  ok: Schema16.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime,
-  lease: Schema14.NullOr(RemoteRunLeaseSummary),
-  bundle: Schema14.NullOr(RemoteRunExecutionBundle)
+  lease: Schema16.NullOr(RemoteRunLeaseSummary),
+  bundle: Schema16.NullOr(RemoteRunExecutionBundle)
 });
-var RemoteRunReleaseInput = Schema14.Struct({
+var RemoteRunReleaseInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  status: Schema14.optional(WorkspaceRemoteHostStatus)
+  status: Schema16.optional(WorkspaceRemoteHostStatus)
 });
-var RemoteRunReleaseResult = Schema14.Struct({
-  ok: Schema14.Boolean,
+var RemoteRunReleaseResult = Schema16.Struct({
+  ok: Schema16.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime
 });
-var RemoteRunStartInput = Schema14.Struct({
+var RemoteRunStartInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString
 });
-var RemoteRunStartResult = Schema14.Struct({
-  ok: Schema14.Boolean,
+var RemoteRunStartResult = Schema16.Struct({
+  ok: Schema16.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
@@ -1743,48 +2212,48 @@ var RemoteRunStartResult = Schema14.Struct({
   runtimeId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime
 });
-var RemoteRunLogInput = Schema14.Struct({
+var RemoteRunLogInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   title: TrimmedNonEmptyString,
-  detail: Schema14.optional(Schema14.String),
-  tone: Schema14.optional(EngineLogTone),
-  status: Schema14.optional(TrimmedNonEmptyString),
-  payload: Schema14.optional(Schema14.Unknown)
+  detail: Schema16.optional(Schema16.String),
+  tone: Schema16.optional(EngineLogTone),
+  status: Schema16.optional(TrimmedNonEmptyString),
+  payload: Schema16.optional(Schema16.Unknown)
 });
-var RemoteRunMessageInput = Schema14.Struct({
+var RemoteRunMessageInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  messageId: Schema14.optional(TrimmedNonEmptyString),
-  text: Schema14.String,
-  state: Schema14.optional(Schema14.Literals(["streaming", "completed"]))
+  messageId: Schema16.optional(TrimmedNonEmptyString),
+  text: Schema16.String,
+  state: Schema16.optional(Schema16.Literals(["streaming", "completed"]))
 });
-var RemoteRunMutationResult = Schema14.Struct({
-  ok: Schema14.Boolean,
+var RemoteRunMutationResult = Schema16.Struct({
+  ok: Schema16.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   acceptedAt: IsoDateTime
 });
-var RemoteRunCompleteInput = Schema14.Struct({
+var RemoteRunCompleteInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString
 });
-var RemoteRunFailInput = Schema14.Struct({
+var RemoteRunFailInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
-  errorText: Schema14.optional(Schema14.String)
+  errorText: Schema16.optional(Schema16.String)
 });
-var RemoteRunArtifactInput = Schema14.Struct({
+var RemoteRunArtifactInput = Schema16.Struct({
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
@@ -1795,8 +2264,8 @@ var RemoteRunArtifactInput = Schema14.Struct({
   contentType: TrimmedNonEmptyString,
   contentBase64: TrimmedNonEmptyString
 });
-var RemoteRunArtifactResult = Schema14.Struct({
-  ok: Schema14.Boolean,
+var RemoteRunArtifactResult = Schema16.Struct({
+  ok: Schema16.Boolean,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
@@ -1804,7 +2273,7 @@ var RemoteRunArtifactResult = Schema14.Struct({
   acceptedAt: IsoDateTime,
   artifactPath: TrimmedNonEmptyString
 });
-var RemoteRunArtifactSummary = Schema14.Struct({
+var RemoteRunArtifactSummary = Schema16.Struct({
   workspaceId: WorkspaceId,
   runId: TrimmedNonEmptyString,
   hostId: TrimmedNonEmptyString,
@@ -1814,244 +2283,244 @@ var RemoteRunArtifactSummary = Schema14.Struct({
   filename: TrimmedNonEmptyString,
   contentType: TrimmedNonEmptyString,
   uploadedAt: IsoDateTime,
-  byteSize: Schema14.Number,
+  byteSize: Schema16.Number,
   artifactPath: TrimmedNonEmptyString,
   downloadPath: TrimmedNonEmptyString
 });
-var RemoteRunArtifactsResult = Schema14.Struct({
+var RemoteRunArtifactsResult = Schema16.Struct({
   workspaceId: WorkspaceId,
   runId: TrimmedNonEmptyString,
-  artifacts: Schema14.Array(RemoteRunArtifactSummary)
+  artifacts: Schema16.Array(RemoteRunArtifactSummary)
 });
 
 // packages/contracts/src/engine.ts
-var EngineEvent = Schema15.Struct({
+var EngineEvent = Schema17.Struct({
   id: EventId,
   sequence: NonNegativeInt,
   createdAt: IsoDateTime,
   type: TrimmedNonEmptyString,
   aggregateId: TrimmedNonEmptyString,
-  payload: Schema15.Unknown
+  payload: Schema17.Unknown
 });
-var EngineReadModel = Schema15.Struct({
+var EngineReadModel = Schema17.Struct({
   snapshotSequence: NonNegativeInt,
-  workspaces: Schema15.Array(WorkspaceSummary),
-  graphs: Schema15.Array(GraphSummary),
-  tasks: Schema15.Array(TaskSummary),
-  runs: Schema15.Array(RunSummary),
-  runtimes: Schema15.Array(RuntimeSummary),
-  conversations: Schema15.Array(ConversationSummary),
-  messages: Schema15.Array(EngineMessage),
-  actions: Schema15.Array(EngineAction),
-  logs: Schema15.Array(EngineRunLog),
-  approvals: Schema15.Array(ApprovalSummary),
-  userInputs: Schema15.optional(Schema15.Array(UserInputRequestSummary)),
-  validations: Schema15.Array(ValidationSummary),
-  reviews: Schema15.Array(ReviewSummary),
-  artifacts: Schema15.Array(ArtifactSummary),
-  policyDecisions: Schema15.Array(PolicyDecisionSummary),
-  queue: Schema15.Array(QueueEntry),
-  worktrees: Schema15.Array(WorktreeSummary),
-  remoteEndpoints: Schema15.Array(RemoteEndpoint),
-  remoteConnections: Schema15.Array(RemoteConnectionSummary),
-  remoteOrchestrations: Schema15.Array(RemoteOrchestrationSummary),
+  workspaces: Schema17.Array(WorkspaceSummary),
+  graphs: Schema17.Array(GraphSummary),
+  tasks: Schema17.Array(TaskSummary),
+  runs: Schema17.Array(RunSummary),
+  runtimes: Schema17.Array(RuntimeSummary),
+  conversations: Schema17.Array(ConversationSummary),
+  messages: Schema17.Array(EngineMessage),
+  actions: Schema17.Array(EngineAction),
+  logs: Schema17.Array(EngineRunLog),
+  approvals: Schema17.Array(ApprovalSummary),
+  userInputs: Schema17.optional(Schema17.Array(UserInputRequestSummary)),
+  validations: Schema17.Array(ValidationSummary),
+  reviews: Schema17.Array(ReviewSummary),
+  artifacts: Schema17.Array(ArtifactSummary),
+  policyDecisions: Schema17.Array(PolicyDecisionSummary),
+  queue: Schema17.Array(QueueEntry),
+  worktrees: Schema17.Array(WorktreeSummary),
+  remoteEndpoints: Schema17.Array(RemoteEndpoint),
+  remoteConnections: Schema17.Array(RemoteConnectionSummary),
+  remoteOrchestrations: Schema17.Array(RemoteOrchestrationSummary),
   updatedAt: IsoDateTime
 });
-var RuntimeAdapterKind = Schema15.Literals(["codex", "claude-code", "pi"]);
-var WorkspaceRegisterCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.register"),
+var RuntimeAdapterKind = Schema17.Literals(["codex", "claude-code", "pi"]);
+var WorkspaceRegisterCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.register"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
   title: TrimmedNonEmptyString,
   rootPath: TrimmedNonEmptyString,
-  defaultModel: Schema15.optional(TrimmedNonEmptyString),
+  defaultModel: Schema17.optional(TrimmedNonEmptyString),
   createdAt: IsoDateTime
 });
-var WorkspaceImportRigCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.importRig"),
+var WorkspaceImportRigCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.importRig"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
   rootPath: TrimmedNonEmptyString,
-  title: Schema15.optional(TrimmedNonEmptyString),
+  title: Schema17.optional(TrimmedNonEmptyString),
   createdAt: IsoDateTime
 });
-var RunCreateAdhocCommand = Schema15.Struct({
-  type: Schema15.Literal("run.createAdhoc"),
+var RunCreateAdhocCommand = Schema17.Struct({
+  type: Schema17.Literal("run.createAdhoc"),
   commandId: CommandId,
   runId: RunId,
   workspaceId: WorkspaceId,
   title: TrimmedNonEmptyString,
-  runtimeAdapter: Schema15.optional(RuntimeAdapterKind),
-  model: Schema15.optional(TrimmedNonEmptyString),
-  executionTarget: Schema15.optional(RunExecutionTarget),
-  remoteHostId: Schema15.optional(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  initialPrompt: Schema15.optional(Schema15.String),
+  runtimeAdapter: Schema17.optional(RuntimeAdapterKind),
+  model: Schema17.optional(TrimmedNonEmptyString),
+  executionTarget: Schema17.optional(RunExecutionTarget),
+  remoteHostId: Schema17.optional(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema17.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema17.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  initialPrompt: Schema17.optional(Schema17.String),
   createdAt: IsoDateTime
 });
-var RunCreateForTaskCommand = Schema15.Struct({
-  type: Schema15.Literal("run.createForTask"),
+var RunCreateForTaskCommand = Schema17.Struct({
+  type: Schema17.Literal("run.createForTask"),
   commandId: CommandId,
   runId: RunId,
   workspaceId: WorkspaceId,
   taskId: TaskId,
-  runtimeAdapter: Schema15.optional(RuntimeAdapterKind),
-  model: Schema15.optional(TrimmedNonEmptyString),
-  executionTarget: Schema15.optional(RunExecutionTarget),
-  remoteHostId: Schema15.optional(TrimmedNonEmptyString),
-  runtimeMode: RuntimeMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema15.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  runtimeAdapter: Schema17.optional(RuntimeAdapterKind),
+  model: Schema17.optional(TrimmedNonEmptyString),
+  executionTarget: Schema17.optional(RunExecutionTarget),
+  remoteHostId: Schema17.optional(TrimmedNonEmptyString),
+  runtimeMode: RuntimeMode.pipe(Schema17.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema17.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
   createdAt: IsoDateTime
 });
-var RunSubmitUserMessageCommand = Schema15.Struct({
-  type: Schema15.Literal("run.submitUserMessage"),
+var RunSubmitUserMessageCommand = Schema17.Struct({
+  type: Schema17.Literal("run.submitUserMessage"),
   commandId: CommandId,
   runId: RunId,
   messageId: MessageId,
-  text: Schema15.String,
-  attachments: Schema15.optional(Schema15.Array(Schema15.Unknown)),
+  text: Schema17.String,
+  attachments: Schema17.optional(Schema17.Array(Schema17.Unknown)),
   createdAt: IsoDateTime
 });
-var RunInterruptCommand = Schema15.Struct({
-  type: Schema15.Literal("run.interrupt"),
+var RunInterruptCommand = Schema17.Struct({
+  type: Schema17.Literal("run.interrupt"),
   commandId: CommandId,
   runId: RunId,
   createdAt: IsoDateTime
 });
-var RunStopCommand = Schema15.Struct({
-  type: Schema15.Literal("run.stop"),
+var RunStopCommand = Schema17.Struct({
+  type: Schema17.Literal("run.stop"),
   commandId: CommandId,
   runId: RunId,
   createdAt: IsoDateTime
 });
-var RunSetRuntimeModeCommand = Schema15.Struct({
-  type: Schema15.Literal("run.setRuntimeMode"),
+var RunSetRuntimeModeCommand = Schema17.Struct({
+  type: Schema17.Literal("run.setRuntimeMode"),
   commandId: CommandId,
   runId: RunId,
   runtimeMode: RuntimeMode,
   createdAt: IsoDateTime
 });
-var RunSetInteractionModeCommand = Schema15.Struct({
-  type: Schema15.Literal("run.setInteractionMode"),
+var RunSetInteractionModeCommand = Schema17.Struct({
+  type: Schema17.Literal("run.setInteractionMode"),
   commandId: CommandId,
   runId: RunId,
   interactionMode: ProviderInteractionMode,
   createdAt: IsoDateTime
 });
-var RunRespondApprovalCommand = Schema15.Struct({
-  type: Schema15.Literal("run.respondApproval"),
+var RunRespondApprovalCommand = Schema17.Struct({
+  type: Schema17.Literal("run.respondApproval"),
   commandId: CommandId,
   runId: RunId,
   requestId: ApprovalRequestId,
   decision: ProviderApprovalDecision,
   createdAt: IsoDateTime
 });
-var RunRespondUserInputCommand = Schema15.Struct({
-  type: Schema15.Literal("run.respondUserInput"),
+var RunRespondUserInputCommand = Schema17.Struct({
+  type: Schema17.Literal("run.respondUserInput"),
   commandId: CommandId,
   runId: RunId,
   requestId: ApprovalRequestId,
   answers: ProviderUserInputAnswers,
   createdAt: IsoDateTime
 });
-var RuntimePrepareCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.prepare"),
+var RuntimePrepareCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.prepare"),
   commandId: CommandId,
   runId: RunId,
   workspaceId: WorkspaceId,
   adapter: RuntimeAdapterKind,
-  executionTarget: Schema15.optional(RunExecutionTarget),
-  remoteHostId: Schema15.optional(TrimmedNonEmptyString),
-  model: Schema15.optional(TrimmedNonEmptyString),
+  executionTarget: Schema17.optional(RunExecutionTarget),
+  remoteHostId: Schema17.optional(TrimmedNonEmptyString),
+  model: Schema17.optional(TrimmedNonEmptyString),
   createdAt: IsoDateTime
 });
-var RuntimeAttachCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.attach"),
+var RuntimeAttachCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.attach"),
   commandId: CommandId,
   runId: RunId,
   runtimeId: EngineRuntimeId,
   createdAt: IsoDateTime
 });
-var RuntimeDetachCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.detach"),
+var RuntimeDetachCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.detach"),
   commandId: CommandId,
   runId: RunId,
   reason: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var GraphUpdateTaskStatusCommand = Schema15.Struct({
-  type: Schema15.Literal("graph.updateTaskStatus"),
+var GraphUpdateTaskStatusCommand = Schema17.Struct({
+  type: Schema17.Literal("graph.updateTaskStatus"),
   commandId: CommandId,
   taskId: TaskId,
   status: TaskStatus,
   createdAt: IsoDateTime
 });
-var TaskEnqueueCommand = Schema15.Struct({
-  type: Schema15.Literal("task.enqueue"),
+var TaskEnqueueCommand = Schema17.Struct({
+  type: Schema17.Literal("task.enqueue"),
   commandId: CommandId,
   taskId: TaskId,
   score: NonNegativeInt,
   createdAt: IsoDateTime
 });
-var WorkspaceHydrateImportedStateCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.hydrateImportedState"),
+var WorkspaceHydrateImportedStateCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.hydrateImportedState"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
-  rootPath: Schema15.optional(Schema15.String),
+  rootPath: Schema17.optional(Schema17.String),
   graph: GraphSummary,
-  tasks: Schema15.Array(TaskSummary),
-  runs: Schema15.Array(RunSummary),
-  runtimes: Schema15.Array(RuntimeSummary),
-  actions: Schema15.Array(EngineAction),
-  logs: Schema15.optional(Schema15.Array(EngineRunLog)),
-  validations: Schema15.Array(ValidationSummary),
-  reviews: Schema15.Array(ReviewSummary),
-  artifacts: Schema15.Array(ArtifactSummary),
-  policyDecisions: Schema15.Array(PolicyDecisionSummary),
-  queue: Schema15.Array(QueueEntry),
+  tasks: Schema17.Array(TaskSummary),
+  runs: Schema17.Array(RunSummary),
+  runtimes: Schema17.Array(RuntimeSummary),
+  actions: Schema17.Array(EngineAction),
+  logs: Schema17.optional(Schema17.Array(EngineRunLog)),
+  validations: Schema17.Array(ValidationSummary),
+  reviews: Schema17.Array(ReviewSummary),
+  artifacts: Schema17.Array(ArtifactSummary),
+  policyDecisions: Schema17.Array(PolicyDecisionSummary),
+  queue: Schema17.Array(QueueEntry),
   createdAt: IsoDateTime
 });
-var WorkspaceCompileTopologyCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.compileTopology"),
+var WorkspaceCompileTopologyCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.compileTopology"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
   rootPath: TrimmedNonEmptyString,
   topology: WorkspaceTopologySummary,
   createdAt: IsoDateTime
 });
-var WorkspaceSyncRemoteFleetCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.syncRemoteFleet"),
+var WorkspaceSyncRemoteFleetCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.syncRemoteFleet"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
   rootPath: TrimmedNonEmptyString,
   remoteFleet: WorkspaceRemoteFleetSummary,
   createdAt: IsoDateTime
 });
-var WorkspaceSyncServiceFabricCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.syncServiceFabric"),
+var WorkspaceSyncServiceFabricCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.syncServiceFabric"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
   rootPath: TrimmedNonEmptyString,
   serviceFabric: WorkspaceServiceFabricSummary,
   createdAt: IsoDateTime
 });
-var WorkspaceRegisterRemoteHostCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.registerRemoteHost"),
+var WorkspaceRegisterRemoteHostCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.registerRemoteHost"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
-  host: Schema15.Struct({
+  host: Schema17.Struct({
     id: TrimmedNonEmptyString,
     name: TrimmedNonEmptyString,
     baseUrl: TrimmedNonEmptyString,
-    workspacePath: Schema15.NullOr(TrimmedNonEmptyString),
+    workspacePath: Schema17.NullOr(TrimmedNonEmptyString),
     transport: TrimmedNonEmptyString,
-    hostname: Schema15.NullOr(TrimmedNonEmptyString),
-    region: Schema15.NullOr(TrimmedNonEmptyString),
-    labels: Schema15.Array(TrimmedNonEmptyString),
-    capabilities: Schema15.Array(TrimmedNonEmptyString),
-    runtimeAdapters: Schema15.Array(TrimmedNonEmptyString),
-    status: Schema15.Literals([
+    hostname: Schema17.NullOr(TrimmedNonEmptyString),
+    region: Schema17.NullOr(TrimmedNonEmptyString),
+    labels: Schema17.Array(TrimmedNonEmptyString),
+    capabilities: Schema17.Array(TrimmedNonEmptyString),
+    runtimeAdapters: Schema17.Array(TrimmedNonEmptyString),
+    status: Schema17.Literals([
       "registering",
       "ready",
       "busy",
@@ -2060,19 +2529,19 @@ var WorkspaceRegisterRemoteHostCommand = Schema15.Struct({
       "offline",
       "quarantined"
     ]),
-    currentLeaseCount: Schema15.Number,
-    lastHeartbeatAt: Schema15.NullOr(IsoDateTime),
+    currentLeaseCount: Schema17.Number,
+    lastHeartbeatAt: Schema17.NullOr(IsoDateTime),
     registeredAt: IsoDateTime,
     manifestPath: TrimmedNonEmptyString
   }),
   createdAt: IsoDateTime
 });
-var WorkspaceUpdateRemoteHostStatusCommand = Schema15.Struct({
-  type: Schema15.Literal("workspace.updateRemoteHostStatus"),
+var WorkspaceUpdateRemoteHostStatusCommand = Schema17.Struct({
+  type: Schema17.Literal("workspace.updateRemoteHostStatus"),
   commandId: CommandId,
   workspaceId: WorkspaceId,
   hostId: TrimmedNonEmptyString,
-  status: Schema15.Literals([
+  status: Schema17.Literals([
     "registering",
     "ready",
     "busy",
@@ -2081,300 +2550,300 @@ var WorkspaceUpdateRemoteHostStatusCommand = Schema15.Struct({
     "offline",
     "quarantined"
   ]),
-  currentLeaseCount: Schema15.optional(Schema15.Number),
-  lastHeartbeatAt: Schema15.optional(IsoDateTime),
+  currentLeaseCount: Schema17.optional(Schema17.Number),
+  lastHeartbeatAt: Schema17.optional(IsoDateTime),
   createdAt: IsoDateTime
 });
-var RunClaimRemoteLeaseCommand = Schema15.Struct({
-  type: Schema15.Literal("run.claimRemoteLease"),
+var RunClaimRemoteLeaseCommand = Schema17.Struct({
+  type: Schema17.Literal("run.claimRemoteLease"),
   commandId: CommandId,
   runId: RunId,
   hostId: TrimmedNonEmptyString,
   leaseId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var RunReleaseRemoteLeaseCommand = Schema15.Struct({
-  type: Schema15.Literal("run.releaseRemoteLease"),
+var RunReleaseRemoteLeaseCommand = Schema17.Struct({
+  type: Schema17.Literal("run.releaseRemoteLease"),
   commandId: CommandId,
   runId: RunId,
   leaseId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var RuntimeRecordMessageCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.recordMessage"),
+var RuntimeRecordMessageCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.recordMessage"),
   commandId: CommandId,
   runId: RunId,
   messageId: MessageId,
   role: EngineMessageRole,
-  text: Schema15.String,
+  text: Schema17.String,
   state: EngineMessageState,
-  attachments: Schema15.optional(Schema15.Array(Schema15.Unknown)),
+  attachments: Schema17.optional(Schema17.Array(Schema17.Unknown)),
   createdAt: IsoDateTime,
-  completedAt: Schema15.optional(IsoDateTime)
+  completedAt: Schema17.optional(IsoDateTime)
 });
-var RuntimeStartActionCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.startAction"),
+var RuntimeStartActionCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.startAction"),
   commandId: CommandId,
   runId: RunId,
   actionId: ActionId,
-  messageId: Schema15.optional(MessageId),
+  messageId: Schema17.optional(MessageId),
   actionType: TrimmedNonEmptyString,
   title: TrimmedNonEmptyString,
-  detail: Schema15.optional(Schema15.String),
-  payload: Schema15.Unknown,
+  detail: Schema17.optional(Schema17.String),
+  payload: Schema17.Unknown,
   createdAt: IsoDateTime
 });
-var RuntimeCompleteActionCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.completeAction"),
+var RuntimeCompleteActionCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.completeAction"),
   commandId: CommandId,
   runId: RunId,
   actionId: ActionId,
   state: TrimmedNonEmptyString,
-  detail: Schema15.optional(Schema15.String),
-  payload: Schema15.Unknown,
+  detail: Schema17.optional(Schema17.String),
+  payload: Schema17.Unknown,
   createdAt: IsoDateTime
 });
-var RuntimeRecordLogCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.recordLog"),
+var RuntimeRecordLogCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.recordLog"),
   commandId: CommandId,
   runId: RunId,
   logId: TrimmedNonEmptyString,
   title: TrimmedNonEmptyString,
-  detail: Schema15.optional(Schema15.String),
+  detail: Schema17.optional(Schema17.String),
   tone: EngineLogTone,
-  status: Schema15.optional(TrimmedNonEmptyString),
-  payload: Schema15.optional(Schema15.Unknown),
+  status: Schema17.optional(TrimmedNonEmptyString),
+  payload: Schema17.optional(Schema17.Unknown),
   createdAt: IsoDateTime
 });
-var RuntimeUpdateMetadataCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.updateMetadata"),
+var RuntimeUpdateMetadataCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.updateMetadata"),
   commandId: CommandId,
   runId: RunId,
   runtimeId: EngineRuntimeId,
-  sandboxMode: Schema15.optional(EngineSandboxMode),
-  isolationMode: Schema15.optional(IsolationMode),
-  workspaceDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  homeDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  tmpDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  cacheDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  logsDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  stateDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  sessionDir: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  sessionLogPath: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  pid: Schema15.optional(NonNegativeInt),
-  worktreePath: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  branch: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
+  sandboxMode: Schema17.optional(EngineSandboxMode),
+  isolationMode: Schema17.optional(IsolationMode),
+  workspaceDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  homeDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  tmpDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  cacheDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  logsDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  stateDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  sessionDir: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  sessionLogPath: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  pid: Schema17.optional(NonNegativeInt),
+  worktreePath: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  branch: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
   createdAt: IsoDateTime
 });
-var RuntimeRequestApprovalCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.requestApproval"),
+var RuntimeRequestApprovalCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.requestApproval"),
   commandId: CommandId,
   runId: RunId,
   requestId: ApprovalRequestId,
   requestKind: TrimmedNonEmptyString,
-  actionId: Schema15.optional(ActionId),
-  payload: Schema15.Unknown,
+  actionId: Schema17.optional(ActionId),
+  payload: Schema17.Unknown,
   createdAt: IsoDateTime
 });
-var RuntimeRequestUserInputCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.requestUserInput"),
+var RuntimeRequestUserInputCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.requestUserInput"),
   commandId: CommandId,
   runId: RunId,
   requestId: ApprovalRequestId,
-  payload: Schema15.Unknown,
+  payload: Schema17.Unknown,
   createdAt: IsoDateTime
 });
-var RunMarkCompletedCommand = Schema15.Struct({
-  type: Schema15.Literal("run.markCompleted"),
+var RunMarkCompletedCommand = Schema17.Struct({
+  type: Schema17.Literal("run.markCompleted"),
   commandId: CommandId,
   runId: RunId,
   createdAt: IsoDateTime
 });
-var RunMarkFailedCommand = Schema15.Struct({
-  type: Schema15.Literal("run.markFailed"),
+var RunMarkFailedCommand = Schema17.Struct({
+  type: Schema17.Literal("run.markFailed"),
   commandId: CommandId,
   runId: RunId,
-  errorText: Schema15.optional(Schema15.String),
+  errorText: Schema17.optional(Schema17.String),
   createdAt: IsoDateTime
 });
-var RunSetStatusCommand = Schema15.Struct({
-  type: Schema15.Literal("run.setStatus"),
+var RunSetStatusCommand = Schema17.Struct({
+  type: Schema17.Literal("run.setStatus"),
   commandId: CommandId,
   runId: RunId,
-  status: Schema15.Literals(["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]),
+  status: Schema17.Literals(["created", "queued", "preparing", "running", "validating", "reviewing", "paused"]),
   createdAt: IsoDateTime
 });
-var RuntimeRecordValidationCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.recordValidation"),
+var RuntimeRecordValidationCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.recordValidation"),
   commandId: CommandId,
   runId: RunId,
-  taskId: Schema15.optional(Schema15.NullOr(TaskId)),
+  taskId: Schema17.optional(Schema17.NullOr(TaskId)),
   validationId: ValidationResultId,
   validatorKey: TrimmedNonEmptyString,
-  status: Schema15.Literals(["pending", "running", "passed", "failed", "skipped"]),
-  output: Schema15.Unknown,
+  status: Schema17.Literals(["pending", "running", "passed", "failed", "skipped"]),
+  output: Schema17.Unknown,
   startedAt: IsoDateTime,
-  completedAt: Schema15.optional(Schema15.NullOr(IsoDateTime)),
+  completedAt: Schema17.optional(Schema17.NullOr(IsoDateTime)),
   createdAt: IsoDateTime
 });
-var RuntimeRecordReviewCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.recordReview"),
+var RuntimeRecordReviewCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.recordReview"),
   commandId: CommandId,
   runId: RunId,
-  taskId: Schema15.optional(Schema15.NullOr(TaskId)),
+  taskId: Schema17.optional(Schema17.NullOr(TaskId)),
   reviewId: ReviewResultId,
   provider: TrimmedNonEmptyString,
-  mode: Schema15.Literals(["off", "advisory", "required"]),
-  status: Schema15.Literals(["pending", "running", "approved", "rejected", "error"]),
-  summary: Schema15.optional(Schema15.NullOr(Schema15.String)),
-  output: Schema15.Unknown,
+  mode: Schema17.Literals(["off", "advisory", "required"]),
+  status: Schema17.Literals(["pending", "running", "approved", "rejected", "error"]),
+  summary: Schema17.optional(Schema17.NullOr(Schema17.String)),
+  output: Schema17.Unknown,
   createdAt: IsoDateTime,
-  completedAt: Schema15.optional(Schema15.NullOr(IsoDateTime))
+  completedAt: Schema17.optional(Schema17.NullOr(IsoDateTime))
 });
-var RuntimeRegisterArtifactCommand = Schema15.Struct({
-  type: Schema15.Literal("runtime.registerArtifact"),
+var RuntimeRegisterArtifactCommand = Schema17.Struct({
+  type: Schema17.Literal("runtime.registerArtifact"),
   commandId: CommandId,
   runId: RunId,
-  taskId: Schema15.optional(Schema15.NullOr(TaskId)),
+  taskId: Schema17.optional(Schema17.NullOr(TaskId)),
   artifactId: ArtifactId,
   kind: TrimmedNonEmptyString,
   label: TrimmedNonEmptyString,
-  path: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  url: Schema15.optional(Schema15.NullOr(TrimmedNonEmptyString)),
-  metadata: Schema15.optional(Schema15.Record(Schema15.String, Schema15.Unknown)),
+  path: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  url: Schema17.optional(Schema17.NullOr(TrimmedNonEmptyString)),
+  metadata: Schema17.optional(Schema17.Record(Schema17.String, Schema17.Unknown)),
   createdAt: IsoDateTime
 });
-var RemoteRegisterEndpointCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.registerEndpoint"),
+var RemoteRegisterEndpointCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.registerEndpoint"),
   commandId: CommandId,
   endpoint: RemoteEndpoint,
   createdAt: IsoDateTime
 });
-var RemoteRemoveEndpointCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.removeEndpoint"),
+var RemoteRemoveEndpointCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.removeEndpoint"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteUpdateEndpointCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.updateEndpoint"),
+var RemoteUpdateEndpointCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.updateEndpoint"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
-  updates: Schema15.Unknown,
+  updates: Schema17.Unknown,
   createdAt: IsoDateTime
 });
-var RemoteConnectCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.connect"),
+var RemoteConnectCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.connect"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteDisconnectCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.disconnect"),
+var RemoteDisconnectCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.disconnect"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemotePauseCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.pause"),
+var RemotePauseCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.pause"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteResumeCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.resume"),
+var RemoteResumeCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.resume"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteStopCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.stop"),
+var RemoteStopCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.stop"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteContinueCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.continue"),
+var RemoteContinueCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.continue"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteCreateRunForTaskCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.createRunForTask"),
+var RemoteCreateRunForTaskCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.createRunForTask"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   taskId: TrimmedNonEmptyString,
   runId: TrimmedNonEmptyString,
   workspaceId: TrimmedNonEmptyString,
-  runtimeMode: Schema15.optional(Schema15.String),
-  interactionMode: Schema15.optional(Schema15.String),
+  runtimeMode: Schema17.optional(Schema17.String),
+  interactionMode: Schema17.optional(Schema17.String),
   createdAt: IsoDateTime
 });
-var RemoteRefreshTasksCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.refreshTasks"),
+var RemoteRefreshTasksCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.refreshTasks"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   createdAt: IsoDateTime
 });
-var RemoteAddIterationsCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.addIterations"),
+var RemoteAddIterationsCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.addIterations"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
-  count: Schema15.Int.check(Schema15.isGreaterThanOrEqualTo(1)),
+  count: Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(1)),
   createdAt: IsoDateTime
 });
-var RemoteRemoveIterationsCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.removeIterations"),
+var RemoteRemoveIterationsCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.removeIterations"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
-  count: Schema15.Int.check(Schema15.isGreaterThanOrEqualTo(1)),
+  count: Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(1)),
   createdAt: IsoDateTime
 });
-var RemoteOrchestrateStartCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.orchestrate.start"),
+var RemoteOrchestrateStartCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.orchestrate.start"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
-  maxWorkers: Schema15.optional(Schema15.Int),
-  maxIterations: Schema15.optional(Schema15.Int),
-  directMerge: Schema15.optional(Schema15.Boolean),
+  maxWorkers: Schema17.optional(Schema17.Int),
+  maxIterations: Schema17.optional(Schema17.Int),
+  directMerge: Schema17.optional(Schema17.Boolean),
   createdAt: IsoDateTime
 });
-var RemoteOrchestratePauseCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.orchestrate.pause"),
+var RemoteOrchestratePauseCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.orchestrate.pause"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   orchestrationId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var RemoteOrchestrateResumeCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.orchestrate.resume"),
+var RemoteOrchestrateResumeCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.orchestrate.resume"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   orchestrationId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var RemoteOrchestrateStopCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.orchestrate.stop"),
+var RemoteOrchestrateStopCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.orchestrate.stop"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   orchestrationId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var RemoteGetPromptPreviewCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.getPromptPreview"),
+var RemoteGetPromptPreviewCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.getPromptPreview"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   taskId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var RemoteGetIterationOutputCommand = Schema15.Struct({
-  type: Schema15.Literal("remote.getIterationOutput"),
+var RemoteGetIterationOutputCommand = Schema17.Struct({
+  type: Schema17.Literal("remote.getIterationOutput"),
   commandId: CommandId,
   endpointId: RemoteEndpointId,
   taskId: TrimmedNonEmptyString,
   createdAt: IsoDateTime
 });
-var EngineCommand = Schema15.Union([
+var EngineCommand = Schema17.Union([
   WorkspaceRegisterCommand,
   WorkspaceImportRigCommand,
   WorkspaceHydrateImportedStateCommand,
@@ -2432,18 +2901,18 @@ var EngineCommand = Schema15.Union([
   RemoteGetPromptPreviewCommand,
   RemoteGetIterationOutputCommand
 ]);
-var EngineDispatchResult = Schema15.Struct({
+var EngineDispatchResult = Schema17.Struct({
   sequence: NonNegativeInt
 });
-var EngineGetSnapshotInput = Schema15.Struct({});
-var EngineReplayEventsInput = Schema15.Struct({
+var EngineGetSnapshotInput = Schema17.Struct({});
+var EngineReplayEventsInput = Schema17.Struct({
   fromSequenceExclusive: NonNegativeInt
 });
-var EngineReplayEventsResult = Schema15.Array(EngineEvent);
-var EngineGetTaskArtifactsInput = Schema15.Struct({
+var EngineReplayEventsResult = Schema17.Array(EngineEvent);
+var EngineGetTaskArtifactsInput = Schema17.Struct({
   taskId: TaskId
 });
-var EngineGetTaskArtifactsResult = Schema15.Array(ArtifactSummary);
+var EngineGetTaskArtifactsResult = Schema17.Array(ArtifactSummary);
 var EngineRpcSchemas = {
   getSnapshot: {
     input: EngineGetSnapshotInput,
@@ -2462,14 +2931,14 @@ var EngineRpcSchemas = {
     output: EngineGetTaskArtifactsResult
   }
 };
-var EngineRuntimeDefaults = Schema15.Struct({
+var EngineRuntimeDefaults = Schema17.Struct({
   runtimeAdapter: TrimmedNonEmptyString,
   runMode: RunMode,
   sandboxMode: EngineSandboxMode,
   isolationMode: IsolationMode
 });
 // packages/contracts/src/rig.ts
-import { Schema as Schema16 } from "effect";
+import { Schema as Schema18 } from "effect";
 var RIG_WS_METHODS = {
   getSnapshot: "rig.getSnapshot",
   replayEvents: "rig.replayEvents",
@@ -2486,237 +2955,259 @@ var RIG_WS_METHODS = {
   stopRun: "rig.stopRun",
   resolveApproval: "rig.resolveApproval",
   resolveUserInput: "rig.resolveUserInput",
-  getTaskArtifacts: "rig.getTaskArtifacts"
+  getTaskArtifacts: "rig.getTaskArtifacts",
+  ackRunSteering: "rig.ackRunSteering"
 };
 var RIG_WS_CHANNELS = {
   snapshotInvalidated: "rig.snapshotInvalidated",
   event: "rig.event",
-  runLogAppended: "rig.runLogAppended"
+  runLogAppended: "rig.runLogAppended",
+  runSteering: "rig.runSteering"
 };
-var RigSnapshotInvalidatedPayload = Schema16.Struct({
+var RigSnapshotInvalidatedPayload = Schema18.Struct({
   sequence: NonNegativeInt,
   updatedAt: IsoDateTime,
-  reason: Schema16.optional(TrimmedNonEmptyString)
+  reason: Schema18.optional(TrimmedNonEmptyString)
 });
 var RigSnapshot = EngineReadModel;
-var RigGetSnapshotInput = Schema16.Struct({});
-var RigReplayEventsInput = Schema16.Struct({
+var RigGetSnapshotInput = Schema18.Struct({});
+var RigReplayEventsInput = Schema18.Struct({
   fromSequenceExclusive: NonNegativeInt
 });
-var RigReplayEventsResult = Schema16.Array(EngineEvent);
-var RigListWorkspacesInput = Schema16.Struct({});
-var RigListWorkspacesResult = Schema16.Array(WorkspaceSummary);
-var RigGetWorkspaceInput = Schema16.Struct({
+var RigReplayEventsResult = Schema18.Array(EngineEvent);
+var RigListWorkspacesInput = Schema18.Struct({});
+var RigListWorkspacesResult = Schema18.Array(WorkspaceSummary);
+var RigGetWorkspaceInput = Schema18.Struct({
   workspaceId: WorkspaceId
 });
-var RigGetWorkspaceResult = Schema16.Struct({
-  workspace: Schema16.NullOr(WorkspaceSummary),
-  tasks: Schema16.Array(TaskSummary),
-  runs: Schema16.Array(RunSummary),
-  approvals: Schema16.Array(ApprovalSummary),
-  userInputs: Schema16.Array(UserInputRequestSummary),
-  artifacts: Schema16.Array(ArtifactSummary),
+var RigGetWorkspaceResult = Schema18.Struct({
+  workspace: Schema18.NullOr(WorkspaceSummary),
+  tasks: Schema18.Array(TaskSummary),
+  runs: Schema18.Array(RunSummary),
+  approvals: Schema18.Array(ApprovalSummary),
+  userInputs: Schema18.Array(UserInputRequestSummary),
+  artifacts: Schema18.Array(ArtifactSummary),
   updatedAt: IsoDateTime
 });
-var RigRawRunLogEntry = Schema16.Record(Schema16.String, Schema16.Unknown);
-var RigGetRunLogsInput = Schema16.Struct({
+var RigRawRunLogEntry = Schema18.Record(Schema18.String, Schema18.Unknown);
+var RigGetRunLogsInput = Schema18.Struct({
   runId: RunId,
-  limit: Schema16.optional(PositiveInt.check(Schema16.isLessThanOrEqualTo(500))),
-  cursor: Schema16.optional(Schema16.String)
+  limit: Schema18.optional(PositiveInt.check(Schema18.isLessThanOrEqualTo(500))),
+  cursor: Schema18.optional(Schema18.String)
 });
-var RigGetRunLogsResult = Schema16.Struct({
-  entries: Schema16.Array(RigRawRunLogEntry),
-  nextCursor: Schema16.NullOr(Schema16.String),
-  hasMore: Schema16.Boolean
+var RigGetRunLogsResult = Schema18.Struct({
+  entries: Schema18.Array(RigRawRunLogEntry),
+  nextCursor: Schema18.NullOr(Schema18.String),
+  hasMore: Schema18.Boolean
 });
-var RigRunLogAppendedPayload = Schema16.Struct({
+var RigRunLogAppendedPayload = Schema18.Struct({
   runId: RunId,
   entry: RigRawRunLogEntry
 });
-var RigCreateAdhocRunInput = Schema16.Struct({
+var RigQueuedRunSteeringMessage = Schema18.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  message: TrimmedNonEmptyString,
+  actor: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  delivered: Schema18.Boolean
+});
+var RigRunSteeringQueuedPayload = Schema18.Struct({
+  runId: RunId,
+  message: RigQueuedRunSteeringMessage
+});
+var RigAckRunSteeringInput = Schema18.Struct({
+  runId: RunId,
+  ids: Schema18.Array(TrimmedNonEmptyString)
+});
+var RigAckRunSteeringResult = Schema18.Struct({
+  runId: RunId,
+  delivered: Schema18.Array(TrimmedNonEmptyString)
+});
+var RigCreateAdhocRunInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   workspaceId: WorkspaceId,
-  title: Schema16.String,
-  runtimeAdapter: Schema16.optional(RuntimeAdapterKind),
-  model: Schema16.optional(Schema16.String),
-  runtimeMode: RuntimeMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  executionTarget: Schema16.optional(RunExecutionTarget),
-  remoteHostId: Schema16.optional(Schema16.String),
-  initialPrompt: Schema16.optional(Schema16.String),
+  title: Schema18.String,
+  runtimeAdapter: Schema18.optional(RuntimeAdapterKind),
+  model: Schema18.optional(Schema18.String),
+  runtimeMode: RuntimeMode.pipe(Schema18.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema18.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  executionTarget: Schema18.optional(RunExecutionTarget),
+  remoteHostId: Schema18.optional(Schema18.String),
+  initialPrompt: Schema18.optional(Schema18.String),
   createdAt: IsoDateTime
 });
-var RigCreateTaskRunInput = Schema16.Struct({
+var RigCreateTaskRunInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   workspaceId: WorkspaceId,
   taskId: TaskId,
-  runtimeAdapter: Schema16.optional(RuntimeAdapterKind),
-  model: Schema16.optional(Schema16.String),
-  runtimeMode: RuntimeMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
-  interactionMode: ProviderInteractionMode.pipe(Schema16.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
-  executionTarget: Schema16.optional(RunExecutionTarget),
-  remoteHostId: Schema16.optional(Schema16.String),
+  runtimeAdapter: Schema18.optional(RuntimeAdapterKind),
+  model: Schema18.optional(Schema18.String),
+  runtimeMode: RuntimeMode.pipe(Schema18.withDecodingDefault(() => DEFAULT_RUNTIME_MODE)),
+  interactionMode: ProviderInteractionMode.pipe(Schema18.withDecodingDefault(() => DEFAULT_PROVIDER_INTERACTION_MODE)),
+  executionTarget: Schema18.optional(RunExecutionTarget),
+  remoteHostId: Schema18.optional(Schema18.String),
   createdAt: IsoDateTime
 });
-var RigEnqueueTaskInput = Schema16.Struct({
+var RigEnqueueTaskInput = Schema18.Struct({
   commandId: CommandId,
   taskId: TaskId,
-  score: Schema16.optional(Schema16.Number),
+  score: Schema18.optional(Schema18.Number),
   createdAt: IsoDateTime
 });
-var RigDeleteRunInput = Schema16.Struct({
+var RigDeleteRunInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
-  purgeTaskArtifacts: Schema16.optional(Schema16.Boolean),
+  purgeTaskArtifacts: Schema18.optional(Schema18.Boolean),
   createdAt: IsoDateTime
 });
-var RigResumeRunInput = Schema16.Struct({
+var RigResumeRunInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
-  promptOverride: Schema16.optional(Schema16.String),
+  promptOverride: Schema18.optional(Schema18.String),
   createdAt: IsoDateTime
 });
-var RigSubmitRunMessageInput = Schema16.Struct({
+var RigSubmitRunMessageInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   messageId: MessageId,
-  text: Schema16.String,
-  attachments: Schema16.optional(Schema16.Array(Schema16.Unknown)),
+  text: Schema18.String,
+  attachments: Schema18.optional(Schema18.Array(Schema18.Unknown)),
   createdAt: IsoDateTime
 });
-var RigInterruptRunInput = Schema16.Struct({
+var RigInterruptRunInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   createdAt: IsoDateTime
 });
-var RigStopRunInput = Schema16.Struct({
+var RigStopRunInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   createdAt: IsoDateTime
 });
-var RigResolveApprovalInput = Schema16.Struct({
+var RigResolveApprovalInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   requestId: ApprovalRequestId,
   decision: ProviderApprovalDecision,
   createdAt: IsoDateTime
 });
-var RigResolveUserInputInput = Schema16.Struct({
+var RigResolveUserInputInput = Schema18.Struct({
   commandId: CommandId,
   runId: RunId,
   requestId: ApprovalRequestId,
   answers: ProviderUserInputAnswers,
   createdAt: IsoDateTime
 });
-var RigGetTaskArtifactsInput = Schema16.Struct({
+var RigGetTaskArtifactsInput = Schema18.Struct({
   taskId: TaskId
 });
-var RigGetTaskArtifactsResult = Schema16.Array(ArtifactSummary);
-var RigMutationResult = Schema16.Struct({
+var RigGetTaskArtifactsResult = Schema18.Array(ArtifactSummary);
+var RigMutationResult = Schema18.Struct({
   sequence: NonNegativeInt
 });
 // packages/contracts/src/terminal.ts
-import { Schema as Schema17 } from "effect";
+import { Schema as Schema19 } from "effect";
 var DEFAULT_TERMINAL_ID = "default";
 var TrimmedNonEmptyStringSchema = TrimmedNonEmptyString;
-var TerminalColsSchema = Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(20)).check(Schema17.isLessThanOrEqualTo(400));
-var TerminalRowsSchema = Schema17.Int.check(Schema17.isGreaterThanOrEqualTo(5)).check(Schema17.isLessThanOrEqualTo(200));
-var TerminalIdSchema = TrimmedNonEmptyStringSchema.check(Schema17.isMaxLength(128));
-var TerminalEnvKeySchema = Schema17.String.check(Schema17.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/)).check(Schema17.isMaxLength(128));
-var TerminalEnvValueSchema = Schema17.String.check(Schema17.isMaxLength(8192));
-var TerminalEnvSchema = Schema17.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(Schema17.isMaxProperties(128));
-var TerminalIdWithDefaultSchema = TerminalIdSchema.pipe(Schema17.withDecodingDefault(() => DEFAULT_TERMINAL_ID));
-var TerminalThreadInput = Schema17.Struct({
+var TerminalColsSchema = Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(20)).check(Schema19.isLessThanOrEqualTo(400));
+var TerminalRowsSchema = Schema19.Int.check(Schema19.isGreaterThanOrEqualTo(5)).check(Schema19.isLessThanOrEqualTo(200));
+var TerminalIdSchema = TrimmedNonEmptyStringSchema.check(Schema19.isMaxLength(128));
+var TerminalEnvKeySchema = Schema19.String.check(Schema19.isPattern(/^[A-Za-z_][A-Za-z0-9_]*$/)).check(Schema19.isMaxLength(128));
+var TerminalEnvValueSchema = Schema19.String.check(Schema19.isMaxLength(8192));
+var TerminalEnvSchema = Schema19.Record(TerminalEnvKeySchema, TerminalEnvValueSchema).check(Schema19.isMaxProperties(128));
+var TerminalIdWithDefaultSchema = TerminalIdSchema.pipe(Schema19.withDecodingDefault(() => DEFAULT_TERMINAL_ID));
+var TerminalThreadInput = Schema19.Struct({
   threadId: TrimmedNonEmptyStringSchema
 });
-var TerminalSessionInput = Schema17.Struct({
+var TerminalSessionInput = Schema19.Struct({
   ...TerminalThreadInput.fields,
   terminalId: TerminalIdWithDefaultSchema
 });
-var TerminalOpenInput = Schema17.Struct({
+var TerminalOpenInput = Schema19.Struct({
   ...TerminalSessionInput.fields,
   cwd: TrimmedNonEmptyStringSchema,
-  cols: Schema17.optional(TerminalColsSchema),
-  rows: Schema17.optional(TerminalRowsSchema),
-  env: Schema17.optional(TerminalEnvSchema)
+  cols: Schema19.optional(TerminalColsSchema),
+  rows: Schema19.optional(TerminalRowsSchema),
+  env: Schema19.optional(TerminalEnvSchema)
 });
-var TerminalWriteInput = Schema17.Struct({
+var TerminalWriteInput = Schema19.Struct({
   ...TerminalSessionInput.fields,
-  data: Schema17.String.check(Schema17.isNonEmpty()).check(Schema17.isMaxLength(65536))
+  data: Schema19.String.check(Schema19.isNonEmpty()).check(Schema19.isMaxLength(65536))
 });
-var TerminalResizeInput = Schema17.Struct({
+var TerminalResizeInput = Schema19.Struct({
   ...TerminalSessionInput.fields,
   cols: TerminalColsSchema,
   rows: TerminalRowsSchema
 });
 var TerminalClearInput = TerminalSessionInput;
-var TerminalRestartInput = Schema17.Struct({
+var TerminalRestartInput = Schema19.Struct({
   ...TerminalThreadInput.fields,
   cwd: TrimmedNonEmptyStringSchema,
   cols: TerminalColsSchema,
   rows: TerminalRowsSchema,
-  env: Schema17.optional(TerminalEnvSchema)
+  env: Schema19.optional(TerminalEnvSchema)
 });
-var TerminalCloseInput = Schema17.Struct({
+var TerminalCloseInput = Schema19.Struct({
   ...TerminalThreadInput.fields,
-  terminalId: Schema17.optional(TerminalIdSchema),
-  deleteHistory: Schema17.optional(Schema17.Boolean)
-});
-var TerminalSessionStatus = Schema17.Literals(["starting", "running", "exited", "error"]);
-var TerminalSessionSnapshot = Schema17.Struct({
-  threadId: Schema17.String.check(Schema17.isNonEmpty()),
-  terminalId: Schema17.String.check(Schema17.isNonEmpty()),
-  cwd: Schema17.String.check(Schema17.isNonEmpty()),
+  terminalId: Schema19.optional(TerminalIdSchema),
+  deleteHistory: Schema19.optional(Schema19.Boolean)
+});
+var TerminalSessionStatus = Schema19.Literals(["starting", "running", "exited", "error"]);
+var TerminalSessionSnapshot = Schema19.Struct({
+  threadId: Schema19.String.check(Schema19.isNonEmpty()),
+  terminalId: Schema19.String.check(Schema19.isNonEmpty()),
+  cwd: Schema19.String.check(Schema19.isNonEmpty()),
   status: TerminalSessionStatus,
-  pid: Schema17.NullOr(Schema17.Int.check(Schema17.isGreaterThan(0))),
-  history: Schema17.String,
-  exitCode: Schema17.NullOr(Schema17.Int),
-  exitSignal: Schema17.NullOr(Schema17.String),
-  updatedAt: Schema17.String
-});
-var TerminalEventBaseSchema = Schema17.Struct({
-  threadId: Schema17.String.check(Schema17.isNonEmpty()),
-  terminalId: Schema17.String.check(Schema17.isNonEmpty()),
-  createdAt: Schema17.String
-});
-var TerminalStartedEvent = Schema17.Struct({
+  pid: Schema19.NullOr(Schema19.Int.check(Schema19.isGreaterThan(0))),
+  history: Schema19.String,
+  exitCode: Schema19.NullOr(Schema19.Int),
+  exitSignal: Schema19.NullOr(Schema19.String),
+  updatedAt: Schema19.String
+});
+var TerminalEventBaseSchema = Schema19.Struct({
+  threadId: Schema19.String.check(Schema19.isNonEmpty()),
+  terminalId: Schema19.String.check(Schema19.isNonEmpty()),
+  createdAt: Schema19.String
+});
+var TerminalStartedEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("started"),
+  type: Schema19.Literal("started"),
   snapshot: TerminalSessionSnapshot
 });
-var TerminalOutputEvent = Schema17.Struct({
+var TerminalOutputEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("output"),
-  data: Schema17.String
+  type: Schema19.Literal("output"),
+  data: Schema19.String
 });
-var TerminalExitedEvent = Schema17.Struct({
+var TerminalExitedEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("exited"),
-  exitCode: Schema17.NullOr(Schema17.Int),
-  exitSignal: Schema17.NullOr(Schema17.String)
+  type: Schema19.Literal("exited"),
+  exitCode: Schema19.NullOr(Schema19.Int),
+  exitSignal: Schema19.NullOr(Schema19.String)
 });
-var TerminalErrorEvent = Schema17.Struct({
+var TerminalErrorEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("error"),
-  message: Schema17.String.check(Schema17.isNonEmpty())
+  type: Schema19.Literal("error"),
+  message: Schema19.String.check(Schema19.isNonEmpty())
 });
-var TerminalClearedEvent = Schema17.Struct({
+var TerminalClearedEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("cleared")
+  type: Schema19.Literal("cleared")
 });
-var TerminalRestartedEvent = Schema17.Struct({
+var TerminalRestartedEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("restarted"),
+  type: Schema19.Literal("restarted"),
   snapshot: TerminalSessionSnapshot
 });
-var TerminalActivityEvent = Schema17.Struct({
+var TerminalActivityEvent = Schema19.Struct({
   ...TerminalEventBaseSchema.fields,
-  type: Schema17.Literal("activity"),
-  hasRunningSubprocess: Schema17.Boolean
+  type: Schema19.Literal("activity"),
+  hasRunningSubprocess: Schema19.Boolean
 });
-var TerminalEvent = Schema17.Union([
+var TerminalEvent = Schema19.Union([
   TerminalStartedEvent,
   TerminalOutputEvent,
   TerminalExitedEvent,
@@ -2726,119 +3217,119 @@ var TerminalEvent = Schema17.Union([
   TerminalActivityEvent
 ]);
 // packages/contracts/src/provider.ts
-import { Schema as Schema18 } from "effect";
+import { Schema as Schema20 } from "effect";
 var TrimmedNonEmptyStringSchema2 = TrimmedNonEmptyString;
-var ProviderSessionStatus = Schema18.Literals([
+var ProviderSessionStatus = Schema20.Literals([
   "connecting",
   "ready",
   "running",
   "error",
   "closed"
 ]);
-var ProviderSession = Schema18.Struct({
+var ProviderSession = Schema20.Struct({
   provider: ProviderKind,
   status: ProviderSessionStatus,
   runtimeMode: RuntimeMode,
-  cwd: Schema18.optional(TrimmedNonEmptyStringSchema2),
-  model: Schema18.optional(TrimmedNonEmptyStringSchema2),
+  cwd: Schema20.optional(TrimmedNonEmptyStringSchema2),
+  model: Schema20.optional(TrimmedNonEmptyStringSchema2),
   threadId: ThreadId,
-  resumeCursor: Schema18.optional(Schema18.Unknown),
-  activeTurnId: Schema18.optional(TurnId),
+  resumeCursor: Schema20.optional(Schema20.Unknown),
+  activeTurnId: Schema20.optional(TurnId),
   createdAt: IsoDateTime,
   updatedAt: IsoDateTime,
-  lastError: Schema18.optional(TrimmedNonEmptyStringSchema2)
+  lastError: Schema20.optional(TrimmedNonEmptyStringSchema2)
 });
-var CodexProviderStartOptions = Schema18.Struct({
-  binaryPath: Schema18.optional(TrimmedNonEmptyStringSchema2),
-  homePath: Schema18.optional(TrimmedNonEmptyStringSchema2)
+var CodexProviderStartOptions = Schema20.Struct({
+  binaryPath: Schema20.optional(TrimmedNonEmptyStringSchema2),
+  homePath: Schema20.optional(TrimmedNonEmptyStringSchema2)
 });
-var ProviderStartOptions = Schema18.Struct({
-  codex: Schema18.optional(CodexProviderStartOptions)
+var ProviderStartOptions = Schema20.Struct({
+  codex: Schema20.optional(CodexProviderStartOptions)
 });
-var ProviderSessionStartInput = Schema18.Struct({
+var ProviderSessionStartInput = Schema20.Struct({
   threadId: ThreadId,
-  provider: Schema18.optional(ProviderKind),
-  cwd: Schema18.optional(TrimmedNonEmptyStringSchema2),
-  model: Schema18.optional(TrimmedNonEmptyStringSchema2),
-  modelOptions: Schema18.optional(ProviderModelOptions),
-  resumeCursor: Schema18.optional(Schema18.Unknown),
-  serviceTier: Schema18.optional(Schema18.NullOr(ProviderServiceTier)),
-  approvalPolicy: Schema18.optional(ProviderApprovalPolicy),
-  sandboxMode: Schema18.optional(ProviderSandboxMode),
-  providerOptions: Schema18.optional(ProviderStartOptions),
+  provider: Schema20.optional(ProviderKind),
+  cwd: Schema20.optional(TrimmedNonEmptyStringSchema2),
+  model: Schema20.optional(TrimmedNonEmptyStringSchema2),
+  modelOptions: Schema20.optional(ProviderModelOptions),
+  resumeCursor: Schema20.optional(Schema20.Unknown),
+  serviceTier: Schema20.optional(Schema20.NullOr(ProviderServiceTier)),
+  approvalPolicy: Schema20.optional(ProviderApprovalPolicy),
+  sandboxMode: Schema20.optional(ProviderSandboxMode),
+  providerOptions: Schema20.optional(ProviderStartOptions),
   runtimeMode: RuntimeMode
 });
-var ProviderSendTurnInput = Schema18.Struct({
+var ProviderSendTurnInput = Schema20.Struct({
   threadId: ThreadId,
-  input: Schema18.optional(TrimmedNonEmptyStringSchema2.check(Schema18.isMaxLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS))),
-  attachments: Schema18.optional(Schema18.Array(ChatAttachment).check(Schema18.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS))),
-  model: Schema18.optional(TrimmedNonEmptyStringSchema2),
-  serviceTier: Schema18.optional(Schema18.NullOr(ProviderServiceTier)),
-  modelOptions: Schema18.optional(ProviderModelOptions),
-  interactionMode: Schema18.optional(ProviderInteractionMode)
-});
-var ProviderTurnStartResult = Schema18.Struct({
+  input: Schema20.optional(TrimmedNonEmptyStringSchema2.check(Schema20.isMaxLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS))),
+  attachments: Schema20.optional(Schema20.Array(ChatAttachment).check(Schema20.isMaxLength(PROVIDER_SEND_TURN_MAX_ATTACHMENTS))),
+  model: Schema20.optional(TrimmedNonEmptyStringSchema2),
+  serviceTier: Schema20.optional(Schema20.NullOr(ProviderServiceTier)),
+  modelOptions: Schema20.optional(ProviderModelOptions),
+  interactionMode: Schema20.optional(ProviderInteractionMode)
+});
+var ProviderTurnStartResult = Schema20.Struct({
   threadId: ThreadId,
   turnId: TurnId,
-  resumeCursor: Schema18.optional(Schema18.Unknown)
+  resumeCursor: Schema20.optional(Schema20.Unknown)
 });
-var ProviderInterruptTurnInput = Schema18.Struct({
+var ProviderInterruptTurnInput = Schema20.Struct({
   threadId: ThreadId,
-  turnId: Schema18.optional(TurnId)
+  turnId: Schema20.optional(TurnId)
 });
-var ProviderStopSessionInput = Schema18.Struct({
+var ProviderStopSessionInput = Schema20.Struct({
   threadId: ThreadId
 });
-var ProviderRespondToRequestInput = Schema18.Struct({
+var ProviderRespondToRequestInput = Schema20.Struct({
   threadId: ThreadId,
   requestId: ApprovalRequestId,
   decision: ProviderApprovalDecision
 });
-var ProviderRespondToUserInputInput = Schema18.Struct({
+var ProviderRespondToUserInputInput = Schema20.Struct({
   threadId: ThreadId,
   requestId: ApprovalRequestId,
   answers: ProviderUserInputAnswers
 });
-var ProviderEventKind = Schema18.Literals(["session", "notification", "request", "error"]);
-var ProviderEvent = Schema18.Struct({
+var ProviderEventKind = Schema20.Literals(["session", "notification", "request", "error"]);
+var ProviderEvent = Schema20.Struct({
   id: EventId,
   kind: ProviderEventKind,
   provider: ProviderKind,
   threadId: ThreadId,
   createdAt: IsoDateTime,
   method: TrimmedNonEmptyStringSchema2,
-  message: Schema18.optional(TrimmedNonEmptyStringSchema2),
-  turnId: Schema18.optional(TurnId),
-  itemId: Schema18.optional(ProviderItemId),
-  requestId: Schema18.optional(ApprovalRequestId),
-  requestKind: Schema18.optional(ProviderRequestKind),
-  textDelta: Schema18.optional(Schema18.String),
-  payload: Schema18.optional(Schema18.Unknown)
+  message: Schema20.optional(TrimmedNonEmptyStringSchema2),
+  turnId: Schema20.optional(TurnId),
+  itemId: Schema20.optional(ProviderItemId),
+  requestId: Schema20.optional(ApprovalRequestId),
+  requestKind: Schema20.optional(ProviderRequestKind),
+  textDelta: Schema20.optional(Schema20.String),
+  payload: Schema20.optional(Schema20.Unknown)
 });
 // packages/contracts/src/providerRuntime.ts
-import { Schema as Schema19 } from "effect";
+import { Schema as Schema21 } from "effect";
 var TrimmedNonEmptyStringSchema3 = TrimmedNonEmptyString;
-var UnknownRecordSchema = Schema19.Record(Schema19.String, Schema19.Unknown);
-var RuntimeEventRawSource = Schema19.Literals([
+var UnknownRecordSchema = Schema21.Record(Schema21.String, Schema21.Unknown);
+var RuntimeEventRawSource = Schema21.Literals([
   "codex.app-server.notification",
   "codex.app-server.request",
   "codex.eventmsg",
   "codex.sdk.thread-event",
   "claude.cli.stream-json"
 ]);
-var RuntimeEventRaw = Schema19.Struct({
+var RuntimeEventRaw = Schema21.Struct({
   source: RuntimeEventRawSource,
-  method: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  messageType: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  payload: Schema19.Unknown
+  method: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  messageType: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  payload: Schema21.Unknown
 });
 var ProviderRequestId = TrimmedNonEmptyStringSchema3;
-var ProviderRefs = Schema19.Struct({
-  providerTurnId: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  providerItemId: Schema19.optional(ProviderItemId),
-  providerRequestId: Schema19.optional(ProviderRequestId)
+var ProviderRefs = Schema21.Struct({
+  providerTurnId: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  providerItemId: Schema21.optional(ProviderItemId),
+  providerRequestId: Schema21.optional(ProviderRequestId)
 });
-var RuntimeSessionState = Schema19.Literals([
+var RuntimeSessionState = Schema21.Literals([
   "starting",
   "ready",
   "running",
@@ -2846,7 +3337,7 @@ var RuntimeSessionState = Schema19.Literals([
   "stopped",
   "error"
 ]);
-var RuntimeThreadState = Schema19.Literals([
+var RuntimeThreadState = Schema21.Literals([
   "active",
   "idle",
   "archived",
@@ -2854,15 +3345,15 @@ var RuntimeThreadState = Schema19.Literals([
   "compacted",
   "error"
 ]);
-var RuntimeTurnState = Schema19.Literals([
+var RuntimeTurnState = Schema21.Literals([
   "completed",
   "failed",
   "interrupted",
   "cancelled"
 ]);
-var RuntimePlanStepStatus = Schema19.Literals(["pending", "inProgress", "completed"]);
-var RuntimeItemStatus = Schema19.Literals(["inProgress", "completed", "failed", "declined"]);
-var RuntimeContentStreamKind = Schema19.Literals([
+var RuntimePlanStepStatus = Schema21.Literals(["pending", "inProgress", "completed"]);
+var RuntimeItemStatus = Schema21.Literals(["inProgress", "completed", "failed", "declined"]);
+var RuntimeContentStreamKind = Schema21.Literals([
   "assistant_text",
   "reasoning_text",
   "reasoning_summary_text",
@@ -2871,15 +3362,15 @@ var RuntimeContentStreamKind = Schema19.Literals([
   "file_change_output",
   "unknown"
 ]);
-var RuntimeSessionExitKind = Schema19.Literals(["graceful", "error"]);
-var RuntimeErrorClass = Schema19.Literals([
+var RuntimeSessionExitKind = Schema21.Literals(["graceful", "error"]);
+var RuntimeErrorClass = Schema21.Literals([
   "provider_error",
   "transport_error",
   "permission_error",
   "validation_error",
   "unknown"
 ]);
-var CanonicalItemType = Schema19.Literals([
+var CanonicalItemType = Schema21.Literals([
   "user_message",
   "assistant_message",
   "reasoning",
@@ -2897,7 +3388,7 @@ var CanonicalItemType = Schema19.Literals([
   "error",
   "unknown"
 ]);
-var CanonicalRequestType = Schema19.Literals([
+var CanonicalRequestType = Schema21.Literals([
   "command_execution_approval",
   "file_read_approval",
   "file_change_approval",
@@ -2908,7 +3399,7 @@ var CanonicalRequestType = Schema19.Literals([
   "auth_tokens_refresh",
   "unknown"
 ]);
-var ProviderRuntimeEventType = Schema19.Literals([
+var ProviderRuntimeEventType = Schema21.Literals([
   "session.started",
   "session.configured",
   "session.state.changed",
@@ -2957,516 +3448,516 @@ var ProviderRuntimeEventType = Schema19.Literals([
   "runtime.warning",
   "runtime.error"
 ]);
-var SessionStartedType = Schema19.Literal("session.started");
-var SessionConfiguredType = Schema19.Literal("session.configured");
-var SessionStateChangedType = Schema19.Literal("session.state.changed");
-var SessionExitedType = Schema19.Literal("session.exited");
-var ThreadStartedType = Schema19.Literal("thread.started");
-var ThreadStateChangedType = Schema19.Literal("thread.state.changed");
-var ThreadMetadataUpdatedType = Schema19.Literal("thread.metadata.updated");
-var ThreadTokenUsageUpdatedType = Schema19.Literal("thread.token-usage.updated");
-var ThreadRealtimeStartedType = Schema19.Literal("thread.realtime.started");
-var ThreadRealtimeItemAddedType = Schema19.Literal("thread.realtime.item-added");
-var ThreadRealtimeAudioDeltaType = Schema19.Literal("thread.realtime.audio.delta");
-var ThreadRealtimeErrorType = Schema19.Literal("thread.realtime.error");
-var ThreadRealtimeClosedType = Schema19.Literal("thread.realtime.closed");
-var TurnStartedType = Schema19.Literal("turn.started");
-var TurnCompletedType = Schema19.Literal("turn.completed");
-var TurnAbortedType = Schema19.Literal("turn.aborted");
-var TurnPlanUpdatedType = Schema19.Literal("turn.plan.updated");
-var TurnProposedDeltaType = Schema19.Literal("turn.proposed.delta");
-var TurnProposedCompletedType = Schema19.Literal("turn.proposed.completed");
-var TurnDiffUpdatedType = Schema19.Literal("turn.diff.updated");
-var ItemStartedType = Schema19.Literal("item.started");
-var ItemUpdatedType = Schema19.Literal("item.updated");
-var ItemCompletedType = Schema19.Literal("item.completed");
-var ContentDeltaType = Schema19.Literal("content.delta");
-var RequestOpenedType = Schema19.Literal("request.opened");
-var RequestResolvedType = Schema19.Literal("request.resolved");
-var UserInputRequestedType = Schema19.Literal("user-input.requested");
-var UserInputResolvedType = Schema19.Literal("user-input.resolved");
-var TaskStartedType = Schema19.Literal("task.started");
-var TaskProgressType = Schema19.Literal("task.progress");
-var TaskCompletedType = Schema19.Literal("task.completed");
-var HookStartedType = Schema19.Literal("hook.started");
-var HookProgressType = Schema19.Literal("hook.progress");
-var HookCompletedType = Schema19.Literal("hook.completed");
-var ToolProgressType = Schema19.Literal("tool.progress");
-var ToolSummaryType = Schema19.Literal("tool.summary");
-var AuthStatusType = Schema19.Literal("auth.status");
-var AccountUpdatedType = Schema19.Literal("account.updated");
-var AccountRateLimitsUpdatedType = Schema19.Literal("account.rate-limits.updated");
-var McpStatusUpdatedType = Schema19.Literal("mcp.status.updated");
-var McpOauthCompletedType = Schema19.Literal("mcp.oauth.completed");
-var ModelReroutedType = Schema19.Literal("model.rerouted");
-var ConfigWarningType = Schema19.Literal("config.warning");
-var DeprecationNoticeType = Schema19.Literal("deprecation.notice");
-var FilesPersistedType = Schema19.Literal("files.persisted");
-var RuntimeWarningType = Schema19.Literal("runtime.warning");
-var RuntimeErrorType = Schema19.Literal("runtime.error");
-var ProviderRuntimeEventBase = Schema19.Struct({
+var SessionStartedType = Schema21.Literal("session.started");
+var SessionConfiguredType = Schema21.Literal("session.configured");
+var SessionStateChangedType = Schema21.Literal("session.state.changed");
+var SessionExitedType = Schema21.Literal("session.exited");
+var ThreadStartedType = Schema21.Literal("thread.started");
+var ThreadStateChangedType = Schema21.Literal("thread.state.changed");
+var ThreadMetadataUpdatedType = Schema21.Literal("thread.metadata.updated");
+var ThreadTokenUsageUpdatedType = Schema21.Literal("thread.token-usage.updated");
+var ThreadRealtimeStartedType = Schema21.Literal("thread.realtime.started");
+var ThreadRealtimeItemAddedType = Schema21.Literal("thread.realtime.item-added");
+var ThreadRealtimeAudioDeltaType = Schema21.Literal("thread.realtime.audio.delta");
+var ThreadRealtimeErrorType = Schema21.Literal("thread.realtime.error");
+var ThreadRealtimeClosedType = Schema21.Literal("thread.realtime.closed");
+var TurnStartedType = Schema21.Literal("turn.started");
+var TurnCompletedType = Schema21.Literal("turn.completed");
+var TurnAbortedType = Schema21.Literal("turn.aborted");
+var TurnPlanUpdatedType = Schema21.Literal("turn.plan.updated");
+var TurnProposedDeltaType = Schema21.Literal("turn.proposed.delta");
+var TurnProposedCompletedType = Schema21.Literal("turn.proposed.completed");
+var TurnDiffUpdatedType = Schema21.Literal("turn.diff.updated");
+var ItemStartedType = Schema21.Literal("item.started");
+var ItemUpdatedType = Schema21.Literal("item.updated");
+var ItemCompletedType = Schema21.Literal("item.completed");
+var ContentDeltaType = Schema21.Literal("content.delta");
+var RequestOpenedType = Schema21.Literal("request.opened");
+var RequestResolvedType = Schema21.Literal("request.resolved");
+var UserInputRequestedType = Schema21.Literal("user-input.requested");
+var UserInputResolvedType = Schema21.Literal("user-input.resolved");
+var TaskStartedType = Schema21.Literal("task.started");
+var TaskProgressType = Schema21.Literal("task.progress");
+var TaskCompletedType = Schema21.Literal("task.completed");
+var HookStartedType = Schema21.Literal("hook.started");
+var HookProgressType = Schema21.Literal("hook.progress");
+var HookCompletedType = Schema21.Literal("hook.completed");
+var ToolProgressType = Schema21.Literal("tool.progress");
+var ToolSummaryType = Schema21.Literal("tool.summary");
+var AuthStatusType = Schema21.Literal("auth.status");
+var AccountUpdatedType = Schema21.Literal("account.updated");
+var AccountRateLimitsUpdatedType = Schema21.Literal("account.rate-limits.updated");
+var McpStatusUpdatedType = Schema21.Literal("mcp.status.updated");
+var McpOauthCompletedType = Schema21.Literal("mcp.oauth.completed");
+var ModelReroutedType = Schema21.Literal("model.rerouted");
+var ConfigWarningType = Schema21.Literal("config.warning");
+var DeprecationNoticeType = Schema21.Literal("deprecation.notice");
+var FilesPersistedType = Schema21.Literal("files.persisted");
+var RuntimeWarningType = Schema21.Literal("runtime.warning");
+var RuntimeErrorType = Schema21.Literal("runtime.error");
+var ProviderRuntimeEventBase = Schema21.Struct({
   eventId: EventId,
   provider: ProviderKind,
   threadId: ThreadId,
   createdAt: IsoDateTime,
-  turnId: Schema19.optional(TurnId),
-  itemId: Schema19.optional(RuntimeItemId),
-  requestId: Schema19.optional(RuntimeRequestId),
-  providerRefs: Schema19.optional(ProviderRefs),
-  raw: Schema19.optional(RuntimeEventRaw)
+  turnId: Schema21.optional(TurnId),
+  itemId: Schema21.optional(RuntimeItemId),
+  requestId: Schema21.optional(RuntimeRequestId),
+  providerRefs: Schema21.optional(ProviderRefs),
+  raw: Schema21.optional(RuntimeEventRaw)
 });
-var SessionStartedPayload = Schema19.Struct({
-  message: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  resume: Schema19.optional(Schema19.Unknown)
+var SessionStartedPayload = Schema21.Struct({
+  message: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  resume: Schema21.optional(Schema21.Unknown)
 });
-var SessionConfiguredPayload = Schema19.Struct({
+var SessionConfiguredPayload = Schema21.Struct({
   config: UnknownRecordSchema
 });
-var SessionStateChangedPayload = Schema19.Struct({
+var SessionStateChangedPayload = Schema21.Struct({
   state: RuntimeSessionState,
-  reason: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  detail: Schema19.optional(Schema19.Unknown)
+  reason: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  detail: Schema21.optional(Schema21.Unknown)
 });
-var SessionExitedPayload = Schema19.Struct({
-  reason: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  recoverable: Schema19.optional(Schema19.Boolean),
-  exitKind: Schema19.optional(RuntimeSessionExitKind)
+var SessionExitedPayload = Schema21.Struct({
+  reason: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  recoverable: Schema21.optional(Schema21.Boolean),
+  exitKind: Schema21.optional(RuntimeSessionExitKind)
 });
-var ThreadStartedPayload = Schema19.Struct({
-  providerThreadId: Schema19.optional(TrimmedNonEmptyStringSchema3)
+var ThreadStartedPayload = Schema21.Struct({
+  providerThreadId: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var ThreadStateChangedPayload = Schema19.Struct({
+var ThreadStateChangedPayload = Schema21.Struct({
   state: RuntimeThreadState,
-  detail: Schema19.optional(Schema19.Unknown)
+  detail: Schema21.optional(Schema21.Unknown)
 });
-var ThreadMetadataUpdatedPayload = Schema19.Struct({
-  name: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  metadata: Schema19.optional(UnknownRecordSchema)
+var ThreadMetadataUpdatedPayload = Schema21.Struct({
+  name: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  metadata: Schema21.optional(UnknownRecordSchema)
 });
-var ThreadTokenUsageUpdatedPayload = Schema19.Struct({
-  usage: Schema19.Unknown
+var ThreadTokenUsageUpdatedPayload = Schema21.Struct({
+  usage: Schema21.Unknown
 });
-var ThreadRealtimeStartedPayload = Schema19.Struct({
-  realtimeSessionId: Schema19.optional(TrimmedNonEmptyStringSchema3)
+var ThreadRealtimeStartedPayload = Schema21.Struct({
+  realtimeSessionId: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var ThreadRealtimeItemAddedPayload = Schema19.Struct({
-  item: Schema19.Unknown
+var ThreadRealtimeItemAddedPayload = Schema21.Struct({
+  item: Schema21.Unknown
 });
-var ThreadRealtimeAudioDeltaPayload = Schema19.Struct({
-  audio: Schema19.Unknown
+var ThreadRealtimeAudioDeltaPayload = Schema21.Struct({
+  audio: Schema21.Unknown
 });
-var ThreadRealtimeErrorPayload = Schema19.Struct({
+var ThreadRealtimeErrorPayload = Schema21.Struct({
   message: TrimmedNonEmptyStringSchema3
 });
-var ThreadRealtimeClosedPayload = Schema19.Struct({
-  reason: Schema19.optional(TrimmedNonEmptyStringSchema3)
+var ThreadRealtimeClosedPayload = Schema21.Struct({
+  reason: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var TurnStartedPayload = Schema19.Struct({
-  model: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  effort: Schema19.optional(TrimmedNonEmptyStringSchema3)
+var TurnStartedPayload = Schema21.Struct({
+  model: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  effort: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var TurnCompletedPayload = Schema19.Struct({
+var TurnCompletedPayload = Schema21.Struct({
   state: RuntimeTurnState,
-  stopReason: Schema19.optional(Schema19.NullOr(TrimmedNonEmptyStringSchema3)),
-  usage: Schema19.optional(Schema19.Unknown),
-  modelUsage: Schema19.optional(UnknownRecordSchema),
-  totalCostUsd: Schema19.optional(Schema19.Number),
-  errorMessage: Schema19.optional(TrimmedNonEmptyStringSchema3)
+  stopReason: Schema21.optional(Schema21.NullOr(TrimmedNonEmptyStringSchema3)),
+  usage: Schema21.optional(Schema21.Unknown),
+  modelUsage: Schema21.optional(UnknownRecordSchema),
+  totalCostUsd: Schema21.optional(Schema21.Number),
+  errorMessage: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var TurnAbortedPayload = Schema19.Struct({
+var TurnAbortedPayload = Schema21.Struct({
   reason: TrimmedNonEmptyStringSchema3
 });
-var RuntimePlanStep = Schema19.Struct({
+var RuntimePlanStep = Schema21.Struct({
   step: TrimmedNonEmptyStringSchema3,
   status: RuntimePlanStepStatus
 });
-var TurnPlanUpdatedPayload = Schema19.Struct({
-  explanation: Schema19.optional(Schema19.NullOr(TrimmedNonEmptyStringSchema3)),
-  plan: Schema19.Array(RuntimePlanStep)
+var TurnPlanUpdatedPayload = Schema21.Struct({
+  explanation: Schema21.optional(Schema21.NullOr(TrimmedNonEmptyStringSchema3)),
+  plan: Schema21.Array(RuntimePlanStep)
 });
-var TurnProposedDeltaPayload = Schema19.Struct({
-  delta: Schema19.String
+var TurnProposedDeltaPayload = Schema21.Struct({
+  delta: Schema21.String
 });
-var TurnProposedCompletedPayload = Schema19.Struct({
+var TurnProposedCompletedPayload = Schema21.Struct({
   planMarkdown: TrimmedNonEmptyStringSchema3
 });
-var TurnDiffUpdatedPayload = Schema19.Struct({
-  unifiedDiff: Schema19.String
+var TurnDiffUpdatedPayload = Schema21.Struct({
+  unifiedDiff: Schema21.String
 });
-var ItemLifecyclePayload = Schema19.Struct({
+var ItemLifecyclePayload = Schema21.Struct({
   itemType: CanonicalItemType,
-  status: Schema19.optional(RuntimeItemStatus),
-  title: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  detail: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  data: Schema19.optional(Schema19.Unknown)
+  status: Schema21.optional(RuntimeItemStatus),
+  title: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  detail: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  data: Schema21.optional(Schema21.Unknown)
 });
-var ContentDeltaPayload = Schema19.Struct({
+var ContentDeltaPayload = Schema21.Struct({
   streamKind: RuntimeContentStreamKind,
-  delta: Schema19.String,
-  contentIndex: Schema19.optional(Schema19.Int),
-  summaryIndex: Schema19.optional(Schema19.Int)
+  delta: Schema21.String,
+  contentIndex: Schema21.optional(Schema21.Int),
+  summaryIndex: Schema21.optional(Schema21.Int)
 });
-var RequestOpenedPayload = Schema19.Struct({
+var RequestOpenedPayload = Schema21.Struct({
   requestType: CanonicalRequestType,
-  detail: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  args: Schema19.optional(Schema19.Unknown)
+  detail: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  args: Schema21.optional(Schema21.Unknown)
 });
-var RequestResolvedPayload = Schema19.Struct({
+var RequestResolvedPayload = Schema21.Struct({
   requestType: CanonicalRequestType,
-  decision: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  resolution: Schema19.optional(Schema19.Unknown)
+  decision: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  resolution: Schema21.optional(Schema21.Unknown)
 });
-var UserInputQuestionOption = Schema19.Struct({
+var UserInputQuestionOption = Schema21.Struct({
   label: TrimmedNonEmptyStringSchema3,
   description: TrimmedNonEmptyStringSchema3
 });
-var UserInputQuestion = Schema19.Struct({
+var UserInputQuestion = Schema21.Struct({
   id: TrimmedNonEmptyStringSchema3,
   header: TrimmedNonEmptyStringSchema3,
   question: TrimmedNonEmptyStringSchema3,
-  options: Schema19.Array(UserInputQuestionOption)
+  options: Schema21.Array(UserInputQuestionOption)
 });
-var UserInputRequestedPayload = Schema19.Struct({
-  questions: Schema19.Array(UserInputQuestion)
+var UserInputRequestedPayload = Schema21.Struct({
+  questions: Schema21.Array(UserInputQuestion)
 });
-var UserInputResolvedPayload = Schema19.Struct({
+var UserInputResolvedPayload = Schema21.Struct({
   answers: UnknownRecordSchema
 });
-var TaskStartedPayload = Schema19.Struct({
+var TaskStartedPayload = Schema21.Struct({
   taskId: RuntimeTaskId,
-  description: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  taskType: Schema19.optional(TrimmedNonEmptyStringSchema3)
+  description: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  taskType: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var TaskProgressPayload = Schema19.Struct({
+var TaskProgressPayload = Schema21.Struct({
   taskId: RuntimeTaskId,
   description: TrimmedNonEmptyStringSchema3,
-  usage: Schema19.optional(Schema19.Unknown),
-  lastToolName: Schema19.optional(TrimmedNonEmptyStringSchema3)
+  usage: Schema21.optional(Schema21.Unknown),
+  lastToolName: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var TaskCompletedPayload = Schema19.Struct({
+var TaskCompletedPayload = Schema21.Struct({
   taskId: RuntimeTaskId,
-  status: Schema19.Literals(["completed", "failed", "stopped"]),
-  summary: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  usage: Schema19.optional(Schema19.Unknown)
+  status: Schema21.Literals(["completed", "failed", "stopped"]),
+  summary: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  usage: Schema21.optional(Schema21.Unknown)
 });
-var HookStartedPayload = Schema19.Struct({
+var HookStartedPayload = Schema21.Struct({
   hookId: TrimmedNonEmptyStringSchema3,
   hookName: TrimmedNonEmptyStringSchema3,
   hookEvent: TrimmedNonEmptyStringSchema3
 });
-var HookProgressPayload = Schema19.Struct({
+var HookProgressPayload = Schema21.Struct({
   hookId: TrimmedNonEmptyStringSchema3,
-  output: Schema19.optional(Schema19.String),
-  stdout: Schema19.optional(Schema19.String),
-  stderr: Schema19.optional(Schema19.String)
+  output: Schema21.optional(Schema21.String),
+  stdout: Schema21.optional(Schema21.String),
+  stderr: Schema21.optional(Schema21.String)
 });
-var HookCompletedPayload = Schema19.Struct({
+var HookCompletedPayload = Schema21.Struct({
   hookId: TrimmedNonEmptyStringSchema3,
-  outcome: Schema19.Literals(["success", "error", "cancelled"]),
-  output: Schema19.optional(Schema19.String),
-  stdout: Schema19.optional(Schema19.String),
-  stderr: Schema19.optional(Schema19.String),
-  exitCode: Schema19.optional(Schema19.Int)
-});
-var ToolProgressPayload = Schema19.Struct({
-  toolUseId: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  toolName: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  summary: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  elapsedSeconds: Schema19.optional(Schema19.Number)
-});
-var ToolSummaryPayload = Schema19.Struct({
+  outcome: Schema21.Literals(["success", "error", "cancelled"]),
+  output: Schema21.optional(Schema21.String),
+  stdout: Schema21.optional(Schema21.String),
+  stderr: Schema21.optional(Schema21.String),
+  exitCode: Schema21.optional(Schema21.Int)
+});
+var ToolProgressPayload = Schema21.Struct({
+  toolUseId: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  toolName: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  summary: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  elapsedSeconds: Schema21.optional(Schema21.Number)
+});
+var ToolSummaryPayload = Schema21.Struct({
   summary: TrimmedNonEmptyStringSchema3,
-  precedingToolUseIds: Schema19.optional(Schema19.Array(TrimmedNonEmptyStringSchema3))
+  precedingToolUseIds: Schema21.optional(Schema21.Array(TrimmedNonEmptyStringSchema3))
 });
-var AuthStatusPayload = Schema19.Struct({
-  isAuthenticating: Schema19.optional(Schema19.Boolean),
-  output: Schema19.optional(Schema19.Array(Schema19.String)),
-  error: Schema19.optional(TrimmedNonEmptyStringSchema3)
+var AuthStatusPayload = Schema21.Struct({
+  isAuthenticating: Schema21.optional(Schema21.Boolean),
+  output: Schema21.optional(Schema21.Array(Schema21.String)),
+  error: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var AccountUpdatedPayload = Schema19.Struct({
-  account: Schema19.Unknown
+var AccountUpdatedPayload = Schema21.Struct({
+  account: Schema21.Unknown
 });
-var AccountRateLimitsUpdatedPayload = Schema19.Struct({
-  rateLimits: Schema19.Unknown
+var AccountRateLimitsUpdatedPayload = Schema21.Struct({
+  rateLimits: Schema21.Unknown
 });
-var McpStatusUpdatedPayload = Schema19.Struct({
-  status: Schema19.Unknown
+var McpStatusUpdatedPayload = Schema21.Struct({
+  status: Schema21.Unknown
 });
-var McpOauthCompletedPayload = Schema19.Struct({
-  success: Schema19.Boolean,
-  name: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  error: Schema19.optional(TrimmedNonEmptyStringSchema3)
+var McpOauthCompletedPayload = Schema21.Struct({
+  success: Schema21.Boolean,
+  name: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  error: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var ModelReroutedPayload = Schema19.Struct({
+var ModelReroutedPayload = Schema21.Struct({
   fromModel: TrimmedNonEmptyStringSchema3,
   toModel: TrimmedNonEmptyStringSchema3,
   reason: TrimmedNonEmptyStringSchema3
 });
-var ConfigWarningPayload = Schema19.Struct({
+var ConfigWarningPayload = Schema21.Struct({
   summary: TrimmedNonEmptyStringSchema3,
-  details: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  path: Schema19.optional(TrimmedNonEmptyStringSchema3),
-  range: Schema19.optional(Schema19.Unknown)
+  details: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  path: Schema21.optional(TrimmedNonEmptyStringSchema3),
+  range: Schema21.optional(Schema21.Unknown)
 });
-var DeprecationNoticePayload = Schema19.Struct({
+var DeprecationNoticePayload = Schema21.Struct({
   summary: TrimmedNonEmptyStringSchema3,
-  details: Schema19.optional(TrimmedNonEmptyStringSchema3)
+  details: Schema21.optional(TrimmedNonEmptyStringSchema3)
 });
-var FilesPersistedPayload = Schema19.Struct({
-  files: Schema19.Array(Schema19.Struct({
+var FilesPersistedPayload = Schema21.Struct({
+  files: Schema21.Array(Schema21.Struct({
     filename: TrimmedNonEmptyStringSchema3,
     fileId: TrimmedNonEmptyStringSchema3
   })),
-  failed: Schema19.optional(Schema19.Array(Schema19.Struct({
+  failed: Schema21.optional(Schema21.Array(Schema21.Struct({
     filename: TrimmedNonEmptyStringSchema3,
     error: TrimmedNonEmptyStringSchema3
   })))
 });
-var RuntimeWarningPayload = Schema19.Struct({
+var RuntimeWarningPayload = Schema21.Struct({
   message: TrimmedNonEmptyStringSchema3,
-  detail: Schema19.optional(Schema19.Unknown)
+  detail: Schema21.optional(Schema21.Unknown)
 });
-var RuntimeErrorPayload = Schema19.Struct({
+var RuntimeErrorPayload = Schema21.Struct({
   message: TrimmedNonEmptyStringSchema3,
-  class: Schema19.optional(RuntimeErrorClass),
-  detail: Schema19.optional(Schema19.Unknown)
+  class: Schema21.optional(RuntimeErrorClass),
+  detail: Schema21.optional(Schema21.Unknown)
 });
-var ProviderRuntimeSessionStartedEvent = Schema19.Struct({
+var ProviderRuntimeSessionStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: SessionStartedType,
   payload: SessionStartedPayload
 });
-var ProviderRuntimeSessionConfiguredEvent = Schema19.Struct({
+var ProviderRuntimeSessionConfiguredEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: SessionConfiguredType,
   payload: SessionConfiguredPayload
 });
-var ProviderRuntimeSessionStateChangedEvent = Schema19.Struct({
+var ProviderRuntimeSessionStateChangedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: SessionStateChangedType,
   payload: SessionStateChangedPayload
 });
-var ProviderRuntimeSessionExitedEvent = Schema19.Struct({
+var ProviderRuntimeSessionExitedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: SessionExitedType,
   payload: SessionExitedPayload
 });
-var ProviderRuntimeThreadStartedEvent = Schema19.Struct({
+var ProviderRuntimeThreadStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadStartedType,
   payload: ThreadStartedPayload
 });
-var ProviderRuntimeThreadStateChangedEvent = Schema19.Struct({
+var ProviderRuntimeThreadStateChangedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadStateChangedType,
   payload: ThreadStateChangedPayload
 });
-var ProviderRuntimeThreadMetadataUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeThreadMetadataUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadMetadataUpdatedType,
   payload: ThreadMetadataUpdatedPayload
 });
-var ProviderRuntimeThreadTokenUsageUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeThreadTokenUsageUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadTokenUsageUpdatedType,
   payload: ThreadTokenUsageUpdatedPayload
 });
-var ProviderRuntimeThreadRealtimeStartedEvent = Schema19.Struct({
+var ProviderRuntimeThreadRealtimeStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadRealtimeStartedType,
   payload: ThreadRealtimeStartedPayload
 });
-var ProviderRuntimeThreadRealtimeItemAddedEvent = Schema19.Struct({
+var ProviderRuntimeThreadRealtimeItemAddedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadRealtimeItemAddedType,
   payload: ThreadRealtimeItemAddedPayload
 });
-var ProviderRuntimeThreadRealtimeAudioDeltaEvent = Schema19.Struct({
+var ProviderRuntimeThreadRealtimeAudioDeltaEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadRealtimeAudioDeltaType,
   payload: ThreadRealtimeAudioDeltaPayload
 });
-var ProviderRuntimeThreadRealtimeErrorEvent = Schema19.Struct({
+var ProviderRuntimeThreadRealtimeErrorEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadRealtimeErrorType,
   payload: ThreadRealtimeErrorPayload
 });
-var ProviderRuntimeThreadRealtimeClosedEvent = Schema19.Struct({
+var ProviderRuntimeThreadRealtimeClosedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ThreadRealtimeClosedType,
   payload: ThreadRealtimeClosedPayload
 });
-var ProviderRuntimeTurnStartedEvent = Schema19.Struct({
+var ProviderRuntimeTurnStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnStartedType,
   payload: TurnStartedPayload
 });
-var ProviderRuntimeTurnCompletedEvent = Schema19.Struct({
+var ProviderRuntimeTurnCompletedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnCompletedType,
   payload: TurnCompletedPayload
 });
-var ProviderRuntimeTurnAbortedEvent = Schema19.Struct({
+var ProviderRuntimeTurnAbortedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnAbortedType,
   payload: TurnAbortedPayload
 });
-var ProviderRuntimeTurnPlanUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeTurnPlanUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnPlanUpdatedType,
   payload: TurnPlanUpdatedPayload
 });
-var ProviderRuntimeTurnProposedDeltaEvent = Schema19.Struct({
+var ProviderRuntimeTurnProposedDeltaEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnProposedDeltaType,
   payload: TurnProposedDeltaPayload
 });
-var ProviderRuntimeTurnProposedCompletedEvent = Schema19.Struct({
+var ProviderRuntimeTurnProposedCompletedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnProposedCompletedType,
   payload: TurnProposedCompletedPayload
 });
-var ProviderRuntimeTurnDiffUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeTurnDiffUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TurnDiffUpdatedType,
   payload: TurnDiffUpdatedPayload
 });
-var ProviderRuntimeItemStartedEvent = Schema19.Struct({
+var ProviderRuntimeItemStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ItemStartedType,
   payload: ItemLifecyclePayload
 });
-var ProviderRuntimeItemUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeItemUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ItemUpdatedType,
   payload: ItemLifecyclePayload
 });
-var ProviderRuntimeItemCompletedEvent = Schema19.Struct({
+var ProviderRuntimeItemCompletedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ItemCompletedType,
   payload: ItemLifecyclePayload
 });
-var ProviderRuntimeContentDeltaEvent = Schema19.Struct({
+var ProviderRuntimeContentDeltaEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ContentDeltaType,
   payload: ContentDeltaPayload
 });
-var ProviderRuntimeRequestOpenedEvent = Schema19.Struct({
+var ProviderRuntimeRequestOpenedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: RequestOpenedType,
   payload: RequestOpenedPayload
 });
-var ProviderRuntimeRequestResolvedEvent = Schema19.Struct({
+var ProviderRuntimeRequestResolvedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: RequestResolvedType,
   payload: RequestResolvedPayload
 });
-var ProviderRuntimeUserInputRequestedEvent = Schema19.Struct({
+var ProviderRuntimeUserInputRequestedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: UserInputRequestedType,
   payload: UserInputRequestedPayload
 });
-var ProviderRuntimeUserInputResolvedEvent = Schema19.Struct({
+var ProviderRuntimeUserInputResolvedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: UserInputResolvedType,
   payload: UserInputResolvedPayload
 });
-var ProviderRuntimeTaskStartedEvent = Schema19.Struct({
+var ProviderRuntimeTaskStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TaskStartedType,
   payload: TaskStartedPayload
 });
-var ProviderRuntimeTaskProgressEvent = Schema19.Struct({
+var ProviderRuntimeTaskProgressEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TaskProgressType,
   payload: TaskProgressPayload
 });
-var ProviderRuntimeTaskCompletedEvent = Schema19.Struct({
+var ProviderRuntimeTaskCompletedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: TaskCompletedType,
   payload: TaskCompletedPayload
 });
-var ProviderRuntimeHookStartedEvent = Schema19.Struct({
+var ProviderRuntimeHookStartedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: HookStartedType,
   payload: HookStartedPayload
 });
-var ProviderRuntimeHookProgressEvent = Schema19.Struct({
+var ProviderRuntimeHookProgressEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: HookProgressType,
   payload: HookProgressPayload
 });
-var ProviderRuntimeHookCompletedEvent = Schema19.Struct({
+var ProviderRuntimeHookCompletedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: HookCompletedType,
   payload: HookCompletedPayload
 });
-var ProviderRuntimeToolProgressEvent = Schema19.Struct({
+var ProviderRuntimeToolProgressEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ToolProgressType,
   payload: ToolProgressPayload
 });
-var ProviderRuntimeToolSummaryEvent = Schema19.Struct({
+var ProviderRuntimeToolSummaryEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ToolSummaryType,
   payload: ToolSummaryPayload
 });
-var ProviderRuntimeAuthStatusEvent = Schema19.Struct({
+var ProviderRuntimeAuthStatusEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: AuthStatusType,
   payload: AuthStatusPayload
 });
-var ProviderRuntimeAccountUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeAccountUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: AccountUpdatedType,
   payload: AccountUpdatedPayload
 });
-var ProviderRuntimeAccountRateLimitsUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeAccountRateLimitsUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: AccountRateLimitsUpdatedType,
   payload: AccountRateLimitsUpdatedPayload
 });
-var ProviderRuntimeMcpStatusUpdatedEvent = Schema19.Struct({
+var ProviderRuntimeMcpStatusUpdatedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: McpStatusUpdatedType,
   payload: McpStatusUpdatedPayload
 });
-var ProviderRuntimeMcpOauthCompletedEvent = Schema19.Struct({
+var ProviderRuntimeMcpOauthCompletedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: McpOauthCompletedType,
   payload: McpOauthCompletedPayload
 });
-var ProviderRuntimeModelReroutedEvent = Schema19.Struct({
+var ProviderRuntimeModelReroutedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ModelReroutedType,
   payload: ModelReroutedPayload
 });
-var ProviderRuntimeConfigWarningEvent = Schema19.Struct({
+var ProviderRuntimeConfigWarningEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: ConfigWarningType,
   payload: ConfigWarningPayload
 });
-var ProviderRuntimeDeprecationNoticeEvent = Schema19.Struct({
+var ProviderRuntimeDeprecationNoticeEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: DeprecationNoticeType,
   payload: DeprecationNoticePayload
 });
-var ProviderRuntimeFilesPersistedEvent = Schema19.Struct({
+var ProviderRuntimeFilesPersistedEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: FilesPersistedType,
   payload: FilesPersistedPayload
 });
-var ProviderRuntimeWarningEvent = Schema19.Struct({
+var ProviderRuntimeWarningEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: RuntimeWarningType,
   payload: RuntimeWarningPayload
 });
-var ProviderRuntimeErrorEvent = Schema19.Struct({
+var ProviderRuntimeErrorEvent = Schema21.Struct({
   ...ProviderRuntimeEventBase.fields,
   type: RuntimeErrorType,
   payload: RuntimeErrorPayload
 });
-var ProviderRuntimeEventV2 = Schema19.Union([
+var ProviderRuntimeEventV2 = Schema21.Union([
   ProviderRuntimeSessionStartedEvent,
   ProviderRuntimeSessionConfiguredEvent,
   ProviderRuntimeSessionStateChangedEvent,
@@ -3516,7 +4007,7 @@ var ProviderRuntimeEventV2 = Schema19.Union([
   ProviderRuntimeErrorEvent
 ]);
 var ProviderRuntimeEvent = ProviderRuntimeEventV2;
-var ProviderRuntimeToolKind = Schema19.Literals([
+var ProviderRuntimeToolKind = Schema21.Literals([
   "command",
   "file-read",
   "file-change",
@@ -3524,91 +4015,91 @@ var ProviderRuntimeToolKind = Schema19.Literals([
 ]);
 var ProviderRuntimeTurnStatus = RuntimeTurnState;
 // packages/contracts/src/ws.ts
-import { Schema as Schema24, Struct as Struct2 } from "effect";
+import { Schema as Schema26, Struct as Struct2 } from "effect";
 
 // packages/contracts/src/git.ts
-import { Schema as Schema20 } from "effect";
+import { Schema as Schema22 } from "effect";
 var TrimmedNonEmptyStringSchema4 = TrimmedNonEmptyString;
-var GitStackedAction = Schema20.Literals(["commit", "commit_push", "commit_push_pr"]);
-var GitCommitStepStatus = Schema20.Literals(["created", "skipped_no_changes"]);
-var GitPushStepStatus = Schema20.Literals([
+var GitStackedAction = Schema22.Literals(["commit", "commit_push", "commit_push_pr"]);
+var GitCommitStepStatus = Schema22.Literals(["created", "skipped_no_changes"]);
+var GitPushStepStatus = Schema22.Literals([
   "pushed",
   "skipped_not_requested",
   "skipped_up_to_date"
 ]);
-var GitBranchStepStatus = Schema20.Literals(["created", "skipped_not_requested"]);
-var GitPrStepStatus = Schema20.Literals([
+var GitBranchStepStatus = Schema22.Literals(["created", "skipped_not_requested"]);
+var GitPrStepStatus = Schema22.Literals([
   "created",
   "opened_existing",
   "skipped_not_requested"
 ]);
-var GitStatusPrState = Schema20.Literals(["open", "closed", "merged"]);
-var GitBranch = Schema20.Struct({
+var GitStatusPrState = Schema22.Literals(["open", "closed", "merged"]);
+var GitBranch = Schema22.Struct({
   name: TrimmedNonEmptyStringSchema4,
-  isRemote: Schema20.optional(Schema20.Boolean),
-  remoteName: Schema20.optional(TrimmedNonEmptyStringSchema4),
-  current: Schema20.Boolean,
-  isDefault: Schema20.Boolean,
-  worktreePath: TrimmedNonEmptyStringSchema4.pipe(Schema20.NullOr)
+  isRemote: Schema22.optional(Schema22.Boolean),
+  remoteName: Schema22.optional(TrimmedNonEmptyStringSchema4),
+  current: Schema22.Boolean,
+  isDefault: Schema22.Boolean,
+  worktreePath: TrimmedNonEmptyStringSchema4.pipe(Schema22.NullOr)
 });
-var GitWorktree = Schema20.Struct({
+var GitWorktree = Schema22.Struct({
   path: TrimmedNonEmptyStringSchema4,
   branch: TrimmedNonEmptyStringSchema4
 });
-var GitStatusInput = Schema20.Struct({
+var GitStatusInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4
 });
-var GitPullInput = Schema20.Struct({
+var GitPullInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4
 });
-var GitReadWorkingTreePatchInput = Schema20.Struct({
+var GitReadWorkingTreePatchInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4,
-  relativePath: Schema20.optional(TrimmedNonEmptyStringSchema4)
+  relativePath: Schema22.optional(TrimmedNonEmptyStringSchema4)
 });
-var GitRunStackedActionInput = Schema20.Struct({
+var GitRunStackedActionInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4,
   action: GitStackedAction,
-  commitMessage: Schema20.optional(TrimmedNonEmptyStringSchema4.check(Schema20.isMaxLength(1e4))),
-  featureBranch: Schema20.optional(Schema20.Boolean)
+  commitMessage: Schema22.optional(TrimmedNonEmptyStringSchema4.check(Schema22.isMaxLength(1e4))),
+  featureBranch: Schema22.optional(Schema22.Boolean)
 });
-var GitListBranchesInput = Schema20.Struct({
+var GitListBranchesInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4
 });
-var GitCreateWorktreeInput = Schema20.Struct({
+var GitCreateWorktreeInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4,
   branch: TrimmedNonEmptyStringSchema4,
   newBranch: TrimmedNonEmptyStringSchema4,
-  path: Schema20.NullOr(TrimmedNonEmptyStringSchema4)
+  path: Schema22.NullOr(TrimmedNonEmptyStringSchema4)
 });
-var GitRemoveWorktreeInput = Schema20.Struct({
+var GitRemoveWorktreeInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4,
   path: TrimmedNonEmptyStringSchema4,
-  force: Schema20.optional(Schema20.Boolean)
+  force: Schema22.optional(Schema22.Boolean)
 });
-var GitCreateBranchInput = Schema20.Struct({
+var GitCreateBranchInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4,
   branch: TrimmedNonEmptyStringSchema4
 });
-var GitCheckoutInput = Schema20.Struct({
+var GitCheckoutInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4,
   branch: TrimmedNonEmptyStringSchema4
 });
-var GitInitInput = Schema20.Struct({
+var GitInitInput = Schema22.Struct({
   cwd: TrimmedNonEmptyStringSchema4
 });
-var GitStatusPr = Schema20.Struct({
+var GitStatusPr = Schema22.Struct({
   number: PositiveInt,
   title: TrimmedNonEmptyStringSchema4,
-  url: Schema20.String,
+  url: Schema22.String,
   baseBranch: TrimmedNonEmptyStringSchema4,
   headBranch: TrimmedNonEmptyStringSchema4,
   state: GitStatusPrState
 });
-var GitStatusResult = Schema20.Struct({
-  branch: TrimmedNonEmptyStringSchema4.pipe(Schema20.NullOr),
-  hasWorkingTreeChanges: Schema20.Boolean,
-  workingTree: Schema20.Struct({
-    files: Schema20.Array(Schema20.Struct({
+var GitStatusResult = Schema22.Struct({
+  branch: TrimmedNonEmptyStringSchema4.pipe(Schema22.NullOr),
+  hasWorkingTreeChanges: Schema22.Boolean,
+  workingTree: Schema22.Struct({
+    files: Schema22.Array(Schema22.Struct({
       path: TrimmedNonEmptyStringSchema4,
       insertions: NonNegativeInt,
       deletions: NonNegativeInt
@@ -3616,55 +4107,55 @@ var GitStatusResult = Schema20.Struct({
     insertions: NonNegativeInt,
     deletions: NonNegativeInt
   }),
-  hasUpstream: Schema20.Boolean,
+  hasUpstream: Schema22.Boolean,
   aheadCount: NonNegativeInt,
   behindCount: NonNegativeInt,
-  pr: Schema20.NullOr(GitStatusPr)
+  pr: Schema22.NullOr(GitStatusPr)
 });
-var GitListBranchesResult = Schema20.Struct({
-  branches: Schema20.Array(GitBranch),
-  isRepo: Schema20.Boolean
+var GitListBranchesResult = Schema22.Struct({
+  branches: Schema22.Array(GitBranch),
+  isRepo: Schema22.Boolean
 });
-var GitCreateWorktreeResult = Schema20.Struct({
+var GitCreateWorktreeResult = Schema22.Struct({
   worktree: GitWorktree
 });
-var GitRunStackedActionResult = Schema20.Struct({
+var GitRunStackedActionResult = Schema22.Struct({
   action: GitStackedAction,
-  branch: Schema20.Struct({
+  branch: Schema22.Struct({
     status: GitBranchStepStatus,
-    name: Schema20.optional(TrimmedNonEmptyStringSchema4)
+    name: Schema22.optional(TrimmedNonEmptyStringSchema4)
   }),
-  commit: Schema20.Struct({
+  commit: Schema22.Struct({
     status: GitCommitStepStatus,
-    commitSha: Schema20.optional(TrimmedNonEmptyStringSchema4),
-    subject: Schema20.optional(TrimmedNonEmptyStringSchema4)
+    commitSha: Schema22.optional(TrimmedNonEmptyStringSchema4),
+    subject: Schema22.optional(TrimmedNonEmptyStringSchema4)
   }),
-  push: Schema20.Struct({
+  push: Schema22.Struct({
     status: GitPushStepStatus,
-    branch: Schema20.optional(TrimmedNonEmptyStringSchema4),
-    upstreamBranch: Schema20.optional(TrimmedNonEmptyStringSchema4),
-    setUpstream: Schema20.optional(Schema20.Boolean)
+    branch: Schema22.optional(TrimmedNonEmptyStringSchema4),
+    upstreamBranch: Schema22.optional(TrimmedNonEmptyStringSchema4),
+    setUpstream: Schema22.optional(Schema22.Boolean)
   }),
-  pr: Schema20.Struct({
+  pr: Schema22.Struct({
     status: GitPrStepStatus,
-    url: Schema20.optional(Schema20.String),
-    number: Schema20.optional(PositiveInt),
-    baseBranch: Schema20.optional(TrimmedNonEmptyStringSchema4),
-    headBranch: Schema20.optional(TrimmedNonEmptyStringSchema4),
-    title: Schema20.optional(TrimmedNonEmptyStringSchema4)
+    url: Schema22.optional(Schema22.String),
+    number: Schema22.optional(PositiveInt),
+    baseBranch: Schema22.optional(TrimmedNonEmptyStringSchema4),
+    headBranch: Schema22.optional(TrimmedNonEmptyStringSchema4),
+    title: Schema22.optional(TrimmedNonEmptyStringSchema4)
   })
 });
-var GitPullResult = Schema20.Struct({
-  status: Schema20.Literals(["pulled", "skipped_up_to_date"]),
+var GitPullResult = Schema22.Struct({
+  status: Schema22.Literals(["pulled", "skipped_up_to_date"]),
   branch: TrimmedNonEmptyStringSchema4,
-  upstreamBranch: TrimmedNonEmptyStringSchema4.pipe(Schema20.NullOr)
+  upstreamBranch: TrimmedNonEmptyStringSchema4.pipe(Schema22.NullOr)
 });
-var GitReadWorkingTreePatchResult = Schema20.Struct({
-  diff: Schema20.String
+var GitReadWorkingTreePatchResult = Schema22.Struct({
+  diff: Schema22.String
 });
 
 // packages/contracts/src/keybindings.ts
-import { Schema as Schema21 } from "effect";
+import { Schema as Schema23 } from "effect";
 var MAX_KEYBINDING_VALUE_LENGTH = 64;
 var MAX_KEYBINDING_WHEN_LENGTH = 256;
 var MAX_WHEN_EXPRESSION_DEPTH = 64;
@@ -3680,126 +4171,126 @@ var STATIC_KEYBINDING_COMMANDS = [
   "chat.newLocal",
   "editor.openFavorite"
 ];
-var SCRIPT_RUN_COMMAND_PATTERN = Schema21.TemplateLiteral([
-  Schema21.Literal("script."),
-  Schema21.NonEmptyString.check(Schema21.isMaxLength(MAX_SCRIPT_ID_LENGTH), Schema21.isPattern(/^[a-z0-9][a-z0-9-]*$/)),
-  Schema21.Literal(".run")
+var SCRIPT_RUN_COMMAND_PATTERN = Schema23.TemplateLiteral([
+  Schema23.Literal("script."),
+  Schema23.NonEmptyString.check(Schema23.isMaxLength(MAX_SCRIPT_ID_LENGTH), Schema23.isPattern(/^[a-z0-9][a-z0-9-]*$/)),
+  Schema23.Literal(".run")
 ]);
-var KeybindingCommand = Schema21.Union([
-  Schema21.Literals(STATIC_KEYBINDING_COMMANDS),
+var KeybindingCommand = Schema23.Union([
+  Schema23.Literals(STATIC_KEYBINDING_COMMANDS),
   SCRIPT_RUN_COMMAND_PATTERN
 ]);
-var KeybindingValue = TrimmedString.check(Schema21.isMinLength(1), Schema21.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH));
-var KeybindingWhen = TrimmedString.check(Schema21.isMinLength(1), Schema21.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH));
-var KeybindingRule = Schema21.Struct({
+var KeybindingValue = TrimmedString.check(Schema23.isMinLength(1), Schema23.isMaxLength(MAX_KEYBINDING_VALUE_LENGTH));
+var KeybindingWhen = TrimmedString.check(Schema23.isMinLength(1), Schema23.isMaxLength(MAX_KEYBINDING_WHEN_LENGTH));
+var KeybindingRule = Schema23.Struct({
   key: KeybindingValue,
   command: KeybindingCommand,
-  when: Schema21.optional(KeybindingWhen)
+  when: Schema23.optional(KeybindingWhen)
 });
-var KeybindingsConfig = Schema21.Array(KeybindingRule).check(Schema21.isMaxLength(MAX_KEYBINDINGS_COUNT));
-var KeybindingShortcut = Schema21.Struct({
+var KeybindingsConfig = Schema23.Array(KeybindingRule).check(Schema23.isMaxLength(MAX_KEYBINDINGS_COUNT));
+var KeybindingShortcut = Schema23.Struct({
   key: KeybindingValue,
-  metaKey: Schema21.Boolean,
-  ctrlKey: Schema21.Boolean,
-  shiftKey: Schema21.Boolean,
-  altKey: Schema21.Boolean,
-  modKey: Schema21.Boolean
-});
-var KeybindingWhenNode = Schema21.Union([
-  Schema21.Struct({
-    type: Schema21.Literal("identifier"),
-    name: Schema21.NonEmptyString
+  metaKey: Schema23.Boolean,
+  ctrlKey: Schema23.Boolean,
+  shiftKey: Schema23.Boolean,
+  altKey: Schema23.Boolean,
+  modKey: Schema23.Boolean
+});
+var KeybindingWhenNode = Schema23.Union([
+  Schema23.Struct({
+    type: Schema23.Literal("identifier"),
+    name: Schema23.NonEmptyString
   }),
-  Schema21.Struct({
-    type: Schema21.Literal("not"),
-    node: Schema21.suspend(() => KeybindingWhenNode)
+  Schema23.Struct({
+    type: Schema23.Literal("not"),
+    node: Schema23.suspend(() => KeybindingWhenNode)
   }),
-  Schema21.Struct({
-    type: Schema21.Literal("and"),
-    left: Schema21.suspend(() => KeybindingWhenNode),
-    right: Schema21.suspend(() => KeybindingWhenNode)
+  Schema23.Struct({
+    type: Schema23.Literal("and"),
+    left: Schema23.suspend(() => KeybindingWhenNode),
+    right: Schema23.suspend(() => KeybindingWhenNode)
   }),
-  Schema21.Struct({
-    type: Schema21.Literal("or"),
-    left: Schema21.suspend(() => KeybindingWhenNode),
-    right: Schema21.suspend(() => KeybindingWhenNode)
+  Schema23.Struct({
+    type: Schema23.Literal("or"),
+    left: Schema23.suspend(() => KeybindingWhenNode),
+    right: Schema23.suspend(() => KeybindingWhenNode)
   })
 ]);
-var ResolvedKeybindingRule = Schema21.Struct({
+var ResolvedKeybindingRule = Schema23.Struct({
   command: KeybindingCommand,
   shortcut: KeybindingShortcut,
-  whenAst: Schema21.optional(KeybindingWhenNode)
+  whenAst: Schema23.optional(KeybindingWhenNode)
 }).annotate({ parseOptions: { onExcessProperty: "ignore" } });
-var ResolvedKeybindingsConfig = Schema21.Array(ResolvedKeybindingRule).check(Schema21.isMaxLength(MAX_KEYBINDINGS_COUNT));
+var ResolvedKeybindingsConfig = Schema23.Array(ResolvedKeybindingRule).check(Schema23.isMaxLength(MAX_KEYBINDINGS_COUNT));
 
 // packages/contracts/src/project.ts
-import { Schema as Schema22 } from "effect";
+import { Schema as Schema24 } from "effect";
 var PROJECT_SEARCH_ENTRIES_MAX_LIMIT = 200;
 var PROJECT_LIST_DIRECTORY_MAX_LIMIT = 500;
 var PROJECT_WRITE_FILE_PATH_MAX_LENGTH = 512;
 var PROJECT_READ_FILE_MAX_BYTES = 512 * 1024;
-var ProjectSearchEntriesInput = Schema22.Struct({
+var ProjectSearchEntriesInput = Schema24.Struct({
   cwd: TrimmedNonEmptyString,
-  query: TrimmedNonEmptyString.check(Schema22.isMaxLength(256)),
-  limit: PositiveInt.check(Schema22.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT))
+  query: TrimmedNonEmptyString.check(Schema24.isMaxLength(256)),
+  limit: PositiveInt.check(Schema24.isLessThanOrEqualTo(PROJECT_SEARCH_ENTRIES_MAX_LIMIT))
 });
-var ProjectEntryKind = Schema22.Literals(["file", "directory"]);
-var ProjectEntry = Schema22.Struct({
+var ProjectEntryKind = Schema24.Literals(["file", "directory"]);
+var ProjectEntry = Schema24.Struct({
   path: TrimmedNonEmptyString,
   kind: ProjectEntryKind,
-  parentPath: Schema22.optional(TrimmedNonEmptyString)
+  parentPath: Schema24.optional(TrimmedNonEmptyString)
 });
-var ProjectSearchEntriesResult = Schema22.Struct({
-  entries: Schema22.Array(ProjectEntry),
-  truncated: Schema22.Boolean
+var ProjectSearchEntriesResult = Schema24.Struct({
+  entries: Schema24.Array(ProjectEntry),
+  truncated: Schema24.Boolean
 });
-var ProjectListDirectoryInput = Schema22.Struct({
+var ProjectListDirectoryInput = Schema24.Struct({
   cwd: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString.check(Schema22.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
-  limit: PositiveInt.check(Schema22.isLessThanOrEqualTo(PROJECT_LIST_DIRECTORY_MAX_LIMIT))
+  relativePath: TrimmedNonEmptyString.check(Schema24.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  limit: PositiveInt.check(Schema24.isLessThanOrEqualTo(PROJECT_LIST_DIRECTORY_MAX_LIMIT))
 });
-var ProjectDirectoryEntry = Schema22.Struct({
+var ProjectDirectoryEntry = Schema24.Struct({
   name: TrimmedNonEmptyString,
   relativePath: TrimmedNonEmptyString,
   kind: ProjectEntryKind,
-  sizeBytes: Schema22.optional(NonNegativeInt),
-  modifiedAt: Schema22.optional(Schema22.String)
+  sizeBytes: Schema24.optional(NonNegativeInt),
+  modifiedAt: Schema24.optional(Schema24.String)
 });
-var ProjectListDirectoryResult = Schema22.Struct({
-  entries: Schema22.Array(ProjectDirectoryEntry),
-  truncated: Schema22.Boolean
+var ProjectListDirectoryResult = Schema24.Struct({
+  entries: Schema24.Array(ProjectDirectoryEntry),
+  truncated: Schema24.Boolean
 });
-var ProjectWriteFileInput = Schema22.Struct({
+var ProjectWriteFileInput = Schema24.Struct({
   cwd: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString.check(Schema22.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
-  contents: Schema22.String
+  relativePath: TrimmedNonEmptyString.check(Schema24.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH)),
+  contents: Schema24.String
 });
-var ProjectWriteFileResult = Schema22.Struct({
+var ProjectWriteFileResult = Schema24.Struct({
   relativePath: TrimmedNonEmptyString
 });
-var ProjectReadFileInput = Schema22.Struct({
+var ProjectReadFileInput = Schema24.Struct({
   cwd: TrimmedNonEmptyString,
-  relativePath: TrimmedNonEmptyString.check(Schema22.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH))
+  relativePath: TrimmedNonEmptyString.check(Schema24.isMaxLength(PROJECT_WRITE_FILE_PATH_MAX_LENGTH))
 });
-var ProjectReadFileResult = Schema22.Struct({
+var ProjectReadFileResult = Schema24.Struct({
   relativePath: TrimmedNonEmptyString,
-  contents: Schema22.String,
-  truncated: Schema22.Boolean,
+  contents: Schema24.String,
+  truncated: Schema24.Boolean,
   sizeBytes: NonNegativeInt,
   maxBytes: PositiveInt
 });
 var PROJECT_READ_FILE_MAX_BYTES_VALUE = PROJECT_READ_FILE_MAX_BYTES;
 
 // packages/contracts/src/editor.ts
-import { Schema as Schema23 } from "effect";
+import { Schema as Schema25 } from "effect";
 var EDITORS = [
   { id: "cursor", label: "Cursor", command: "cursor" },
   { id: "vscode", label: "VS Code", command: "code" },
   { id: "zed", label: "Zed", command: "zed" },
   { id: "file-manager", label: "File Manager", command: null }
 ];
-var EditorId = Schema23.Literals(EDITORS.map((e) => e.id));
-var OpenInEditorInput = Schema23.Struct({
+var EditorId = Schema25.Literals(EDITORS.map((e) => e.id));
+var OpenInEditorInput = Schema25.Struct({
   cwd: TrimmedNonEmptyString,
   editor: EditorId
 });
@@ -3866,8 +4357,8 @@ var WS_CHANNELS = {
   remoteConnectionChanged: "remote.connectionChanged",
   remoteEvent: "remote.event"
 };
-var tagRequestBody = (tag, schema) => schema.mapFields(Struct2.assign({ _tag: Schema24.tag(tag) }), { unsafePreserveChecks: true });
-var WebSocketRequestBody = Schema24.Union([
+var tagRequestBody = (tag, schema) => schema.mapFields(Struct2.assign({ _tag: Schema26.tag(tag) }), { unsafePreserveChecks: true });
+var WebSocketRequestBody = Schema26.Union([
   tagRequestBody(RIG_WS_METHODS.getSnapshot, RigGetSnapshotInput),
   tagRequestBody(RIG_WS_METHODS.replayEvents, RigReplayEventsInput),
   tagRequestBody(RIG_WS_METHODS.listWorkspaces, RigListWorkspacesInput),
@@ -3883,6 +4374,7 @@ var WebSocketRequestBody = Schema24.Union([
   tagRequestBody(RIG_WS_METHODS.resolveApproval, RigResolveApprovalInput),
   tagRequestBody(RIG_WS_METHODS.resolveUserInput, RigResolveUserInputInput),
   tagRequestBody(RIG_WS_METHODS.getTaskArtifacts, RigGetTaskArtifactsInput),
+  tagRequestBody(RIG_WS_METHODS.ackRunSteering, RigAckRunSteeringInput),
   tagRequestBody(WS_METHODS.projectsListDirectory, ProjectListDirectoryInput),
   tagRequestBody(WS_METHODS.projectsSearchEntries, ProjectSearchEntriesInput),
   tagRequestBody(WS_METHODS.projectsReadFile, ProjectReadFileInput),
@@ -3904,232 +4396,372 @@ var WebSocketRequestBody = Schema24.Union([
   tagRequestBody(WS_METHODS.terminalClear, TerminalClearInput),
   tagRequestBody(WS_METHODS.terminalRestart, TerminalRestartInput),
   tagRequestBody(WS_METHODS.terminalClose, TerminalCloseInput),
-  tagRequestBody(WS_METHODS.serverGetConfig, Schema24.Struct({})),
+  tagRequestBody(WS_METHODS.serverGetConfig, Schema26.Struct({})),
   tagRequestBody(WS_METHODS.serverUpsertKeybinding, KeybindingRule),
-  tagRequestBody(WS_METHODS.remoteListEndpoints, Schema24.Struct({})),
-  tagRequestBody(WS_METHODS.remoteRegisterEndpoint, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteListEndpoints, Schema26.Struct({})),
+  tagRequestBody(WS_METHODS.remoteRegisterEndpoint, Schema26.Struct({
     alias: TrimmedNonEmptyString,
     host: TrimmedNonEmptyString,
-    port: Schema24.Int,
-    token: Schema24.optional(TrimmedNonEmptyString),
-    autoConnect: Schema24.optional(Schema24.Boolean)
+    port: Schema26.Int,
+    token: Schema26.optional(TrimmedNonEmptyString),
+    autoConnect: Schema26.optional(Schema26.Boolean)
   })),
-  tagRequestBody(WS_METHODS.remoteRemoveEndpoint, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteRemoveEndpoint, Schema26.Struct({
     endpointId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteUpdateEndpoint, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteUpdateEndpoint, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    alias: Schema24.optional(TrimmedNonEmptyString),
-    host: Schema24.optional(TrimmedNonEmptyString),
-    port: Schema24.optional(Schema24.Int),
-    token: Schema24.optional(TrimmedNonEmptyString),
-    autoConnect: Schema24.optional(Schema24.Boolean)
+    alias: Schema26.optional(TrimmedNonEmptyString),
+    host: Schema26.optional(TrimmedNonEmptyString),
+    port: Schema26.optional(Schema26.Int),
+    token: Schema26.optional(TrimmedNonEmptyString),
+    autoConnect: Schema26.optional(Schema26.Boolean)
   })),
-  tagRequestBody(WS_METHODS.remoteTestEndpoint, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteTestEndpoint, Schema26.Struct({
     host: TrimmedNonEmptyString,
-    port: Schema24.Int,
-    token: Schema24.optional(TrimmedNonEmptyString)
+    port: Schema26.Int,
+    token: Schema26.optional(TrimmedNonEmptyString)
   })),
-  tagRequestBody(WS_METHODS.remoteConnect, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteConnect, Schema26.Struct({
     endpointId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteDisconnect, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteDisconnect, Schema26.Struct({
     endpointId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remotePause, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteResume, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteStop, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteContinue, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteCreateRunForTask, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remotePause, Schema26.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteResume, Schema26.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteStop, Schema26.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteContinue, Schema26.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteCreateRunForTask, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     taskId: TrimmedNonEmptyString,
     runId: TrimmedNonEmptyString,
     workspaceId: TrimmedNonEmptyString,
-    runtimeMode: Schema24.optional(Schema24.String),
-    interactionMode: Schema24.optional(Schema24.String)
+    runtimeMode: Schema26.optional(Schema26.String),
+    interactionMode: Schema26.optional(Schema26.String)
   })),
-  tagRequestBody(WS_METHODS.remoteRefreshTasks, Schema24.Struct({ endpointId: TrimmedNonEmptyString })),
-  tagRequestBody(WS_METHODS.remoteAddIterations, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteRefreshTasks, Schema26.Struct({ endpointId: TrimmedNonEmptyString })),
+  tagRequestBody(WS_METHODS.remoteAddIterations, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    count: Schema24.Int
+    count: Schema26.Int
   })),
-  tagRequestBody(WS_METHODS.remoteRemoveIterations, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteRemoveIterations, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    count: Schema24.Int
+    count: Schema26.Int
   })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateStart, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteOrchestrateStart, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    maxWorkers: Schema24.optional(Schema24.Int),
-    maxIterations: Schema24.optional(Schema24.Int),
-    directMerge: Schema24.optional(Schema24.Boolean)
+    maxWorkers: Schema26.optional(Schema26.Int),
+    maxIterations: Schema26.optional(Schema26.Int),
+    directMerge: Schema26.optional(Schema26.Boolean)
   })),
-  tagRequestBody(WS_METHODS.remoteOrchestratePause, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteOrchestratePause, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     orchestrationId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateResume, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteOrchestrateResume, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     orchestrationId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateStop, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteOrchestrateStop, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     orchestrationId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteOrchestrateState, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteOrchestrateState, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     orchestrationId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remotePromptPreview, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remotePromptPreview, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     taskId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteIterationOutput, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteIterationOutput, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
     taskId: TrimmedNonEmptyString
   })),
-  tagRequestBody(WS_METHODS.remoteTerminalOpen, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteTerminalOpen, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    threadId: Schema24.String,
-    terminalId: Schema24.String,
-    cwd: Schema24.optional(Schema24.String),
-    env: Schema24.optional(Schema24.Unknown)
+    threadId: Schema26.String,
+    terminalId: Schema26.String,
+    cwd: Schema26.optional(Schema26.String),
+    env: Schema26.optional(Schema26.Unknown)
   })),
-  tagRequestBody(WS_METHODS.remoteTerminalWrite, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteTerminalWrite, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    threadId: Schema24.String,
-    terminalId: Schema24.String,
-    data: Schema24.String
+    threadId: Schema26.String,
+    terminalId: Schema26.String,
+    data: Schema26.String
   })),
-  tagRequestBody(WS_METHODS.remoteTerminalResize, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteTerminalResize, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    threadId: Schema24.String,
-    terminalId: Schema24.String,
-    cols: Schema24.Number,
-    rows: Schema24.Number
+    threadId: Schema26.String,
+    terminalId: Schema26.String,
+    cols: Schema26.Number,
+    rows: Schema26.Number
   })),
-  tagRequestBody(WS_METHODS.remoteTerminalClose, Schema24.Struct({
+  tagRequestBody(WS_METHODS.remoteTerminalClose, Schema26.Struct({
     endpointId: TrimmedNonEmptyString,
-    threadId: Schema24.String,
-    terminalId: Schema24.String
+    threadId: Schema26.String,
+    terminalId: Schema26.String
   }))
 ]);
-var WebSocketRequest = Schema24.Struct({
+var WebSocketRequest = Schema26.Struct({
   id: TrimmedNonEmptyString,
   body: WebSocketRequestBody
 });
-var WebSocketResponse = Schema24.Struct({
+var WebSocketResponse = Schema26.Struct({
   id: TrimmedNonEmptyString,
-  result: Schema24.optional(Schema24.Unknown),
-  error: Schema24.optional(Schema24.Struct({
-    message: Schema24.String
+  result: Schema26.optional(Schema26.Unknown),
+  error: Schema26.optional(Schema26.Struct({
+    message: Schema26.String
   }))
 });
-var WsPush = Schema24.Struct({
-  type: Schema24.Literal("push"),
+var WsPush = Schema26.Struct({
+  type: Schema26.Literal("push"),
   channel: TrimmedNonEmptyString,
-  data: Schema24.Unknown
+  data: Schema26.Unknown
 });
 var EngineGetSnapshotResult = EngineReadModel;
 var EngineReplayEventsWsResult = EngineReplayEventsResult;
-var WsResponse = Schema24.Union([WebSocketResponse, WsPush]);
-var WsWelcomePayload = Schema24.Struct({
+var WsResponse = Schema26.Union([WebSocketResponse, WsPush]);
+var WsWelcomePayload = Schema26.Struct({
   cwd: TrimmedNonEmptyString,
   projectName: TrimmedNonEmptyString,
-  bootstrapProjectId: Schema24.optional(ProjectId),
-  bootstrapThreadId: Schema24.optional(ThreadId)
+  bootstrapProjectId: Schema26.optional(ProjectId),
+  bootstrapThreadId: Schema26.optional(ThreadId)
 });
 // packages/contracts/src/server.ts
-import { Schema as Schema25 } from "effect";
-var KeybindingsMalformedConfigIssue = Schema25.Struct({
-  kind: Schema25.Literal("keybindings.malformed-config"),
+import { Schema as Schema27 } from "effect";
+var KeybindingsMalformedConfigIssue = Schema27.Struct({
+  kind: Schema27.Literal("keybindings.malformed-config"),
   message: TrimmedNonEmptyString
 });
-var KeybindingsInvalidEntryIssue = Schema25.Struct({
-  kind: Schema25.Literal("keybindings.invalid-entry"),
+var KeybindingsInvalidEntryIssue = Schema27.Struct({
+  kind: Schema27.Literal("keybindings.invalid-entry"),
   message: TrimmedNonEmptyString,
-  index: Schema25.Number
+  index: Schema27.Number
 });
-var ServerConfigIssue = Schema25.Union([
+var ServerConfigIssue = Schema27.Union([
   KeybindingsMalformedConfigIssue,
   KeybindingsInvalidEntryIssue
 ]);
-var ServerConfigIssues = Schema25.Array(ServerConfigIssue);
-var ServerProviderStatusState = Schema25.Literals(["ready", "warning", "error"]);
-var ServerProviderAuthStatus = Schema25.Literals([
+var ServerConfigIssues = Schema27.Array(ServerConfigIssue);
+var ServerProviderStatusState = Schema27.Literals(["ready", "warning", "error"]);
+var ServerProviderAuthStatus = Schema27.Literals([
   "authenticated",
   "unauthenticated",
   "unknown"
 ]);
-var ServerProviderStatus = Schema25.Struct({
+var ServerProviderStatus = Schema27.Struct({
   provider: ProviderKind,
   status: ServerProviderStatusState,
-  available: Schema25.Boolean,
+  available: Schema27.Boolean,
   authStatus: ServerProviderAuthStatus,
   checkedAt: IsoDateTime,
-  message: Schema25.optional(TrimmedNonEmptyString)
+  message: Schema27.optional(TrimmedNonEmptyString)
 });
-var ServerProviderStatuses = Schema25.Array(ServerProviderStatus);
-var ServerConfig = Schema25.Struct({
+var ServerProviderStatuses = Schema27.Array(ServerProviderStatus);
+var ServerConfig = Schema27.Struct({
   cwd: TrimmedNonEmptyString,
-  rigRoot: Schema25.NullOr(TrimmedNonEmptyString),
+  rigRoot: Schema27.NullOr(TrimmedNonEmptyString),
   keybindingsConfigPath: TrimmedNonEmptyString,
   keybindings: ResolvedKeybindingsConfig,
   issues: ServerConfigIssues,
   providers: ServerProviderStatuses,
-  availableEditors: Schema25.Array(EditorId)
+  availableEditors: Schema27.Array(EditorId)
 });
 var ServerUpsertKeybindingInput = KeybindingRule;
-var ServerUpsertKeybindingResult = Schema25.Struct({
+var ServerUpsertKeybindingResult = Schema27.Struct({
   keybindings: ResolvedKeybindingsConfig,
   issues: ServerConfigIssues
 });
-var ServerConfigUpdatedPayload = Schema25.Struct({
+var ServerConfigUpdatedPayload = Schema27.Struct({
   issues: ServerConfigIssues,
   providers: ServerProviderStatuses
 });
 // packages/contracts/src/serviceFabric.ts
-import { Schema as Schema26 } from "effect";
-var ServiceFabricWorkspaceInput = Schema26.Struct({
+import { Schema as Schema28 } from "effect";
+var ServiceFabricWorkspaceInput = Schema28.Struct({
   workspaceId: WorkspaceId
 });
-var ServiceFabricUpInput = Schema26.Struct({
+var ServiceFabricUpInput = Schema28.Struct({
   workspaceId: WorkspaceId,
-  services: Schema26.optional(Schema26.Array(TrimmedNonEmptyString))
+  services: Schema28.optional(Schema28.Array(TrimmedNonEmptyString))
 });
-var ServiceFabricUpResult = Schema26.Struct({
-  plan: Schema26.Struct({
+var ServiceFabricUpResult = Schema28.Struct({
+  plan: Schema28.Struct({
     generatedAt: IsoDateTime,
-    serviceCount: Schema26.Number,
-    services: Schema26.Array(Schema26.Struct({
+    serviceCount: Schema28.Number,
+    services: Schema28.Array(Schema28.Struct({
       name: TrimmedNonEmptyString,
       relativeRootPath: TrimmedNonEmptyString,
       absoluteRootPath: TrimmedNonEmptyString,
-      port: Schema26.Number,
+      port: Schema28.Number,
       healthcheck: TrimmedNonEmptyString,
-      routePrefix: Schema26.NullOr(TrimmedNonEmptyString),
-      mode: Schema26.Literals(["stub", "process"]),
-      command: Schema26.NullOr(Schema26.String),
-      environment: Schema26.Unknown
+      routePrefix: Schema28.NullOr(TrimmedNonEmptyString),
+      mode: Schema28.Literals(["stub", "process"]),
+      command: Schema28.NullOr(Schema28.String),
+      environment: Schema28.Unknown
     })),
-    warnings: Schema26.Array(Schema26.String)
+    warnings: Schema28.Array(Schema28.String)
   }),
-  state: Schema26.Struct({
+  state: Schema28.Struct({
     generatedAt: IsoDateTime,
     rootPath: TrimmedNonEmptyString,
-    services: Schema26.Array(Schema26.Struct({
+    services: Schema28.Array(Schema28.Struct({
       name: TrimmedNonEmptyString,
-      pid: Schema26.Number,
-      mode: Schema26.Literals(["stub", "process"]),
-      port: Schema26.Number,
+      pid: Schema28.Number,
+      mode: Schema28.Literals(["stub", "process"]),
+      port: Schema28.Number,
       healthcheck: TrimmedNonEmptyString,
-      routePrefix: Schema26.NullOr(TrimmedNonEmptyString),
+      routePrefix: Schema28.NullOr(TrimmedNonEmptyString),
       relativeRootPath: TrimmedNonEmptyString,
       logPath: TrimmedNonEmptyString
     }))
   }),
   summary: WorkspaceServiceFabricSummary
 });
+// packages/contracts/src/cli-output.ts
+import { Schema as Schema29 } from "effect";
+var CLI_OUTPUT_VERSION = 1;
+var RigCliOutputEnvelope = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.String,
+  data: Schema29.Unknown
+});
+var CliTaskSummary = Schema29.Struct({
+  id: Schema29.NullOr(Schema29.String),
+  title: Schema29.NullOr(Schema29.String),
+  status: Schema29.NullOr(Schema29.String),
+  source: Schema29.optional(Schema29.String),
+  url: Schema29.optional(Schema29.String),
+  number: Schema29.optional(Schema29.Number),
+  labels: Schema29.optional(Schema29.Array(Schema29.Unknown)),
+  assignees: Schema29.optional(Schema29.Array(Schema29.Unknown)),
+  readiness: Schema29.optional(Schema29.Union([Schema29.String, Schema29.Boolean])),
+  validators: Schema29.optional(Schema29.Array(Schema29.Unknown)),
+  raw: Schema29.optional(Schema29.Unknown)
+});
+var CliTaskFilters = Schema29.Struct({
+  assignee: Schema29.optional(Schema29.String),
+  state: Schema29.optional(Schema29.String),
+  status: Schema29.optional(Schema29.String),
+  limit: Schema29.optional(Schema29.Number)
+});
+var CliRunRecord = Schema29.Record(Schema29.String, Schema29.Unknown);
+var CliInboxRecord = Schema29.Record(Schema29.String, Schema29.Unknown);
+var CliDoctorCheck = Schema29.Struct({
+  id: Schema29.String,
+  label: Schema29.String,
+  status: Schema29.Literals(["pass", "warn", "fail"]),
+  detail: Schema29.optional(Schema29.String),
+  remediation: Schema29.optional(Schema29.String)
+});
+var CliServerConnection = Schema29.Union([
+  Schema29.Struct({ kind: Schema29.Literal("local"), mode: Schema29.Literal("auto") }),
+  Schema29.Struct({ kind: Schema29.Literal("remote"), baseUrl: Schema29.String })
+]);
+var CliRepoConnectionState = Schema29.Struct({
+  selected: Schema29.String,
+  project: Schema29.optional(Schema29.String),
+  linkedAt: Schema29.optional(Schema29.String),
+  serverProjectRoot: Schema29.optional(Schema29.String)
+});
+var RigTaskListOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("task list"),
+  data: Schema29.Struct({
+    count: Schema29.Number,
+    filters: CliTaskFilters,
+    raw: Schema29.Boolean,
+    tasks: Schema29.Array(CliTaskSummary)
+  })
+});
+var RigTaskShowOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("task show"),
+  data: Schema29.Struct({
+    task: CliTaskSummary,
+    raw: Schema29.Boolean
+  })
+});
+var RigRunListOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("run list"),
+  data: Schema29.Struct({
+    runs: Schema29.Array(CliRunRecord),
+    source: Schema29.Literals(["local", "server"])
+  })
+});
+var RigRunShowOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("run show"),
+  data: CliRunRecord
+});
+var RigServerStatusOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("server status"),
+  data: Schema29.Struct({
+    selected: Schema29.String,
+    repo: Schema29.NullOr(CliRepoConnectionState),
+    connections: Schema29.Record(Schema29.String, CliServerConnection)
+  })
+});
+var RigInboxApprovalsOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("inbox approvals"),
+  data: Schema29.Struct({
+    approvals: Schema29.Array(CliInboxRecord)
+  })
+});
+var RigInboxInputsOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("inbox inputs"),
+  data: Schema29.Struct({
+    requests: Schema29.Array(CliInboxRecord)
+  })
+});
+var RigDoctorCheckOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("doctor check"),
+  data: Schema29.Struct({
+    checks: Schema29.Array(CliDoctorCheck),
+    failures: Schema29.Number
+  })
+});
+var RigStatsData = Schema29.Struct({
+  since: Schema29.NullOr(Schema29.String),
+  totalRuns: Schema29.Number,
+  statusCounts: Schema29.Record(Schema29.String, Schema29.Number),
+  completedRuns: Schema29.Number,
+  failedRuns: Schema29.Number,
+  needsAttentionRuns: Schema29.Number,
+  completionRate: Schema29.NullOr(Schema29.Number),
+  failureRate: Schema29.NullOr(Schema29.Number),
+  needsAttentionRate: Schema29.NullOr(Schema29.Number),
+  medianCompletionMs: Schema29.NullOr(Schema29.Number),
+  steeringTotal: Schema29.Number,
+  steeringPerRun: Schema29.NullOr(Schema29.Number),
+  stallTotal: Schema29.Number,
+  approvalsRequested: Schema29.Number,
+  approvalsApproved: Schema29.Number,
+  approvalsRejected: Schema29.Number,
+  approvalsPending: Schema29.Number
+});
+var RigStatsOutput = Schema29.Struct({
+  v: Schema29.Literal(1),
+  command: Schema29.Literal("stats show"),
+  data: RigStatsData
+});
+// packages/contracts/src/protocol-version.ts
+var RIG_PROTOCOL_VERSION = 1;
 export {
+  reduceRunJournal,
+  isTerminalRunStatus,
+  isActiveRunStatus,
+  decodeRunJournalEvent,
+  canTransitionRunStatus,
+  assertRunStatusTransition,
   WsWelcomePayload,
   WsResponse,
   WsPush,
@@ -4146,6 +4778,7 @@ export {
   WorkspaceServiceFabricSummary,
   WorkspaceServiceFabricStatus,
   WorkspaceServiceFabricServiceSummary,
+  WorkspaceSandbox,
   WorkspaceRemoteHostSummary,
   WorkspaceRemoteHostStatus,
   WorkspaceRemoteFleetSummary,
@@ -4158,6 +4791,7 @@ export {
   WorkspaceHydrateImportedStateCommand,
   WorkspaceConfig,
   WorkspaceCompileTopologyCommand,
+  WorkspaceCheckout,
   WebSocketResponse,
   WebSocketRequest,
   WS_METHODS,
@@ -4210,6 +4844,7 @@ export {
   TaskId,
   TaskFieldExtension,
   TaskEnqueueCommand,
+  TERMINAL_RUN_STATUSES,
   SkillRegistration,
   ServiceFabricWorkspaceInput,
   ServiceFabricUpResult,
@@ -4249,43 +4884,74 @@ export {
   RuntimeCompleteActionCommand,
   RuntimeAttachCommand,
   RuntimeAdapterKind,
+  RunTimelineEntryEvent,
   RunSummary,
   RunSubmitUserMessageCommand,
   RunStopCommand,
+  RunSteeringEvent,
+  RunStatusChangedEvent,
   RunStatus,
+  RunStallDetectedEvent,
   RunSetStatusCommand,
   RunSetRuntimeModeCommand,
   RunSetInteractionModeCommand,
   RunRespondUserInputCommand,
   RunRespondApprovalCommand,
   RunReleaseRemoteLeaseCommand,
+  RunRecordPatchEvent,
+  RunRecordPatch,
   RunMode,
   RunMarkFailedCommand,
   RunMarkCompletedCommand,
+  RunLogEntryEvent,
   RunKind,
+  RunJournalRecord,
+  RunJournalEvent,
   RunInterruptCommand,
+  RunInputResolvedEvent,
+  RunInputRequestedEvent,
   RunId,
   RunExecutionTarget,
   RunCreateForTaskCommand,
   RunCreateAdhocCommand,
+  RunCloseoutStatus,
+  RunCloseoutState,
+  RunCloseoutPhaseOutcome,
+  RunCloseoutPhaseEvent,
+  RunCloseoutPhase,
   RunClaimRemoteLeaseCommand,
+  RunApprovalResolvedEvent,
+  RunApprovalRequestedEvent,
+  RunAdoptedEvent,
+  RunActor,
+  RigTaskShowOutput,
+  RigTaskListOutput,
   RigSubmitRunMessageInput,
   RigStopRunInput,
+  RigStatsOutput,
+  RigStatsData,
   RigSnapshotInvalidatedPayload,
   RigSnapshot,
+  RigServerStatusOutput,
   RigRuntimeMode,
+  RigRunSteeringQueuedPayload,
+  RigRunShowOutput,
   RigRunLogAppendedPayload,
+  RigRunListOutput,
   RigResumeRunInput,
   RigResolveUserInputInput,
   RigResolveApprovalInput,
   RigReplayEventsResult,
   RigReplayEventsInput,
   RigRawRunLogEntry,
+  RigQueuedRunSteeringMessage,
   RigPlugin,
   RigMutationResult,
   RigListWorkspacesResult,
   RigListWorkspacesInput,
   RigInterruptRunInput,
+  RigInboxInputsOutput,
+  RigInboxApprovalsOutput,
   RigGetWorkspaceResult,
   RigGetWorkspaceInput,
   RigGetTaskArtifactsResult,
@@ -4294,10 +4960,14 @@ export {
   RigGetRunLogsResult,
   RigGetRunLogsInput,
   RigEnqueueTaskInput,
+  RigDoctorCheckOutput,
   RigDeleteRunInput,
   RigCreateTaskRunInput,
   RigCreateAdhocRunInput,
   RigConfig,
+  RigCliOutputEnvelope,
+  RigAckRunSteeringResult,
+  RigAckRunSteeringInput,
   ReviewSummary,
   ReviewStatus,
   ReviewResultId,
@@ -4354,8 +5024,10 @@ export {
   RemoteConnectionStatus,
   RemoteConnectCommand,
   RemoteAddIterationsCommand,
+  RUN_STATUS_TRANSITIONS,
   RIG_WS_METHODS,
   RIG_WS_CHANNELS,
+  RIG_PROTOCOL_VERSION,
   REASONING_EFFORT_OPTIONS_BY_PROVIDER,
   QueueEntry,
   PullRequestConfig,
@@ -4408,6 +5080,7 @@ export {
   PolicyDecision,
   PluginContributes,
   PlanningConfig,
+  PiRuntimeConfig,
   PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
   PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
   PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
@@ -4463,9 +5136,13 @@ export {
   IssueAnalysisConfig,
   IsolationMode,
   IsoDateTime,
+  HookToolInput,
+  HookResult,
   HookRegistration,
   HookMatcher,
   HookEvent,
+  HookDecision,
+  HookContext,
   GraphUpdateTaskStatusCommand,
   GraphSummary,
   GraphId,
@@ -4527,6 +5204,13 @@ export {
   CommandId,
   CodexModelOptions,
   ClientOrchestrationCommand,
+  CliTaskSummary,
+  CliTaskFilters,
+  CliServerConnection,
+  CliRunRecord,
+  CliRepoConnectionState,
+  CliInboxRecord,
+  CliDoctorCheck,
   CliCommandRegistration,
   ClaudeModelOptions,
   CheckpointRef,
@@ -4535,6 +5219,7 @@ export {
   CanonicalRequestType,
   CanonicalItemType,
   CODEX_REASONING_EFFORT_OPTIONS,
+  CLI_OUTPUT_VERSION,
   AutomationConfig,
   AssistantDeliveryMode,
   ArtifactSummary,
@@ -4542,6 +5227,8 @@ export {
   ApprovalSummary,
   ApprovalStatus,
   ApprovalRequestId,
+  ApprovalDecision,
   AgentRoleRegistration,
-  ActionId
+  ActionId,
+  ACTIVE_RUN_STATUSES
 };