@mindfoldhq/runtime-manager 0.1.4 → 0.1.5

package/dist/vine-runtime-manager.js

@@ -1293,7 +1293,7 @@ function validateVercelCredentialsConfig(config, ctx) {
 }
 
 // ../../packages/protocol/src/runtime-repos-manifest.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // ../../packages/protocol/src/repo-env-template.ts
 import { z as z5 } from "zod";
@@ -1634,7 +1634,7 @@ function toHttpStatus(code) {
 }
 
 // ../../packages/protocol/src/ws-server-manager.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // ../../packages/protocol/src/agent-question.ts
 import { z as z7 } from "zod";
@@ -2861,6 +2861,25 @@ var TaskUpdateInput = z17.object({
 var TaskArchiveInput = z17.object({
   id: Id
 });
+var TaskReviewRequestCreateInput = z17.object({
+  task_id: Id,
+  project_repository_id: Id,
+  title: z17.string().min(1).max(256).optional(),
+  body: z17.string().max(65000).optional()
+}).strict();
+var TaskReviewRequestDto = z17.object({
+  task_id: Id,
+  project_repository_id: Id,
+  provider_kind: GitCredentialProviderKind,
+  status: z17.enum(["created", "manual"]),
+  base_ref: z17.string().min(1).nullable(),
+  head_branch: z17.string().min(1).nullable(),
+  url: z17.string().nullable(),
+  provider_id: z17.string().nullable(),
+  unavailable_reason: z17.string().nullable(),
+  manual_compare_url: z17.string().nullable(),
+  manual_instructions: z17.string().nullable()
+}).strict();
 var TaskImportFromTrellisInput = z17.object({
   project_id: Id,
   repo_root: z17.string().min(1),
@@ -2903,6 +2922,15 @@ var TurnSkillBundle = z18.object({
   version: z18.number().int().positive().default(1)
 }).strict();
 
+// ../../packages/protocol/src/task-work-branch.ts
+import { z as z19 } from "zod";
+var TaskWorkBranchTarget = z19.object({
+  repository_id: z19.string().min(1),
+  repo_slug: z19.string().min(1),
+  base_ref: z19.string().min(1),
+  work_branch: z19.string().min(1)
+});
+
 // ../../packages/protocol/src/ws-server-manager.ts
 var ManagerKind = RuntimeManagerKind;
 var ManagerStatus = RuntimeManagerStatus;
@@ -2914,7 +2942,7 @@ var RuntimeRunnerKind2 = RuntimeRunnerKind;
 var RuntimeRunnerStatus2 = RuntimeRunnerStatus;
 var ThreadRuntimeAgentSessionStatus2 = ThreadRuntimeAgentSessionStatus;
 var ManagerBackendKind = RuntimeAgentBackendKind;
-var ManagerTurnEventKind = z19.enum([
+var ManagerTurnEventKind = z20.enum([
   "text_delta",
   "tool_call",
   "tool_result",
@@ -2922,626 +2950,628 @@ var ManagerTurnEventKind = z19.enum([
   "error",
   "meta"
 ]);
-var ManagerTurnFinishedStatus = z19.enum([
+var ManagerTurnFinishedStatus = z20.enum([
   "completed",
   "failed",
   "cancelled"
 ]);
-var ManagerHelloPayload = z19.object({
-  registration_token: z19.string().min(1),
-  name: z19.string().min(1),
+var ManagerHelloPayload = z20.object({
+  registration_token: z20.string().min(1),
+  name: z20.string().min(1),
   manager_kind: ManagerKind,
-  host_fingerprint: z19.string().min(1),
-  version: z19.string(),
+  host_fingerprint: z20.string().min(1),
+  version: z20.string(),
   capabilities: RuntimeManagerCapabilitiesClientReadCompat
 }).strict();
-var ManagerHeartbeatPayload = z19.object({
+var ManagerHeartbeatPayload = z20.object({
   status: ManagerStatus,
-  active_session_count: z19.number().int().nonnegative(),
-  sent_at: z19.string()
+  active_session_count: z20.number().int().nonnegative(),
+  sent_at: z20.string()
 });
-var ProviderAnnounceEntry = z19.object({
+var ProviderAnnounceEntry = z20.object({
   provider_kind: ProviderKind,
   status: ProviderStatus,
   capacity_policy: RuntimeProviderCapacityPolicyClientReadCompat,
   config: RuntimeProviderConfigClientReadCompat
 });
-var ProviderAnnouncePayload = z19.object({
-  providers: z19.array(ProviderAnnounceEntry).min(1)
+var ProviderAnnouncePayload = z20.object({
+  providers: z20.array(ProviderAnnounceEntry).min(1)
 });
-var SessionStatePayload = z19.object({
-  session_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  runtime_manager_id: z19.string().min(1),
-  runtime_provider_id: z19.string().min(1),
+var SessionStatePayload = z20.object({
+  session_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  runtime_manager_id: z20.string().min(1),
+  runtime_provider_id: z20.string().min(1),
   execution_mode: ExecutionMode,
   provider_kind: ProviderKind,
   status: ThreadRuntimeSessionStatus2,
-  provider_runtime_id: z19.string().nullable(),
-  workspace_root: z19.string().nullable(),
-  agent_private_root: z19.string().nullable(),
-  project_repo_path: z19.string().nullable(),
-  project_id: z19.string().min(1).nullable().default(null),
-  task_id: z19.string().min(1).nullable().default(null),
-  last_error: z19.string().nullable(),
-  runtime_profile_snapshot: z19.record(z19.string(), z19.unknown()).optional(),
-  capabilities_snapshot: z19.record(z19.string(), z19.unknown()).optional(),
-  auth_mount_snapshot: z19.record(z19.string(), z19.unknown()).optional(),
-  checkpoint_policy: z19.record(z19.string(), z19.unknown()).optional(),
-  metadata: z19.record(z19.string(), z19.unknown()).optional()
-});
-var RunnerStatePayload = z19.object({
-  runner_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
+  provider_runtime_id: z20.string().nullable(),
+  workspace_root: z20.string().nullable(),
+  agent_private_root: z20.string().nullable(),
+  project_repo_path: z20.string().nullable(),
+  project_id: z20.string().min(1).nullable().default(null),
+  task_id: z20.string().min(1).nullable().default(null),
+  last_error: z20.string().nullable(),
+  runtime_profile_snapshot: z20.record(z20.string(), z20.unknown()).optional(),
+  capabilities_snapshot: z20.record(z20.string(), z20.unknown()).optional(),
+  auth_mount_snapshot: z20.record(z20.string(), z20.unknown()).optional(),
+  checkpoint_policy: z20.record(z20.string(), z20.unknown()).optional(),
+  metadata: z20.record(z20.string(), z20.unknown()).optional()
+});
+var RunnerStatePayload = z20.object({
+  runner_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
   runner_kind: RuntimeRunnerKind2,
-  runner_version: z19.string().nullable(),
+  runner_version: z20.string().nullable(),
   status: RuntimeRunnerStatus2,
-  endpoint: z19.string().nullable(),
-  process_id: z19.string().nullable(),
-  last_error: z19.string().nullable(),
-  metadata: z19.record(z19.string(), z19.unknown()).optional()
-});
-var AgentSessionStatePayload = z19.object({
-  agent_session_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  runner_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  agent_profile_id: z19.string().min(1),
-  project_agent_profile_id: z19.string().nullable(),
+  endpoint: z20.string().nullable(),
+  process_id: z20.string().nullable(),
+  last_error: z20.string().nullable(),
+  metadata: z20.record(z20.string(), z20.unknown()).optional()
+});
+var AgentSessionStatePayload = z20.object({
+  agent_session_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  runner_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  agent_profile_id: z20.string().min(1),
+  project_agent_profile_id: z20.string().nullable(),
   backend_kind: ManagerBackendKind,
-  model: z19.string().nullable(),
+  model: z20.string().nullable(),
   status: ThreadRuntimeAgentSessionStatus2,
-  external_session_id: z19.string().nullable(),
-  cwd_path: z19.string().nullable(),
-  last_error: z19.string().nullable(),
-  metadata: z19.record(z19.string(), z19.unknown()).optional()
+  external_session_id: z20.string().nullable(),
+  cwd_path: z20.string().nullable(),
+  last_error: z20.string().nullable(),
+  metadata: z20.record(z20.string(), z20.unknown()).optional()
 });
-var ManagerTurnEventPayload = z19.object({
-  agent_turn_id: z19.string().min(1),
+var ManagerTurnEventPayload = z20.object({
+  agent_turn_id: z20.string().min(1),
   kind: ManagerTurnEventKind,
-  data: z19.record(z19.string(), z19.unknown())
+  data: z20.record(z20.string(), z20.unknown())
 });
-var ManagerTurnFinishedPayload = z19.object({
-  agent_turn_id: z19.string().min(1),
+var ManagerTurnFinishedPayload = z20.object({
+  agent_turn_id: z20.string().min(1),
   status: ManagerTurnFinishedStatus,
-  exit_code: z19.number().int().nullable(),
-  external_session_id: z19.string().nullable(),
-  final_text: z19.string(),
-  failure_detail: z19.string().nullable(),
+  exit_code: z20.number().int().nullable(),
+  external_session_id: z20.string().nullable(),
+  final_text: z20.string(),
+  failure_detail: z20.string().nullable(),
   failure_code: ErrorCode.nullable().default(null),
   prompt_context_summary: PromptContextSummary.nullable().optional()
 });
-var ManagerStaleSessionPayload = z19.object({
-  agent_turn_id: z19.string().min(1),
-  attempted_external_session_id: z19.string().min(1),
-  retry_requested: z19.boolean().optional()
-});
-var TaskSnapshotGetPayload = z19.object({
-  request_id: z19.string().min(1),
-  task_id: z19.string().min(1)
-});
-var TaskCliUpdatePayload = z19.object({
-  request_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  task_id: z19.string().min(1),
-  field: z19.enum(["prd_md", "design_md", "implement_md"]),
-  content: z19.string(),
-  expected_version: z19.number().int().optional()
-});
-var TaskCliCreatePayload = z19.object({
-  request_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  agent_turn_id: z19.string().min(1),
-  title: z19.string().min(1),
-  trellis_id: z19.string().min(1).optional(),
+var ManagerStaleSessionPayload = z20.object({
+  agent_turn_id: z20.string().min(1),
+  attempted_external_session_id: z20.string().min(1),
+  retry_requested: z20.boolean().optional()
+});
+var TaskSnapshotGetPayload = z20.object({
+  request_id: z20.string().min(1),
+  task_id: z20.string().min(1)
+});
+var TaskCliUpdatePayload = z20.object({
+  request_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  task_id: z20.string().min(1),
+  field: z20.enum(["prd_md", "design_md", "implement_md"]),
+  content: z20.string(),
+  expected_version: z20.number().int().optional()
+});
+var TaskCliCreatePayload = z20.object({
+  request_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  agent_turn_id: z20.string().min(1),
+  title: z20.string().min(1),
+  trellis_id: z20.string().min(1).optional(),
   status: TaskStatus.optional(),
-  priority: z19.string().min(1).nullable().optional(),
-  prd_md: z19.string().optional(),
-  design_md: z19.string().optional(),
-  implement_md: z19.string().optional()
+  priority: z20.string().min(1).nullable().optional(),
+  prd_md: z20.string().optional(),
+  design_md: z20.string().optional(),
+  implement_md: z20.string().optional()
 }).strict();
-var TaskCliStatusUpdatePayload = z19.object({
-  request_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  agent_turn_id: z19.string().min(1),
+var TaskCliStatusUpdatePayload = z20.object({
+  request_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  agent_turn_id: z20.string().min(1),
   status: TaskStatus,
-  expected_version: z19.number().int().optional()
+  expected_version: z20.number().int().optional()
 }).strict();
 var ManagerTaskRefsSnapshotPayload = TaskRefsSnapshotPayload;
-var AgentQuestionCreatePayload = z19.object({
-  request_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  agent_turn_id: z19.string().min(1),
-  questions: z19.array(AgentQuestionSpec).min(1)
-});
-var TurnDispatchGitAuth = z19.discriminatedUnion("kind", [
-  z19.object({
-    version: z19.literal(1),
-    kind: z19.literal("https_token"),
-    username: z19.string().min(1).nullable().default(null),
-    token: z19.string().min(1)
+var AgentQuestionCreatePayload = z20.object({
+  request_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  agent_turn_id: z20.string().min(1),
+  questions: z20.array(AgentQuestionSpec).min(1)
+});
+var TurnDispatchGitAuth = z20.discriminatedUnion("kind", [
+  z20.object({
+    version: z20.literal(1),
+    kind: z20.literal("https_token"),
+    username: z20.string().min(1).nullable().default(null),
+    token: z20.string().min(1)
   }).strict(),
-  z19.object({
-    version: z19.literal(1),
-    kind: z19.literal("ssh_key"),
-    private_key: z19.string().min(1),
-    known_hosts: z19.string().min(1).nullable().default(null)
+  z20.object({
+    version: z20.literal(1),
+    kind: z20.literal("ssh_key"),
+    private_key: z20.string().min(1),
+    known_hosts: z20.string().min(1).nullable().default(null)
   }).strict()
 ]);
-var TurnDispatchRepository = z19.object({
-  repository_id: z19.string().min(1),
-  repo_slug: z19.string().min(1),
-  remote_key: z19.string().min(1).nullable().default(null),
-  remote_url: z19.string().min(1),
-  default_branch: z19.string().min(1),
-  setup_script: z19.string().nullable().default(null),
+var TurnDispatchRepository = z20.object({
+  repository_id: z20.string().min(1),
+  repo_slug: z20.string().min(1),
+  remote_key: z20.string().min(1).nullable().default(null),
+  remote_url: z20.string().min(1),
+  default_branch: z20.string().min(1),
+  work_branch: z20.string().min(1).nullable().default(null),
+  setup_script: z20.string().nullable().default(null),
   env_template: MaterializedRepoEnvTemplate.default(EMPTY_MATERIALIZED_REPO_ENV_TEMPLATE),
-  env_prepare_script: z19.string().nullable().default(null),
+  env_prepare_script: z20.string().nullable().default(null),
   git_auth: TurnDispatchGitAuth.nullable().default(null)
 });
-var TurnDispatchPayload = z19.object({
-  agent_turn_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  agent_profile_id: z19.string().min(1),
-  project_agent_profile_id: z19.string().nullable(),
+var TurnDispatchPayload = z20.object({
+  agent_turn_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  agent_profile_id: z20.string().min(1),
+  project_agent_profile_id: z20.string().nullable(),
   backend_kind: ManagerBackendKind,
-  prompt: z19.string(),
+  prompt: z20.string(),
   prompt_context: PromptContext.default(EMPTY_PROMPT_CONTEXT),
-  model: z19.string().nullable(),
-  external_session_id: z19.string().nullable(),
-  project_id: z19.string().min(1).nullable().default(null),
-  task_id: z19.string().min(1).nullable().default(null),
-  env_overrides: z19.record(z19.string(), z19.string()).default({}),
-  skills: z19.array(TurnSkillBundle).default([]),
-  repositories: z19.array(TurnDispatchRepository).default([]),
+  model: z20.string().nullable(),
+  external_session_id: z20.string().nullable(),
+  project_id: z20.string().min(1).nullable().default(null),
+  task_id: z20.string().min(1).nullable().default(null),
+  env_overrides: z20.record(z20.string(), z20.string()).default({}),
+  skills: z20.array(TurnSkillBundle).default([]),
+  repositories: z20.array(TurnDispatchRepository).default([]),
   provider_kind: RuntimeProviderKind.nullable().default(null),
   remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable().default(null),
   restore_source: RuntimeCheckpointRestoreSource.optional()
 });
-var TurnCancelDispatchPayload = z19.object({
-  organization_id: z19.string().min(1),
-  agent_turn_id: z19.string().min(1),
-  reason: z19.string().optional()
+var TurnCancelDispatchPayload = z20.object({
+  organization_id: z20.string().min(1),
+  agent_turn_id: z20.string().min(1),
+  reason: z20.string().optional()
 });
-var SessionCreatePayload = z19.object({
-  session_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  thread_id: z19.string().min(1),
+var SessionCreatePayload = z20.object({
+  session_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  thread_id: z20.string().min(1),
   execution_mode: ExecutionMode,
   provider_kind: ProviderKind,
-  project_id: z19.string().nullable(),
-  task_id: z19.string().nullable(),
-  runtime_profile_snapshot: z19.record(z19.string(), z19.unknown()),
-  capabilities_snapshot: z19.record(z19.string(), z19.unknown()),
-  auth_mount_snapshot: z19.record(z19.string(), z19.unknown()),
-  checkpoint_policy: z19.record(z19.string(), z19.unknown()),
+  project_id: z20.string().nullable(),
+  task_id: z20.string().nullable(),
+  runtime_profile_snapshot: z20.record(z20.string(), z20.unknown()),
+  capabilities_snapshot: z20.record(z20.string(), z20.unknown()),
+  auth_mount_snapshot: z20.record(z20.string(), z20.unknown()),
+  checkpoint_policy: z20.record(z20.string(), z20.unknown()),
   restore_source: RuntimeCheckpointRestoreSource.optional()
 });
-var ManagerHelloAckPayload = z19.object({
-  organization_id: z19.string().min(1),
-  runtime_manager_id: z19.string().min(1),
-  server_capabilities: z19.object({
-    supports_server_rebuilt_resume_retry: z19.boolean().optional()
+var ManagerHelloAckPayload = z20.object({
+  organization_id: z20.string().min(1),
+  runtime_manager_id: z20.string().min(1),
+  server_capabilities: z20.object({
+    supports_server_rebuilt_resume_retry: z20.boolean().optional()
   }).optional()
 });
-var ProviderAnnounceAckEntry = z19.object({
+var ProviderAnnounceAckEntry = z20.object({
   provider_kind: ProviderKind,
   remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable().default(null),
-  runtime_provider_id: z19.string().min(1),
+  runtime_provider_id: z20.string().min(1),
   config: RuntimeProviderConfigClientReadCompat.default({}),
   capacity_policy: RuntimeProviderCapacityPolicyClientReadCompat.default({}),
   resolved_secrets: RuntimeProviderResolvedSecretsClientReadCompat.default({})
 });
-var ProviderAnnounceAckPayload = z19.object({
-  providers: z19.array(ProviderAnnounceAckEntry).min(1)
-});
-var SessionReleasePayload = z19.object({
-  session_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  reason: z19.string(),
-  force: z19.boolean().default(false),
-  skip_dirty_probe: z19.boolean().default(false)
-});
-var SessionCheckpointPayload = z19.object({
-  session_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  reason: z19.string().optional()
-});
-var TaskSnapshotContentPayload = z19.object({
-  task_id: z19.string().min(1),
-  trellis_id: z19.string().min(1),
-  project_id: z19.string().min(1),
-  version: z19.number().int(),
-  title: z19.string(),
+var ProviderAnnounceAckPayload = z20.object({
+  providers: z20.array(ProviderAnnounceAckEntry).min(1)
+});
+var SessionReleasePayload = z20.object({
+  session_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  reason: z20.string(),
+  force: z20.boolean().default(false),
+  skip_dirty_probe: z20.boolean().default(false)
+});
+var SessionCheckpointPayload = z20.object({
+  session_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  reason: z20.string().optional()
+});
+var TaskSnapshotContentPayload = z20.object({
+  task_id: z20.string().min(1),
+  trellis_id: z20.string().min(1),
+  project_id: z20.string().min(1),
+  version: z20.number().int(),
+  title: z20.string(),
   status: TaskStatus,
-  prd_md: z19.string(),
-  design_md: z19.string(),
-  implement_md: z19.string()
+  prd_md: z20.string(),
+  design_md: z20.string(),
+  implement_md: z20.string()
 });
-var TaskSnapshotResultPayload = z19.object({
-  request_id: z19.string().min(1),
-  status: z19.enum(["ok", "error"]),
+var TaskSnapshotResultPayload = z20.object({
+  request_id: z20.string().min(1),
+  status: z20.enum(["ok", "error"]),
   task: TaskSnapshotContentPayload.optional(),
-  error: z19.object({
-    code: z19.string().min(1),
-    message: z19.string().min(1)
+  error: z20.object({
+    code: z20.string().min(1),
+    message: z20.string().min(1)
   }).optional()
 });
-var TaskCliUpdateResultPayload = z19.object({
-  request_id: z19.string().min(1),
-  status: z19.enum(["ok", "error", "conflict"]),
-  version: z19.number().int().optional(),
-  current_version: z19.number().int().optional(),
-  error: z19.object({
-    code: z19.string().min(1),
-    message: z19.string().min(1)
+var TaskCliUpdateResultPayload = z20.object({
+  request_id: z20.string().min(1),
+  status: z20.enum(["ok", "error", "conflict"]),
+  version: z20.number().int().optional(),
+  current_version: z20.number().int().optional(),
+  error: z20.object({
+    code: z20.string().min(1),
+    message: z20.string().min(1)
   }).optional()
 });
-var TaskCliCreateResultPayload = z19.object({
-  request_id: z19.string().min(1),
-  status: z19.enum(["ok", "error"]),
-  task_id: z19.string().min(1).optional(),
-  trellis_id: z19.string().min(1).optional(),
-  project_id: z19.string().min(1).optional(),
-  channel_id: z19.string().min(1).optional(),
-  version: z19.number().int().optional(),
+var TaskCliCreateResultPayload = z20.object({
+  request_id: z20.string().min(1),
+  status: z20.enum(["ok", "error"]),
+  task_id: z20.string().min(1).optional(),
+  trellis_id: z20.string().min(1).optional(),
+  project_id: z20.string().min(1).optional(),
+  channel_id: z20.string().min(1).optional(),
+  version: z20.number().int().optional(),
   task_status: TaskStatus.optional(),
-  error: z19.object({
-    code: z19.string().min(1),
-    message: z19.string().min(1)
+  work_branches: z20.array(TaskWorkBranchTarget).optional(),
+  error: z20.object({
+    code: z20.string().min(1),
+    message: z20.string().min(1)
   }).optional()
 });
-var TaskCliStatusUpdateResultPayload = z19.object({
-  request_id: z19.string().min(1),
-  status: z19.enum(["ok", "error", "conflict"]),
-  task_id: z19.string().min(1).optional(),
-  version: z19.number().int().optional(),
+var TaskCliStatusUpdateResultPayload = z20.object({
+  request_id: z20.string().min(1),
+  status: z20.enum(["ok", "error", "conflict"]),
+  task_id: z20.string().min(1).optional(),
+  version: z20.number().int().optional(),
   task_status: TaskStatus.optional(),
-  current_version: z19.number().int().optional(),
-  error: z19.object({
-    code: z19.string().min(1),
-    message: z19.string().min(1)
+  current_version: z20.number().int().optional(),
+  error: z20.object({
+    code: z20.string().min(1),
+    message: z20.string().min(1)
   }).optional()
 });
-var AgentQuestionCreateResultPayload = z19.object({
-  request_id: z19.string().min(1),
-  status: z19.enum(["ok", "error"]),
-  ticket: z19.string().min(1).optional(),
-  error: z19.object({ code: z19.string().min(1), message: z19.string().min(1) }).optional()
-});
-var TaskChangedPayload = z19.object({
-  task_id: z19.string().min(1),
-  trellis_id: z19.string().min(1),
-  project_id: z19.string().min(1),
-  version: z19.number().int()
-});
-var SessionEnsurePayload = z19.object({
-  request_id: z19.string().min(1),
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  project_id: z19.string().min(1).nullable().default(null),
-  task_id: z19.string().min(1).nullable().default(null),
+var AgentQuestionCreateResultPayload = z20.object({
+  request_id: z20.string().min(1),
+  status: z20.enum(["ok", "error"]),
+  ticket: z20.string().min(1).optional(),
+  error: z20.object({ code: z20.string().min(1), message: z20.string().min(1) }).optional()
+});
+var TaskChangedPayload = z20.object({
+  task_id: z20.string().min(1),
+  trellis_id: z20.string().min(1),
+  project_id: z20.string().min(1),
+  version: z20.number().int()
+});
+var SessionEnsurePayload = z20.object({
+  request_id: z20.string().min(1),
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  project_id: z20.string().min(1).nullable().default(null),
+  task_id: z20.string().min(1).nullable().default(null),
   provider_kind: RuntimeProviderKind.nullable().default(null),
   remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable().default(null),
-  repositories: z19.array(TurnDispatchRepository).default([]),
+  repositories: z20.array(TurnDispatchRepository).default([]),
   restore_source: RuntimeCheckpointRestoreSource.optional()
 });
-var TerminalOpenRelayPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  terminal_session_id: z19.string().min(1),
-  cols: z19.number().int().positive(),
-  rows: z19.number().int().positive()
-});
-var TerminalInputRelayPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  terminal_session_id: z19.string().min(1),
-  data: z19.string()
-});
-var TerminalResizeRelayPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  terminal_session_id: z19.string().min(1),
-  cols: z19.number().int().positive(),
-  rows: z19.number().int().positive()
-});
-var TerminalDataRelayPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  terminal_session_id: z19.string().min(1),
-  data_base64: z19.string(),
-  seq: z19.number().int().min(1)
-});
-var TerminalCloseRequestRelayPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  terminal_session_id: z19.string().min(1),
-  reason: z19.string().optional()
-});
-var TerminalCloseReportRelayPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  terminal_session_id: z19.string().min(1),
-  reason: z19.string().optional(),
-  exit_code: z19.number().int().optional(),
-  signal: z19.string().optional(),
-  final_seq: z19.number().int().nonnegative().optional()
-});
-var ServerManagerServicePortHttpProtocol = z19.enum(["http", "https"]);
-var ServerManagerServicePortHeaderBag = z19.record(z19.string(), z19.string());
-var ServicePortRoutingPayload = z19.object({
-  organization_id: z19.string().min(1),
-  channel_id: z19.string().min(1),
-  session_id: z19.string().min(1),
-  service_port_id: z19.string().min(1),
-  proxy_request_id: z19.string().min(1)
+var TerminalOpenRelayPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  terminal_session_id: z20.string().min(1),
+  cols: z20.number().int().positive(),
+  rows: z20.number().int().positive()
+});
+var TerminalInputRelayPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  terminal_session_id: z20.string().min(1),
+  data: z20.string()
+});
+var TerminalResizeRelayPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  terminal_session_id: z20.string().min(1),
+  cols: z20.number().int().positive(),
+  rows: z20.number().int().positive()
+});
+var TerminalDataRelayPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  terminal_session_id: z20.string().min(1),
+  data_base64: z20.string(),
+  seq: z20.number().int().min(1)
+});
+var TerminalCloseRequestRelayPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  terminal_session_id: z20.string().min(1),
+  reason: z20.string().optional()
+});
+var TerminalCloseReportRelayPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  terminal_session_id: z20.string().min(1),
+  reason: z20.string().optional(),
+  exit_code: z20.number().int().optional(),
+  signal: z20.string().optional(),
+  final_seq: z20.number().int().nonnegative().optional()
+});
+var ServerManagerServicePortHttpProtocol = z20.enum(["http", "https"]);
+var ServerManagerServicePortHeaderBag = z20.record(z20.string(), z20.string());
+var ServicePortRoutingPayload = z20.object({
+  organization_id: z20.string().min(1),
+  channel_id: z20.string().min(1),
+  session_id: z20.string().min(1),
+  service_port_id: z20.string().min(1),
+  proxy_request_id: z20.string().min(1)
 });
 var ServicePortHttpRequestRelayPayload = ServicePortRoutingPayload.extend({
-  target_host: z19.string().min(1),
-  target_port: z19.number().int().min(1).max(65535),
+  target_host: z20.string().min(1),
+  target_port: z20.number().int().min(1).max(65535),
   protocol: ServerManagerServicePortHttpProtocol,
-  method: z19.string().min(1),
-  path: z19.string().min(1),
+  method: z20.string().min(1),
+  path: z20.string().min(1),
   headers: ServerManagerServicePortHeaderBag.default({}),
-  body_base64: z19.string().nullable().default(null)
+  body_base64: z20.string().nullable().default(null)
 });
 var ServicePortHttpCancelRelayPayload = ServicePortRoutingPayload.extend({
-  reason: z19.string().optional()
+  reason: z20.string().optional()
 });
 var ServicePortHttpResponseStartRelayPayload = ServicePortRoutingPayload.extend({
-  status: z19.number().int().min(100).max(599),
+  status: z20.number().int().min(100).max(599),
   headers: ServerManagerServicePortHeaderBag.default({})
 });
 var ServicePortHttpBodyRelayPayload = ServicePortRoutingPayload.extend({
-  body_base64: z19.string()
+  body_base64: z20.string()
 });
 var ServicePortHttpEndRelayPayload = ServicePortRoutingPayload;
 var ServicePortHttpErrorRelayPayload = ServicePortRoutingPayload.extend({
-  reason: z19.enum([
+  reason: z20.enum([
     "runner_unsupported",
     "session_unavailable",
     "port_unavailable",
     "proxy_failed",
     "invalid_target"
   ]),
-  message: z19.string().optional()
+  message: z20.string().optional()
 });
 var ServicePortWsOpenRelayPayload = ServicePortRoutingPayload.extend({
-  target_host: z19.string().min(1),
-  target_port: z19.number().int().min(1).max(65535),
+  target_host: z20.string().min(1),
+  target_port: z20.number().int().min(1).max(65535),
   protocol: ServerManagerServicePortHttpProtocol,
-  path: z19.string().min(1),
+  path: z20.string().min(1),
   headers: ServerManagerServicePortHeaderBag.default({})
 });
 var ServicePortWsDataRelayPayload = ServicePortRoutingPayload.extend({
-  data_base64: z19.string(),
-  is_binary: z19.boolean().default(false)
+  data_base64: z20.string(),
+  is_binary: z20.boolean().default(false)
 });
 var ServicePortWsCloseRelayPayload = ServicePortRoutingPayload.extend({
-  code: z19.number().int().min(1000).max(4999).optional(),
-  reason: z19.string().optional()
+  code: z20.number().int().min(1000).max(4999).optional(),
+  reason: z20.string().optional()
 });
 var ServicePortWsOpenedRelayPayload = ServicePortRoutingPayload;
 var ServicePortWsErrorRelayPayload = ServicePortRoutingPayload.extend({
-  reason: z19.enum([
+  reason: z20.enum([
     "runner_unsupported",
     "session_unavailable",
     "port_unavailable",
     "proxy_failed",
     "invalid_target"
   ]),
-  message: z19.string().optional()
+  message: z20.string().optional()
 });
-var ManagerToServerMessage = z19.discriminatedUnion("type", [
-  z19.object({ type: z19.literal("manager.hello"), payload: ManagerHelloPayload }),
-  z19.object({
-    type: z19.literal("manager.heartbeat"),
+var ManagerToServerMessage = z20.discriminatedUnion("type", [
+  z20.object({ type: z20.literal("manager.hello"), payload: ManagerHelloPayload }),
+  z20.object({
+    type: z20.literal("manager.heartbeat"),
     payload: ManagerHeartbeatPayload
   }),
-  z19.object({
-    type: z19.literal("provider.announce"),
+  z20.object({
+    type: z20.literal("provider.announce"),
     payload: ProviderAnnouncePayload
   }),
-  z19.object({
-    type: z19.literal("session.state"),
+  z20.object({
+    type: z20.literal("session.state"),
     payload: SessionStatePayload
   }),
-  z19.object({
-    type: z19.literal("runner.state"),
+  z20.object({
+    type: z20.literal("runner.state"),
     payload: RunnerStatePayload
   }),
-  z19.object({
-    type: z19.literal("agent_session.state"),
+  z20.object({
+    type: z20.literal("agent_session.state"),
     payload: AgentSessionStatePayload
   }),
-  z19.object({ type: z19.literal("turn.event"), payload: ManagerTurnEventPayload }),
-  z19.object({
-    type: z19.literal("turn.finished"),
+  z20.object({ type: z20.literal("turn.event"), payload: ManagerTurnEventPayload }),
+  z20.object({
+    type: z20.literal("turn.finished"),
     payload: ManagerTurnFinishedPayload
   }),
-  z19.object({
-    type: z19.literal("manager.stale_session"),
+  z20.object({
+    type: z20.literal("manager.stale_session"),
     payload: ManagerStaleSessionPayload
   }),
-  z19.object({
-    type: z19.literal("task.snapshot.get"),
+  z20.object({
+    type: z20.literal("task.snapshot.get"),
     payload: TaskSnapshotGetPayload
   }),
-  z19.object({
-    type: z19.literal("task.cli_update"),
+  z20.object({
+    type: z20.literal("task.cli_update"),
     payload: TaskCliUpdatePayload
   }),
-  z19.object({
-    type: z19.literal("task.cli_create"),
+  z20.object({
+    type: z20.literal("task.cli_create"),
     payload: TaskCliCreatePayload
   }),
-  z19.object({
-    type: z19.literal("task.cli_status_update"),
+  z20.object({
+    type: z20.literal("task.cli_status_update"),
     payload: TaskCliStatusUpdatePayload
   }),
-  z19.object({
-    type: z19.literal("task.refs_snapshot"),
+  z20.object({
+    type: z20.literal("task.refs_snapshot"),
     payload: ManagerTaskRefsSnapshotPayload
   }),
-  z19.object({
-    type: z19.literal("agent.question.create"),
+  z20.object({
+    type: z20.literal("agent.question.create"),
     payload: AgentQuestionCreatePayload
   }),
-  z19.object({
-    type: z19.literal("terminal.data"),
+  z20.object({
+    type: z20.literal("terminal.data"),
     payload: TerminalDataRelayPayload
   }),
-  z19.object({
-    type: z19.literal("terminal.close"),
+  z20.object({
+    type: z20.literal("terminal.close"),
     payload: TerminalCloseReportRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.http.response_start"),
+  z20.object({
+    type: z20.literal("service_port.http.response_start"),
     payload: ServicePortHttpResponseStartRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.http.body"),
+  z20.object({
+    type: z20.literal("service_port.http.body"),
     payload: ServicePortHttpBodyRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.http.end"),
+  z20.object({
+    type: z20.literal("service_port.http.end"),
     payload: ServicePortHttpEndRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.http.error"),
+  z20.object({
+    type: z20.literal("service_port.http.error"),
     payload: ServicePortHttpErrorRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.opened"),
+  z20.object({
+    type: z20.literal("service_port.ws.opened"),
     payload: ServicePortWsOpenedRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.data"),
+  z20.object({
+    type: z20.literal("service_port.ws.data"),
     payload: ServicePortWsDataRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.close"),
+  z20.object({
+    type: z20.literal("service_port.ws.close"),
     payload: ServicePortWsCloseRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.error"),
+  z20.object({
+    type: z20.literal("service_port.ws.error"),
     payload: ServicePortWsErrorRelayPayload
   })
 ]);
-var ServerToManagerMessage = z19.discriminatedUnion("type", [
-  z19.object({
-    type: z19.literal("manager.hello.ack"),
+var ServerToManagerMessage = z20.discriminatedUnion("type", [
+  z20.object({
+    type: z20.literal("manager.hello.ack"),
     payload: ManagerHelloAckPayload
   }),
-  z19.object({
-    type: z19.literal("provider.announce.ack"),
+  z20.object({
+    type: z20.literal("provider.announce.ack"),
     payload: ProviderAnnounceAckPayload
   }),
-  z19.object({ type: z19.literal("turn.dispatch"), payload: TurnDispatchPayload }),
-  z19.object({
-    type: z19.literal("turn.cancel"),
+  z20.object({ type: z20.literal("turn.dispatch"), payload: TurnDispatchPayload }),
+  z20.object({
+    type: z20.literal("turn.cancel"),
     payload: TurnCancelDispatchPayload
   }),
-  z19.object({
-    type: z19.literal("session.create"),
+  z20.object({
+    type: z20.literal("session.create"),
     payload: SessionCreatePayload
   }),
-  z19.object({
-    type: z19.literal("session.release"),
+  z20.object({
+    type: z20.literal("session.release"),
     payload: SessionReleasePayload
   }),
-  z19.object({
-    type: z19.literal("session.checkpoint"),
+  z20.object({
+    type: z20.literal("session.checkpoint"),
     payload: SessionCheckpointPayload
   }),
-  z19.object({
-    type: z19.literal("task.snapshot.result"),
+  z20.object({
+    type: z20.literal("task.snapshot.result"),
     payload: TaskSnapshotResultPayload
   }),
-  z19.object({
-    type: z19.literal("task.cli_update.result"),
+  z20.object({
+    type: z20.literal("task.cli_update.result"),
     payload: TaskCliUpdateResultPayload
   }),
-  z19.object({
-    type: z19.literal("task.cli_create.result"),
+  z20.object({
+    type: z20.literal("task.cli_create.result"),
     payload: TaskCliCreateResultPayload
   }),
-  z19.object({
-    type: z19.literal("task.cli_status_update.result"),
+  z20.object({
+    type: z20.literal("task.cli_status_update.result"),
     payload: TaskCliStatusUpdateResultPayload
   }),
-  z19.object({
-    type: z19.literal("agent.question.create.result"),
+  z20.object({
+    type: z20.literal("agent.question.create.result"),
     payload: AgentQuestionCreateResultPayload
   }),
-  z19.object({ type: z19.literal("task.changed"), payload: TaskChangedPayload }),
-  z19.object({
-    type: z19.literal("session.ensure"),
+  z20.object({ type: z20.literal("task.changed"), payload: TaskChangedPayload }),
+  z20.object({
+    type: z20.literal("session.ensure"),
     payload: SessionEnsurePayload
   }),
-  z19.object({
-    type: z19.literal("terminal.open"),
+  z20.object({
+    type: z20.literal("terminal.open"),
     payload: TerminalOpenRelayPayload
   }),
-  z19.object({
-    type: z19.literal("terminal.input"),
+  z20.object({
+    type: z20.literal("terminal.input"),
     payload: TerminalInputRelayPayload
   }),
-  z19.object({
-    type: z19.literal("terminal.resize"),
+  z20.object({
+    type: z20.literal("terminal.resize"),
     payload: TerminalResizeRelayPayload
   }),
-  z19.object({
-    type: z19.literal("terminal.close"),
+  z20.object({
+    type: z20.literal("terminal.close"),
     payload: TerminalCloseRequestRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.http.request"),
+  z20.object({
+    type: z20.literal("service_port.http.request"),
     payload: ServicePortHttpRequestRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.http.cancel"),
+  z20.object({
+    type: z20.literal("service_port.http.cancel"),
     payload: ServicePortHttpCancelRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.open"),
+  z20.object({
+    type: z20.literal("service_port.ws.open"),
     payload: ServicePortWsOpenRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.data"),
+  z20.object({
+    type: z20.literal("service_port.ws.data"),
     payload: ServicePortWsDataRelayPayload
   }),
-  z19.object({
-    type: z19.literal("service_port.ws.close"),
+  z20.object({
+    type: z20.literal("service_port.ws.close"),
     payload: ServicePortWsCloseRelayPayload
   })
 ]);
 
 // ../../packages/protocol/src/runtime-repos-manifest.ts
-var RuntimeReposManifestEntry = z20.object({
-  repository_id: z20.string().min(1),
-  repo_slug: z20.string().min(1),
-  repo_path: z20.string().min(1),
-  repo_remote: z20.string().min(1),
-  repo_branch: z20.string().min(1).nullable(),
-  work_branch: z20.string().min(1).nullable().default(null),
-  setup_script: z20.string().nullable(),
+var RuntimeReposManifestEntry = z21.object({
+  repository_id: z21.string().min(1),
+  repo_slug: z21.string().min(1),
+  repo_path: z21.string().min(1),
+  repo_remote: z21.string().min(1),
+  repo_branch: z21.string().min(1).nullable(),
+  work_branch: z21.string().min(1).nullable().default(null),
+  setup_script: z21.string().nullable(),
   env_template: MaterializedRepoEnvTemplate.default(EMPTY_MATERIALIZED_REPO_ENV_TEMPLATE),
-  env_prepare_script: z20.string().nullable().default(null),
+  env_prepare_script: z21.string().nullable().default(null),
   git_auth: TurnDispatchGitAuth.nullable()
 }).strict();
-var RuntimeReposManifest = z20.array(RuntimeReposManifestEntry);
+var RuntimeReposManifest = z21.array(RuntimeReposManifestEntry);
 function serializeRuntimeReposManifest(repos) {
   return JSON.stringify(repos.map((repo) => {
     const envTemplate = MaterializedRepoEnvTemplate.parse(repo.envTemplate ?? EMPTY_MATERIALIZED_REPO_ENV_TEMPLATE);
@@ -4410,23 +4440,23 @@ import { tmpdir as tmpdir3 } from "node:os";
 import { join as join7 } from "node:path";
 
 // ../../packages/protocol/src/agent-backend-auth-api.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // ../../packages/protocol/src/agent-backend-auth-descriptor.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 
 // ../../packages/protocol-core/src/codex-auth.ts
-import { z as z21 } from "zod";
-var CodexChatgptAuthBundle = z21.object({
-  accessToken: z21.string().min(1),
-  idToken: z21.string().min(1),
-  refreshToken: z21.string().min(1),
-  accountId: z21.string().min(1),
-  lastRefresh: z21.string().min(1).optional()
+import { z as z22 } from "zod";
+var CodexChatgptAuthBundle = z22.object({
+  accessToken: z22.string().min(1),
+  idToken: z22.string().min(1),
+  refreshToken: z22.string().min(1),
+  accountId: z22.string().min(1),
+  lastRefresh: z22.string().min(1).optional()
 });
 
 // ../../packages/protocol/src/agent-backend-auth-descriptor.ts
-var BackendSetupMode = z22.enum(["byok", "account", "self"]);
+var BackendSetupMode = z23.enum(["byok", "account", "self"]);
 var BACKEND_AUTH_DESCRIPTORS = [
   {
     backend: "claude",
@@ -4459,64 +4489,64 @@ var BACKEND_AUTH_DESCRIPTOR_BY_BACKEND = Object.freeze(Object.fromEntries(BACKEN
 ])));
 
 // ../../packages/protocol/src/agent-backend-auth-api.ts
-var BackendByokProvider = z23.enum(["anthropic", "openai_compatible"]);
-var BackendAuthGetInput = z23.object({ backend_kind: BackendKind }).strict();
-var BackendSetByokInput = z23.object({
+var BackendByokProvider = z24.enum(["anthropic", "openai_compatible"]);
+var BackendAuthGetInput = z24.object({ backend_kind: BackendKind }).strict();
+var BackendSetByokInput = z24.object({
   backend_kind: BackendKind,
-  api_key: z23.string().trim().min(1).max(8192),
-  base_url: z23.string().trim().min(1).max(2048).optional(),
+  api_key: z24.string().trim().min(1).max(8192),
+  base_url: z24.string().trim().min(1).max(2048).optional(),
   provider: BackendByokProvider.optional()
 }).strict();
-var BackendClearByokInput = z23.object({ backend_kind: BackendKind }).strict();
-var BackendAuthAccountStatusDto = z23.object({
-  account_id: z23.string(),
-  expires_at: z23.string()
+var BackendClearByokInput = z24.object({ backend_kind: BackendKind }).strict();
+var BackendAuthAccountStatusDto = z24.object({
+  account_id: z24.string(),
+  expires_at: z24.string()
 }).strict();
-var BackendAuthStatusDto = z23.object({
+var BackendAuthStatusDto = z24.object({
   backend_kind: BackendKind,
   mode: BackendSetupMode,
-  byok_configured: z23.boolean(),
+  byok_configured: z24.boolean(),
   account: BackendAuthAccountStatusDto.nullable()
 }).strict();
-var CodexOauthStartInput = z23.object({}).strict();
-var CodexOauthStartDto = z23.object({
-  login_id: z23.string().min(1),
-  verification_url: z23.string().url(),
-  user_code: z23.string().min(1),
-  interval_seconds: z23.number().int().positive(),
-  expires_at: z23.string().min(1)
+var CodexOauthStartInput = z24.object({}).strict();
+var CodexOauthStartDto = z24.object({
+  login_id: z24.string().min(1),
+  verification_url: z24.string().url(),
+  user_code: z24.string().min(1),
+  interval_seconds: z24.number().int().positive(),
+  expires_at: z24.string().min(1)
 }).strict();
-var CodexOauthPollInput = z23.object({ login_id: z23.string().min(1) }).strict();
-var CodexOauthPollDto = z23.discriminatedUnion("status", [
-  z23.object({
-    status: z23.literal("pending"),
-    next_poll_after: z23.string().min(1).optional()
+var CodexOauthPollInput = z24.object({ login_id: z24.string().min(1) }).strict();
+var CodexOauthPollDto = z24.discriminatedUnion("status", [
+  z24.object({
+    status: z24.literal("pending"),
+    next_poll_after: z24.string().min(1).optional()
   }).strict(),
-  z23.object({
-    status: z23.literal("connected"),
-    account_id: z23.string().min(1),
-    expires_at: z23.string().min(1)
+  z24.object({
+    status: z24.literal("connected"),
+    account_id: z24.string().min(1),
+    expires_at: z24.string().min(1)
   }).strict(),
-  z23.object({ status: z23.literal("expired") }).strict(),
-  z23.object({ status: z23.literal("failed"), error: z23.string().min(1) }).strict()
+  z24.object({ status: z24.literal("expired") }).strict(),
+  z24.object({ status: z24.literal("failed"), error: z24.string().min(1) }).strict()
 ]);
-var CodexOauthStatusInput = z23.object({}).strict();
-var CodexOauthStatusDto = z23.object({
-  connected: z23.boolean(),
-  account_id: z23.string().min(1).optional(),
-  expires_at: z23.string().min(1).optional()
+var CodexOauthStatusInput = z24.object({}).strict();
+var CodexOauthStatusDto = z24.object({
+  connected: z24.boolean(),
+  account_id: z24.string().min(1).optional(),
+  expires_at: z24.string().min(1).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.connected) {
     if (!value.account_id) {
       ctx.addIssue({
-        code: z23.ZodIssueCode.custom,
+        code: z24.ZodIssueCode.custom,
         path: ["account_id"],
         message: "account_id is required when connected"
       });
     }
     if (!value.expires_at) {
       ctx.addIssue({
-        code: z23.ZodIssueCode.custom,
+        code: z24.ZodIssueCode.custom,
         path: ["expires_at"],
         message: "expires_at is required when connected"
       });
@@ -4525,21 +4555,21 @@ var CodexOauthStatusDto = z23.object({
   }
   if (value.account_id || value.expires_at) {
     ctx.addIssue({
-      code: z23.ZodIssueCode.custom,
+      code: z24.ZodIssueCode.custom,
       message: "account metadata is only valid when connected"
     });
   }
 });
-var CodexOauthUnbindInput = z23.object({}).strict();
+var CodexOauthUnbindInput = z24.object({}).strict();
 // ../../packages/protocol/src/agent-observability.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 
 // ../../packages/protocol-core/src/events.ts
-import { z as z24 } from "zod";
-var TextDeltaData = z24.object({
-  content: z24.string()
+import { z as z25 } from "zod";
+var TextDeltaData = z25.object({
+  content: z25.string()
 });
-var ToolKind = z24.enum([
+var ToolKind = z25.enum([
   "builtin",
   "shell",
   "function",
@@ -4548,53 +4578,53 @@ var ToolKind = z24.enum([
   "file",
   "unknown"
 ]);
-var ToolAttributesData = z24.object({
-  mcp: z24.object({ server: z24.string(), tool: z24.string() }).optional(),
-  shell: z24.object({ command_kind: z24.string().optional() }).optional(),
-  function: z24.object({ name: z24.string().optional() }).optional(),
-  web_search: z24.object({ provider: z24.string().optional() }).optional(),
-  file: z24.object({ operation: z24.string().optional() }).optional()
+var ToolAttributesData = z25.object({
+  mcp: z25.object({ server: z25.string(), tool: z25.string() }).optional(),
+  shell: z25.object({ command_kind: z25.string().optional() }).optional(),
+  function: z25.object({ name: z25.string().optional() }).optional(),
+  web_search: z25.object({ provider: z25.string().optional() }).optional(),
+  file: z25.object({ operation: z25.string().optional() }).optional()
 }).default({});
-var ToolCallData = z24.object({
-  schema_version: z24.number().int().default(1),
-  call_id: z24.string().min(1),
-  name: z24.string(),
+var ToolCallData = z25.object({
+  schema_version: z25.number().int().default(1),
+  call_id: z25.string().min(1),
+  name: z25.string(),
   tool_kind: ToolKind.default("unknown"),
   input: JsonObject.default({}),
   attributes: ToolAttributesData,
   metadata: JsonObject.optional()
 });
-var ToolResultData = z24.object({
-  schema_version: z24.number().int().default(1),
-  call_id: z24.string().min(1),
-  name: z24.string().optional(),
+var ToolResultData = z25.object({
+  schema_version: z25.number().int().default(1),
+  call_id: z25.string().min(1),
+  name: z25.string().optional(),
   tool_kind: ToolKind.default("unknown"),
-  is_error: z24.boolean().default(false),
-  output: z24.string().optional(),
+  is_error: z25.boolean().default(false),
+  output: z25.string().optional(),
   output_json: JsonObject.optional(),
   attributes: ToolAttributesData,
   error: JsonObject.optional(),
   metadata: JsonObject.optional()
 });
-var ReasoningData = z24.object({
-  content: z24.string()
+var ReasoningData = z25.object({
+  content: z25.string()
 });
-var ErrorEventData = z24.object({
-  message: z24.string(),
-  source: z24.enum(["daemon", "cli", "agent", "unknown"]).default("unknown"),
+var ErrorEventData = z25.object({
+  message: z25.string(),
+  source: z25.enum(["daemon", "cli", "agent", "unknown"]).default("unknown"),
   details: JsonObject.optional()
 });
-var MetaEventData = z24.object({
-  event: z24.string(),
+var MetaEventData = z25.object({
+  event: z25.string(),
   data: JsonObject.optional()
 });
-var AgentEventPayload = z24.discriminatedUnion("kind", [
-  z24.object({ kind: z24.literal("text_delta"), data: TextDeltaData }),
-  z24.object({ kind: z24.literal("tool_call"), data: ToolCallData }),
-  z24.object({ kind: z24.literal("tool_result"), data: ToolResultData }),
-  z24.object({ kind: z24.literal("reasoning"), data: ReasoningData }),
-  z24.object({ kind: z24.literal("error"), data: ErrorEventData }),
-  z24.object({ kind: z24.literal("meta"), data: MetaEventData })
+var AgentEventPayload = z25.discriminatedUnion("kind", [
+  z25.object({ kind: z25.literal("text_delta"), data: TextDeltaData }),
+  z25.object({ kind: z25.literal("tool_call"), data: ToolCallData }),
+  z25.object({ kind: z25.literal("tool_result"), data: ToolResultData }),
+  z25.object({ kind: z25.literal("reasoning"), data: ReasoningData }),
+  z25.object({ kind: z25.literal("error"), data: ErrorEventData }),
+  z25.object({ kind: z25.literal("meta"), data: MetaEventData })
 ]);
 // ../../packages/protocol/src/agent-observability.ts
 var AGENT_OBSERVATION_KINDS = [
@@ -4610,7 +4640,7 @@ var AGENT_OBSERVATION_KINDS = [
   "usage",
   "event"
 ];
-var AgentObservationKind = z25.enum(AGENT_OBSERVATION_KINDS);
+var AgentObservationKind = z26.enum(AGENT_OBSERVATION_KINDS);
 var AGENT_OBSERVATION_STATUSES = [
   "pending",
   "succeeded",
@@ -4620,15 +4650,15 @@ var AGENT_OBSERVATION_STATUSES = [
   "cancelled",
   "unknown"
 ];
-var AgentObservationStatus = z25.enum(AGENT_OBSERVATION_STATUSES);
+var AgentObservationStatus = z26.enum(AGENT_OBSERVATION_STATUSES);
 var AGENT_OBSERVATION_ADAPTER_MODES = [
   "legacy",
   "sdk",
   "acp",
   "unknown"
 ];
-var AgentObservationAdapterMode = z25.enum(AGENT_OBSERVATION_ADAPTER_MODES);
-var AgentTraceDateTime = z25.string().datetime({ offset: true });
+var AgentObservationAdapterMode = z26.enum(AGENT_OBSERVATION_ADAPTER_MODES);
+var AgentTraceDateTime = z26.string().datetime({ offset: true });
 var AgentTraceNullableDateTime = AgentTraceDateTime.nullable();
 var AgentTraceScopeShape = {
   agent_turn_id: Id.optional(),
@@ -4636,12 +4666,12 @@ var AgentTraceScopeShape = {
   task_id: Id.optional(),
   project_id: Id.optional()
 };
-var AgentTraceStatuses = z25.array(AgentObservationStatus).min(1);
-var AgentTraceKinds = z25.array(AgentObservationKind).min(1);
-var AgentTraceCursorDto = z25.object({
-  boundary_seq: z25.number().int().nonnegative(),
+var AgentTraceStatuses = z26.array(AgentObservationStatus).min(1);
+var AgentTraceKinds = z26.array(AgentObservationKind).min(1);
+var AgentTraceCursorDto = z26.object({
+  boundary_seq: z26.number().int().nonnegative(),
   created_at: AgentTraceDateTime,
-  observation_key: z25.string().min(1)
+  observation_key: z26.string().min(1)
 });
 function refineExactlyOneTraceScope(value, ctx) {
   const count = [
@@ -4652,58 +4682,58 @@ function refineExactlyOneTraceScope(value, ctx) {
   ].filter((id) => id !== undefined).length;
   if (count !== 1) {
     ctx.addIssue({
-      code: z25.ZodIssueCode.custom,
+      code: z26.ZodIssueCode.custom,
       message: "exactly one trace scope is required: agent_turn_id, channel_id, task_id, or project_id"
     });
   }
 }
-var AgentTurnTraceGetInput = z25.object({
+var AgentTurnTraceGetInput = z26.object({
   agent_turn_id: Id,
   kind: AgentTraceKinds.optional(),
   status: AgentTraceStatuses.optional(),
-  after_seq: z25.number().int().nonnegative().optional(),
+  after_seq: z26.number().int().nonnegative().optional(),
   after_cursor: AgentTraceCursorDto.optional(),
-  limit: z25.number().int().positive().max(500).optional()
+  limit: z26.number().int().positive().max(500).optional()
 });
-var AgentTurnTraceStatsInput = z25.object({
+var AgentTurnTraceStatsInput = z26.object({
   ...AgentTraceScopeShape,
   time_from: AgentTraceDateTime.optional(),
   time_to: AgentTraceDateTime.optional(),
   agent_profile_id: Id.optional(),
-  backend_kind: z25.string().min(1).optional(),
-  model: z25.string().min(1).optional(),
+  backend_kind: z26.string().min(1).optional(),
+  model: z26.string().min(1).optional(),
   tool_kind: ToolKind.optional(),
-  mcp_server: z25.string().min(1).optional(),
-  mcp_tool: z25.string().min(1).optional(),
+  mcp_server: z26.string().min(1).optional(),
+  mcp_tool: z26.string().min(1).optional(),
   observation_status: AgentObservationStatus.optional(),
-  limit: z25.number().int().positive().max(5000).optional()
+  limit: z26.number().int().positive().max(5000).optional()
 }).superRefine(refineExactlyOneTraceScope);
-var AgentTurnTraceContextAtInput = z25.object({
+var AgentTurnTraceContextAtInput = z26.object({
   agent_turn_id: Id,
-  seq: z25.number().int().positive().optional(),
-  observation_key: z25.string().min(1).optional()
+  seq: z26.number().int().positive().optional(),
+  observation_key: z26.string().min(1).optional()
 }).superRefine((value, ctx) => {
   const count = [value.seq, value.observation_key].filter((locator) => locator !== undefined).length;
   if (count !== 1) {
     ctx.addIssue({
-      code: z25.ZodIssueCode.custom,
+      code: z26.ZodIssueCode.custom,
       message: "exactly one context locator is required: seq or observation_key"
     });
   }
 });
-var AgentTraceObservationProvenanceDto = z25.object({
+var AgentTraceObservationProvenanceDto = z26.object({
   agent_turn_id: Id,
-  observation_key: z25.string().min(1),
-  start_seq: z25.number().int().positive().nullable(),
-  end_seq: z25.number().int().positive().nullable(),
-  source_seq: z25.number().int().positive().nullable()
+  observation_key: z26.string().min(1),
+  start_seq: z26.number().int().positive().nullable(),
+  end_seq: z26.number().int().positive().nullable(),
+  source_seq: z26.number().int().positive().nullable()
 });
-var AgentTraceSourcePointerDto = z25.object({
+var AgentTraceSourcePointerDto = z26.object({
   agent_turn_id: Id,
-  observation_key: z25.string().min(1),
-  source_seq: z25.number().int().positive().nullable()
+  observation_key: z26.string().min(1),
+  source_seq: z26.number().int().positive().nullable()
 });
-var AgentTraceObservationDto = z25.object({
+var AgentTraceObservationDto = z26.object({
   id: Id,
   agent_turn_id: Id,
   channel_id: Id,
@@ -4714,29 +4744,29 @@ var AgentTraceObservationDto = z25.object({
   channel_linked_task_id: Id.nullable(),
   agent_profile_id: Id,
   project_agent_profile_id: Id.nullable(),
-  observation_key: z25.string().min(1),
-  parent_observation_key: z25.string().min(1).nullable(),
+  observation_key: z26.string().min(1),
+  parent_observation_key: z26.string().min(1).nullable(),
   kind: AgentObservationKind,
-  name: z25.string(),
+  name: z26.string(),
   status: AgentObservationStatus,
-  start_seq: z25.number().int().positive().nullable(),
-  end_seq: z25.number().int().positive().nullable(),
+  start_seq: z26.number().int().positive().nullable(),
+  end_seq: z26.number().int().positive().nullable(),
   started_at: AgentTraceNullableDateTime,
   ended_at: AgentTraceNullableDateTime,
-  duration_ms: z25.number().int().nonnegative().nullable(),
-  backend_kind: z25.string().nullable(),
+  duration_ms: z26.number().int().nonnegative().nullable(),
+  backend_kind: z26.string().nullable(),
   adapter_mode: AgentObservationAdapterMode.nullable(),
-  model: z25.string().nullable(),
-  runtime_provider_kind: z25.string().nullable(),
-  runtime_session_id: z25.string().nullable(),
-  external_session_id: z25.string().nullable(),
-  environment: z25.string().nullable(),
-  app_version: z25.string().nullable(),
-  trace_name: z25.string().nullable(),
+  model: z26.string().nullable(),
+  runtime_provider_kind: z26.string().nullable(),
+  runtime_session_id: z26.string().nullable(),
+  external_session_id: z26.string().nullable(),
+  environment: z26.string().nullable(),
+  app_version: z26.string().nullable(),
+  trace_name: z26.string().nullable(),
   tool_kind: ToolKind.nullable(),
-  tool_call_id_hash: z25.string().nullable(),
-  mcp_server: z25.string().nullable(),
-  mcp_tool: z25.string().nullable(),
+  tool_call_id_hash: z26.string().nullable(),
+  mcp_server: z26.string().nullable(),
+  mcp_tool: z26.string().nullable(),
   input_summary: JsonObject,
   output_summary: JsonObject,
   error: JsonObject.nullable(),
@@ -4747,60 +4777,60 @@ var AgentTraceObservationDto = z25.object({
   updated_at: AgentTraceDateTime,
   provenance: AgentTraceObservationProvenanceDto
 });
-var AgentTraceCountBucketDto = z25.object({
-  key: z25.string(),
-  count: z25.number().int().nonnegative(),
-  sources: z25.array(AgentTraceSourcePointerDto)
-});
-var AgentTraceToolHealthDto = z25.object({
-  total: z25.number().int().nonnegative(),
-  succeeded: z25.number().int().nonnegative(),
-  failed: z25.number().int().nonnegative(),
-  missing: z25.number().int().nonnegative(),
-  unsupported: z25.number().int().nonnegative(),
-  pending: z25.number().int().nonnegative(),
-  cancelled: z25.number().int().nonnegative(),
-  unknown: z25.number().int().nonnegative()
-});
-var AgentTraceUsageSummaryDto = z25.object({
-  mode: z25.literal("reported_top_level"),
-  input_tokens: z25.number().nullable(),
-  output_tokens: z25.number().nullable(),
-  total_tokens: z25.number().nullable(),
-  cached_tokens: z25.number().nullable(),
-  reasoning_tokens: z25.number().nullable(),
-  sources: z25.array(AgentTraceSourcePointerDto)
-});
-var AgentTraceCostSummaryDto = z25.object({
-  mode: z25.literal("reported_top_level"),
-  total_cost_usd: z25.number().nullable(),
-  sources: z25.array(AgentTraceSourcePointerDto)
-});
-var AgentTraceMcpToolStatsDto = z25.object({
-  server: z25.string(),
-  tool: z25.string(),
-  total: z25.number().int().nonnegative(),
-  statuses: z25.record(z25.string(), z25.number().int().nonnegative()),
-  sources: z25.array(AgentTraceSourcePointerDto)
-});
-var AgentTraceCapabilityGapDto = z25.object({
-  kind: z25.string(),
-  message: z25.string(),
-  count: z25.number().int().nonnegative(),
-  sources: z25.array(AgentTraceSourcePointerDto)
-});
-var AgentTraceHealthSummaryDto = z25.object({
-  observation_count: z25.number().int().nonnegative(),
-  by_kind: z25.array(AgentTraceCountBucketDto),
-  by_status: z25.array(AgentTraceCountBucketDto),
+var AgentTraceCountBucketDto = z26.object({
+  key: z26.string(),
+  count: z26.number().int().nonnegative(),
+  sources: z26.array(AgentTraceSourcePointerDto)
+});
+var AgentTraceToolHealthDto = z26.object({
+  total: z26.number().int().nonnegative(),
+  succeeded: z26.number().int().nonnegative(),
+  failed: z26.number().int().nonnegative(),
+  missing: z26.number().int().nonnegative(),
+  unsupported: z26.number().int().nonnegative(),
+  pending: z26.number().int().nonnegative(),
+  cancelled: z26.number().int().nonnegative(),
+  unknown: z26.number().int().nonnegative()
+});
+var AgentTraceUsageSummaryDto = z26.object({
+  mode: z26.literal("reported_top_level"),
+  input_tokens: z26.number().nullable(),
+  output_tokens: z26.number().nullable(),
+  total_tokens: z26.number().nullable(),
+  cached_tokens: z26.number().nullable(),
+  reasoning_tokens: z26.number().nullable(),
+  sources: z26.array(AgentTraceSourcePointerDto)
+});
+var AgentTraceCostSummaryDto = z26.object({
+  mode: z26.literal("reported_top_level"),
+  total_cost_usd: z26.number().nullable(),
+  sources: z26.array(AgentTraceSourcePointerDto)
+});
+var AgentTraceMcpToolStatsDto = z26.object({
+  server: z26.string(),
+  tool: z26.string(),
+  total: z26.number().int().nonnegative(),
+  statuses: z26.record(z26.string(), z26.number().int().nonnegative()),
+  sources: z26.array(AgentTraceSourcePointerDto)
+});
+var AgentTraceCapabilityGapDto = z26.object({
+  kind: z26.string(),
+  message: z26.string(),
+  count: z26.number().int().nonnegative(),
+  sources: z26.array(AgentTraceSourcePointerDto)
+});
+var AgentTraceHealthSummaryDto = z26.object({
+  observation_count: z26.number().int().nonnegative(),
+  by_kind: z26.array(AgentTraceCountBucketDto),
+  by_status: z26.array(AgentTraceCountBucketDto),
   tool_health: AgentTraceToolHealthDto,
-  mcp_tool_count: z25.number().int().nonnegative(),
+  mcp_tool_count: z26.number().int().nonnegative(),
   usage: AgentTraceUsageSummaryDto,
   cost: AgentTraceCostSummaryDto,
-  capability_gaps: z25.array(AgentTraceCapabilityGapDto),
-  truncated: z25.boolean()
+  capability_gaps: z26.array(AgentTraceCapabilityGapDto),
+  truncated: z26.boolean()
 });
-var AgentTraceTurnIdentityDto = z25.object({
+var AgentTraceTurnIdentityDto = z26.object({
   id: Id,
   channel_id: Id,
   project_id: Id.nullable(),
@@ -4809,18 +4839,18 @@ var AgentTraceTurnIdentityDto = z25.object({
   agent_turn_task_id: Id.nullable(),
   channel_linked_task_id: Id.nullable(),
   parent_agent_turn_id: Id.nullable(),
-  turn_kind: z25.string(),
+  turn_kind: z26.string(),
   status: AgentTurnStatus,
   agent_profile_id: Id,
   project_agent_profile_id: Id.nullable(),
-  trigger_type: z25.string(),
-  runtime_mode: z25.string(),
-  backend_kind: z25.string().nullable(),
-  model: z25.string().nullable(),
-  thread_runtime_session_id: z25.string().nullable(),
-  thread_runtime_agent_session_id: z25.string().nullable(),
-  runtime_session_id: z25.string().nullable(),
-  external_session_id: z25.string().nullable(),
+  trigger_type: z26.string(),
+  runtime_mode: z26.string(),
+  backend_kind: z26.string().nullable(),
+  model: z26.string().nullable(),
+  thread_runtime_session_id: z26.string().nullable(),
+  thread_runtime_agent_session_id: z26.string().nullable(),
+  runtime_session_id: z26.string().nullable(),
+  external_session_id: z26.string().nullable(),
   external_session_failed_at: AgentTraceNullableDateTime,
   trigger_message_id: Id.nullable(),
   final_message_id: Id.nullable(),
@@ -4830,411 +4860,411 @@ var AgentTraceTurnIdentityDto = z25.object({
   created_at: AgentTraceDateTime,
   updated_at: AgentTraceDateTime
 });
-var AgentTurnTraceGetResult = z25.object({
+var AgentTurnTraceGetResult = z26.object({
   agent_turn_id: Id,
   channel_id: Id,
   turn: AgentTraceTurnIdentityDto,
-  observations: z25.array(AgentTraceObservationDto),
+  observations: z26.array(AgentTraceObservationDto),
   health: AgentTraceHealthSummaryDto,
-  next_seq: z25.number().int().nonnegative().nullable(),
+  next_seq: z26.number().int().nonnegative().nullable(),
   next_cursor: AgentTraceCursorDto.nullable(),
-  has_more: z25.boolean()
+  has_more: z26.boolean()
 });
-var AgentTraceScopeDto = z25.object({
-  type: z25.enum(["agent_turn", "channel", "task", "project"]),
+var AgentTraceScopeDto = z26.object({
+  type: z26.enum(["agent_turn", "channel", "task", "project"]),
   id: Id
 });
-var AgentTurnTraceStatsResult = z25.object({
+var AgentTurnTraceStatsResult = z26.object({
   scope: AgentTraceScopeDto,
-  turn_count: z25.number().int().nonnegative(),
-  observation_count: z25.number().int().nonnegative(),
-  session_identity: z25.object({
-    turn_count: z25.number().int().nonnegative(),
-    child_turn_count: z25.number().int().nonnegative(),
-    runtime_session_count: z25.number().int().nonnegative(),
-    external_session_count: z25.number().int().nonnegative()
+  turn_count: z26.number().int().nonnegative(),
+  observation_count: z26.number().int().nonnegative(),
+  session_identity: z26.object({
+    turn_count: z26.number().int().nonnegative(),
+    child_turn_count: z26.number().int().nonnegative(),
+    runtime_session_count: z26.number().int().nonnegative(),
+    external_session_count: z26.number().int().nonnegative()
   }),
-  by_kind: z25.array(AgentTraceCountBucketDto),
-  by_status: z25.array(AgentTraceCountBucketDto),
+  by_kind: z26.array(AgentTraceCountBucketDto),
+  by_status: z26.array(AgentTraceCountBucketDto),
   tool_health: AgentTraceToolHealthDto,
-  mcp_tools: z25.array(AgentTraceMcpToolStatsDto),
+  mcp_tools: z26.array(AgentTraceMcpToolStatsDto),
   usage: AgentTraceUsageSummaryDto,
   cost: AgentTraceCostSummaryDto,
-  capability_gaps: z25.array(AgentTraceCapabilityGapDto),
-  truncated: z25.boolean()
+  capability_gaps: z26.array(AgentTraceCapabilityGapDto),
+  truncated: z26.boolean()
 });
-var AgentTraceContextRuntimeDto = z25.object({
-  backend_kind: z25.string().nullable(),
+var AgentTraceContextRuntimeDto = z26.object({
+  backend_kind: z26.string().nullable(),
   adapter_mode: AgentObservationAdapterMode.nullable(),
-  model: z25.string().nullable(),
-  runtime_provider_kind: z25.string().nullable(),
-  runtime_session_id: z25.string().nullable(),
-  external_session_id: z25.string().nullable()
+  model: z26.string().nullable(),
+  runtime_provider_kind: z26.string().nullable(),
+  runtime_session_id: z26.string().nullable(),
+  external_session_id: z26.string().nullable()
 });
-var AgentTraceContextUnavailableDto = z25.object({
-  field: z25.string(),
-  reason: z25.string()
+var AgentTraceContextUnavailableDto = z26.object({
+  field: z26.string(),
+  reason: z26.string()
 });
-var AgentTurnTraceContextAtResult = z25.object({
+var AgentTurnTraceContextAtResult = z26.object({
   agent_turn_id: Id,
   channel_id: Id,
-  locator: z25.object({
-    seq: z25.number().int().positive().nullable(),
-    observation_key: z25.string().nullable()
+  locator: z26.object({
+    seq: z26.number().int().positive().nullable(),
+    observation_key: z26.string().nullable()
   }),
   context_snapshot: PromptContextSummary.nullable(),
   runtime: AgentTraceContextRuntimeDto,
-  adapter_capability: z25.object({
-    status: z25.enum(["available", "unavailable"]),
+  adapter_capability: z26.object({
+    status: z26.enum(["available", "unavailable"]),
     metadata: JsonObject.nullable(),
-    source_observation_key: z25.string().nullable()
+    source_observation_key: z26.string().nullable()
   }),
   observation: AgentTraceObservationDto.nullable(),
-  provenance: z25.object({
+  provenance: z26.object({
     agent_turn_id: Id,
-    seq: z25.number().int().positive().nullable(),
-    observation_key: z25.string().nullable()
+    seq: z26.number().int().positive().nullable(),
+    observation_key: z26.string().nullable()
   }),
-  unavailable: z25.array(AgentTraceContextUnavailableDto)
+  unavailable: z26.array(AgentTraceContextUnavailableDto)
 });
 var TraceLabIsoInstant = AgentTraceDateTime;
-var TraceLabRange = z25.object({
+var TraceLabRange = z26.object({
   from: TraceLabIsoInstant,
   to: TraceLabIsoInstant
 });
-var AgentTurnTraceOrgUserSummaryCursor = z25.object({
+var AgentTurnTraceOrgUserSummaryCursor = z26.object({
   last_active: TraceLabIsoInstant,
   user_id: Id
 });
-var AgentTurnTraceOrgUserSummaryInput = z25.object({
+var AgentTurnTraceOrgUserSummaryInput = z26.object({
   activity_window: TraceLabRange,
   today_window: TraceLabRange,
   week_window: TraceLabRange,
   cursor: AgentTurnTraceOrgUserSummaryCursor.nullable().optional(),
-  limit: z25.number().int().positive().max(200).optional()
+  limit: z26.number().int().positive().max(200).optional()
 });
-var AgentTurnTraceOrgUserSummaryRowDto = z25.object({
+var AgentTurnTraceOrgUserSummaryRowDto = z26.object({
   user_id: Id,
-  user_name: z25.string().nullable(),
-  user_email: z25.string().nullable(),
-  user_image: z25.string().nullable(),
-  channels_today: z25.number().int().nonnegative(),
-  channels_week: z25.number().int().nonnegative(),
-  channel_count: z25.number().int().nonnegative(),
-  cost_usd: z25.number().nullable(),
-  total_tokens: z25.number().nullable(),
+  user_name: z26.string().nullable(),
+  user_email: z26.string().nullable(),
+  user_image: z26.string().nullable(),
+  channels_today: z26.number().int().nonnegative(),
+  channels_week: z26.number().int().nonnegative(),
+  channel_count: z26.number().int().nonnegative(),
+  cost_usd: z26.number().nullable(),
+  total_tokens: z26.number().nullable(),
   last_active: TraceLabIsoInstant
 });
-var AgentTurnTraceOrgUserSummaryResult = z25.object({
-  users: z25.array(AgentTurnTraceOrgUserSummaryRowDto),
+var AgentTurnTraceOrgUserSummaryResult = z26.object({
+  users: z26.array(AgentTurnTraceOrgUserSummaryRowDto),
   next_cursor: AgentTurnTraceOrgUserSummaryCursor.nullable(),
-  has_more: z25.boolean()
+  has_more: z26.boolean()
 });
-var AgentTurnTraceUserProjectsInput = z25.object({
+var AgentTurnTraceUserProjectsInput = z26.object({
   user_id: Id,
   activity_window: TraceLabRange
 });
-var AgentTurnTraceUserChannelRowDto = z25.object({
+var AgentTurnTraceUserChannelRowDto = z26.object({
   channel_id: Id,
   project_id: Id.nullable(),
   linked_task_id: Id.nullable(),
-  linked_task_title: z25.string().nullable(),
-  title: z25.string(),
-  turn_count: z25.number().int().nonnegative(),
-  cost_usd: z25.number().nullable(),
-  total_tokens: z25.number().nullable(),
-  status: z25.string(),
+  linked_task_title: z26.string().nullable(),
+  title: z26.string(),
+  turn_count: z26.number().int().nonnegative(),
+  cost_usd: z26.number().nullable(),
+  total_tokens: z26.number().nullable(),
+  status: z26.string(),
   first_queued_at: TraceLabIsoInstant,
   last_active: TraceLabIsoInstant
 });
-var AgentTurnTraceUserProjectGroupDto = z25.object({
+var AgentTurnTraceUserProjectGroupDto = z26.object({
   project_id: Id.nullable(),
-  project_name: z25.string(),
-  channel_count: z25.number().int().nonnegative(),
-  cost_usd: z25.number().nullable(),
-  channels: z25.array(AgentTurnTraceUserChannelRowDto)
+  project_name: z26.string(),
+  channel_count: z26.number().int().nonnegative(),
+  cost_usd: z26.number().nullable(),
+  channels: z26.array(AgentTurnTraceUserChannelRowDto)
 });
-var AgentTurnTraceUserProjectsResult = z25.object({
+var AgentTurnTraceUserProjectsResult = z26.object({
   user_id: Id,
-  projects: z25.array(AgentTurnTraceUserProjectGroupDto),
-  channel_count: z25.number().int().nonnegative(),
-  cost_usd: z25.number().nullable()
+  projects: z26.array(AgentTurnTraceUserProjectGroupDto),
+  channel_count: z26.number().int().nonnegative(),
+  cost_usd: z26.number().nullable()
 });
-var AgentTurnTraceChannelTurnsInput = z25.object({
+var AgentTurnTraceChannelTurnsInput = z26.object({
   channel_id: Id
 });
-var AgentTurnTraceChannelTurnRowDto = z25.object({
+var AgentTurnTraceChannelTurnRowDto = z26.object({
   agent_turn_id: Id,
   channel_id: Id,
   agent_profile_id: Id,
-  agent_key: z25.string().nullable(),
+  agent_key: z26.string().nullable(),
   project_agent_profile_id: Id.nullable(),
-  project_agent_key: z25.string().nullable(),
-  backend_kind: z25.string().nullable(),
-  model: z25.string().nullable(),
+  project_agent_key: z26.string().nullable(),
+  backend_kind: z26.string().nullable(),
+  model: z26.string().nullable(),
   trigger_message_id: Id.nullable(),
-  trigger_message_channel_seq: z25.number().int().positive().nullable(),
-  trigger_message_body_md: z25.string().nullable(),
+  trigger_message_channel_seq: z26.number().int().positive().nullable(),
+  trigger_message_body_md: z26.string().nullable(),
   trigger_message_created_at: AgentTraceNullableDateTime,
   final_message_id: Id.nullable(),
-  final_message_channel_seq: z25.number().int().positive().nullable(),
-  final_message_body_md: z25.string().nullable(),
+  final_message_channel_seq: z26.number().int().positive().nullable(),
+  final_message_body_md: z26.string().nullable(),
   final_message_created_at: AgentTraceNullableDateTime,
   status: AgentTurnStatus,
   queued_at: TraceLabIsoInstant,
   started_at: AgentTraceNullableDateTime,
   completed_at: AgentTraceNullableDateTime,
-  duration_ms: z25.number().int().nonnegative().nullable(),
-  cost_usd: z25.number().nullable(),
-  tools_ok: z25.number().int().nonnegative(),
-  tools_failed: z25.number().int().nonnegative(),
-  capability_gaps: z25.number().int().nonnegative(),
+  duration_ms: z26.number().int().nonnegative().nullable(),
+  cost_usd: z26.number().nullable(),
+  tools_ok: z26.number().int().nonnegative(),
+  tools_failed: z26.number().int().nonnegative(),
+  capability_gaps: z26.number().int().nonnegative(),
   context_snapshot: PromptContextSummary.nullable()
 });
-var AgentTurnTraceChannelTurnsResult = z25.object({
+var AgentTurnTraceChannelTurnsResult = z26.object({
   channel_id: Id,
   project_id: Id.nullable(),
-  project_name: z25.string().nullable(),
-  channel_title: z25.string(),
+  project_name: z26.string().nullable(),
+  channel_title: z26.string(),
   linked_task_id: Id.nullable(),
-  linked_task_title: z25.string().nullable(),
+  linked_task_title: z26.string().nullable(),
   owner_user_id: Id.nullable(),
-  turns: z25.array(AgentTurnTraceChannelTurnRowDto)
+  turns: z26.array(AgentTurnTraceChannelTurnRowDto)
 });
 // ../../packages/protocol/src/agent-prompt-profile.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var agentPromptProfileFields = {
-  basePersonaMd: z26.string().optional(),
-  systemPromptPath: z26.string().optional(),
-  appendSystemPrompt: z26.string().optional(),
-  defaultCardVersion: z26.number().int().positive().optional()
+  basePersonaMd: z27.string().optional(),
+  systemPromptPath: z27.string().optional(),
+  appendSystemPrompt: z27.string().optional(),
+  defaultCardVersion: z27.number().int().positive().optional()
 };
-var AgentPromptProfileServerStrict = z26.object(agentPromptProfileFields).strict();
-var AgentPromptProfileClientReadCompat = z26.object(agentPromptProfileFields).passthrough();
+var AgentPromptProfileServerStrict = z27.object(agentPromptProfileFields).strict();
+var AgentPromptProfileClientReadCompat = z27.object(agentPromptProfileFields).passthrough();
 // ../../packages/protocol/src/api.ts
-import { z as z27 } from "zod";
-var ApiErrorDto = z27.object({
+import { z as z28 } from "zod";
+var ApiErrorDto = z28.object({
   code: ErrorCode,
-  message: z27.string()
+  message: z28.string()
 });
-var ApiFailureDto = z27.object({
-  ok: z27.literal(false),
+var ApiFailureDto = z28.object({
+  ok: z28.literal(false),
   error: ApiErrorDto,
-  request_id: z27.string()
+  request_id: z28.string()
 });
 // ../../packages/protocol/src/channel.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var CHANNEL_TYPES = ["dm", "chat", "forum"];
-var ChannelType = z28.enum(CHANNEL_TYPES);
+var ChannelType = z29.enum(CHANNEL_TYPES);
 var CHANNEL_VISIBILITIES = [
   "private",
   "project",
   "organization"
 ];
-var ChannelVisibility = z28.enum(CHANNEL_VISIBILITIES);
+var ChannelVisibility = z29.enum(CHANNEL_VISIBILITIES);
 var CHANNEL_TAG_SCOPES = [
   "organization",
   "project",
   "private"
 ];
-var ChannelTagScope = z28.enum(CHANNEL_TAG_SCOPES);
+var ChannelTagScope = z29.enum(CHANNEL_TAG_SCOPES);
 var CHANNEL_MEMBER_ROLES = [
   "owner",
   "admin",
   "member",
   "guest"
 ];
-var ChannelMemberRole = z28.enum(CHANNEL_MEMBER_ROLES);
+var ChannelMemberRole = z29.enum(CHANNEL_MEMBER_ROLES);
 var CHANNEL_MEMBER_STATUSES = [
   "active",
   "muted",
   "left",
   "removed"
 ];
-var ChannelMemberStatus = z28.enum(CHANNEL_MEMBER_STATUSES);
+var ChannelMemberStatus = z29.enum(CHANNEL_MEMBER_STATUSES);
 var THREAD_STATUSES = ["open", "locked", "archived"];
-var ThreadStatus = z28.enum(THREAD_STATUSES);
+var ThreadStatus = z29.enum(THREAD_STATUSES);
 var MESSAGE_SENDER_KINDS = ["user", "agent", "system"];
-var MessageSenderKind = z28.enum(MESSAGE_SENDER_KINDS);
+var MessageSenderKind = z29.enum(MESSAGE_SENDER_KINDS);
 var MESSAGE_CONTENT_KINDS = [
   "text",
   "rich",
   "system",
   "forward_bundle"
 ];
-var MessageContentKind = z28.enum(MESSAGE_CONTENT_KINDS);
+var MessageContentKind = z29.enum(MESSAGE_CONTENT_KINDS);
 var MESSAGE_DELETE_KINDS = [
   "author_recall",
   "moderator_delete",
   "agent_output_recall"
 ];
-var MessageDeleteKind = z28.enum(MESSAGE_DELETE_KINDS);
+var MessageDeleteKind = z29.enum(MESSAGE_DELETE_KINDS);
 var MESSAGE_MUTATION_KINDS = [
   "edit",
   "author_recall",
   "moderator_delete",
   "agent_output_recall"
 ];
-var MessageMutationKind = z28.enum(MESSAGE_MUTATION_KINDS);
+var MessageMutationKind = z29.enum(MESSAGE_MUTATION_KINDS);
 var MESSAGE_MENTION_KINDS = ["user", "agent"];
-var MessageMentionKind = z28.enum(MESSAGE_MENTION_KINDS);
+var MessageMentionKind = z29.enum(MESSAGE_MENTION_KINDS);
 var THREAD_PARTICIPANT_KINDS = ["user", "agent"];
-var ThreadParticipantKind = z28.enum(THREAD_PARTICIPANT_KINDS);
+var ThreadParticipantKind = z29.enum(THREAD_PARTICIPANT_KINDS);
 var THREAD_SUBSCRIPTION_STATUSES = [
   "following",
   "muted",
   "none"
 ];
-var ThreadSubscriptionStatus = z28.enum(THREAD_SUBSCRIPTION_STATUSES);
+var ThreadSubscriptionStatus = z29.enum(THREAD_SUBSCRIPTION_STATUSES);
 var FORWARD_BUNDLE_ITEM_CONTENT_KINDS = [
   "text",
   "rich",
   "system"
 ];
-var ForwardBundleItemContentKind = z28.enum(FORWARD_BUNDLE_ITEM_CONTENT_KINDS);
+var ForwardBundleItemContentKind = z29.enum(FORWARD_BUNDLE_ITEM_CONTENT_KINDS);
 var forwardBundleSenderFields = {
   kind: MessageSenderKind,
-  userId: z28.string().nullable().optional(),
-  agentProfileId: z28.string().nullable().optional(),
-  projectAgentProfileId: z28.string().nullable().optional(),
-  displayName: z28.string(),
-  avatarUrl: z28.string().nullable().optional()
+  userId: z29.string().nullable().optional(),
+  agentProfileId: z29.string().nullable().optional(),
+  projectAgentProfileId: z29.string().nullable().optional(),
+  displayName: z29.string(),
+  avatarUrl: z29.string().nullable().optional()
 };
-var ForwardBundleSenderServerStrict = z28.object(forwardBundleSenderFields).strict();
-var ForwardBundleSenderClientReadCompat = z28.object(forwardBundleSenderFields).passthrough();
+var ForwardBundleSenderServerStrict = z29.object(forwardBundleSenderFields).strict();
+var ForwardBundleSenderClientReadCompat = z29.object(forwardBundleSenderFields).passthrough();
 var forwardBundleAttachmentFields = {
-  objectKey: z28.string(),
-  publicUrl: z28.string(),
-  filename: z28.string(),
-  contentType: z28.string().nullable().optional(),
-  byteSize: z28.number().int().nullable().optional(),
-  width: z28.number().int().nullable().optional(),
-  height: z28.number().int().nullable().optional(),
-  attachmentKind: z28.string().nullable().optional()
+  objectKey: z29.string(),
+  publicUrl: z29.string(),
+  filename: z29.string(),
+  contentType: z29.string().nullable().optional(),
+  byteSize: z29.number().int().nullable().optional(),
+  width: z29.number().int().nullable().optional(),
+  height: z29.number().int().nullable().optional(),
+  attachmentKind: z29.string().nullable().optional()
 };
-var ForwardBundleAttachmentServerStrict = z28.object(forwardBundleAttachmentFields).strict();
-var ForwardBundleAttachmentClientReadCompat = z28.object(forwardBundleAttachmentFields).passthrough();
-var ForwardBundleItemServerStrict = z28.object({
-  sourceMessageId: z28.string(),
-  sourceChannelId: z28.string(),
-  sourceThreadId: z28.string().nullable().optional(),
+var ForwardBundleAttachmentServerStrict = z29.object(forwardBundleAttachmentFields).strict();
+var ForwardBundleAttachmentClientReadCompat = z29.object(forwardBundleAttachmentFields).passthrough();
+var ForwardBundleItemServerStrict = z29.object({
+  sourceMessageId: z29.string(),
+  sourceChannelId: z29.string(),
+  sourceThreadId: z29.string().nullable().optional(),
   sender: ForwardBundleSenderServerStrict,
-  bodyMd: z28.string(),
+  bodyMd: z29.string(),
   contentKind: ForwardBundleItemContentKind,
-  createdAt: z28.string(),
-  attachments: z28.array(ForwardBundleAttachmentServerStrict)
+  createdAt: z29.string(),
+  attachments: z29.array(ForwardBundleAttachmentServerStrict)
 }).strict();
-var ForwardBundleItemClientReadCompat = z28.object({
-  sourceMessageId: z28.string(),
-  sourceChannelId: z28.string(),
-  sourceThreadId: z28.string().nullable().optional(),
+var ForwardBundleItemClientReadCompat = z29.object({
+  sourceMessageId: z29.string(),
+  sourceChannelId: z29.string(),
+  sourceThreadId: z29.string().nullable().optional(),
   sender: ForwardBundleSenderClientReadCompat,
-  bodyMd: z28.string(),
+  bodyMd: z29.string(),
   contentKind: ForwardBundleItemContentKind,
-  createdAt: z28.string(),
-  attachments: z28.array(ForwardBundleAttachmentClientReadCompat)
+  createdAt: z29.string(),
+  attachments: z29.array(ForwardBundleAttachmentClientReadCompat)
 }).passthrough();
-var ForwardBundleContentServerStrict = z28.object({
-  v: z28.literal(1),
-  sourceChannelId: z28.string(),
-  items: z28.array(ForwardBundleItemServerStrict).min(1)
+var ForwardBundleContentServerStrict = z29.object({
+  v: z29.literal(1),
+  sourceChannelId: z29.string(),
+  items: z29.array(ForwardBundleItemServerStrict).min(1)
 }).strict();
-var ForwardBundleContentClientReadCompat = z28.object({
-  v: z28.literal(1),
-  sourceChannelId: z28.string(),
-  items: z28.array(ForwardBundleItemClientReadCompat).min(1)
+var ForwardBundleContentClientReadCompat = z29.object({
+  v: z29.literal(1),
+  sourceChannelId: z29.string(),
+  items: z29.array(ForwardBundleItemClientReadCompat).min(1)
 }).passthrough();
 // ../../packages/protocol/src/channel-message-preview.ts
 var PREVIEW_SEGMENTER = new Intl.Segmenter("zh", { granularity: "grapheme" });
 // ../../packages/protocol/src/channel-worker-pump.ts
-import { z as z29 } from "zod";
-var ChannelWorkerSkillFile = z29.object({
-  path: z29.string().min(1),
-  content: z29.string()
+import { z as z30 } from "zod";
+var ChannelWorkerSkillFile = z30.object({
+  path: z30.string().min(1),
+  content: z30.string()
 }).strict();
-var ChannelWorkerSkillBundle = z29.object({
+var ChannelWorkerSkillBundle = z30.object({
   id: Id,
-  slug: z29.string().min(1),
-  name: z29.string().min(1),
-  description: z29.string(),
-  contentMd: z29.string().min(1),
-  files: z29.array(ChannelWorkerSkillFile).default([]),
-  version: z29.number().int().positive().default(1)
+  slug: z30.string().min(1),
+  name: z30.string().min(1),
+  description: z30.string(),
+  contentMd: z30.string().min(1),
+  files: z30.array(ChannelWorkerSkillFile).default([]),
+  version: z30.number().int().positive().default(1)
 }).strict();
-var ChannelWorkerPumpRunOptions = z29.object({
-  model: z29.string().nullish(),
-  toolsAllowlist: z29.array(z29.string()),
-  customEnv: z29.record(z29.string(), z29.string()),
-  customArgs: z29.array(z29.string()),
-  sandboxMode: z29.enum(["default", "auto-allow", "deny-all"]).optional(),
-  timeoutMs: z29.number().int().nullable(),
-  priorSessionId: z29.string().nullish()
+var ChannelWorkerPumpRunOptions = z30.object({
+  model: z30.string().nullish(),
+  toolsAllowlist: z30.array(z30.string()),
+  customEnv: z30.record(z30.string(), z30.string()),
+  customArgs: z30.array(z30.string()),
+  sandboxMode: z30.enum(["default", "auto-allow", "deny-all"]).optional(),
+  timeoutMs: z30.number().int().nullable(),
+  priorSessionId: z30.string().nullish()
 }).strict();
-var ChannelContext = z29.object({
+var ChannelContext = z30.object({
   channelId: Id,
-  trellisChannelName: z29.string().min(1),
-  channelType: z29.enum(["chat", "forum"]),
-  trellisScope: z29.enum(["project", "global"]),
-  trellisProjectKey: z29.string().min(1).optional(),
+  trellisChannelName: z30.string().min(1),
+  channelType: z30.enum(["chat", "forum"]),
+  trellisScope: z30.enum(["project", "global"]),
+  trellisProjectKey: z30.string().min(1).optional(),
   daemonWorkspaceId: Id.optional()
 }).strict();
-var TaskContext = z29.object({
+var TaskContext = z30.object({
   taskId: Id,
-  trellisId: z29.string().min(1),
+  trellisId: z30.string().min(1),
   projectId: Id
 }).strict();
-var RunTrigger = z29.object({
+var RunTrigger = z30.object({
   channelId: Id,
-  eventSeq: z29.number().int().nonnegative()
+  eventSeq: z30.number().int().nonnegative()
 }).strict();
-var RunContext = z29.object({
-  turnKind: z29.enum(["task_turn", "channel_turn"]),
+var RunContext = z30.object({
+  turnKind: z30.enum(["task_turn", "channel_turn"]),
   taskContext: TaskContext.optional(),
   trigger: RunTrigger.optional(),
   runtimeMode: AgentTurnRuntimeMode,
   triggerType: AgentTurnTriggerType,
   parentAgentTurnId: Id.optional()
 }).strict();
-var AgentContext = z29.object({
+var AgentContext = z30.object({
   agentProfileId: Id,
   projectAgentProfileId: Id.nullable().optional(),
   backendKind: BackendKind,
-  model: z29.string().nullable().optional()
+  model: z30.string().nullable().optional()
 }).strict();
-var UniversalChannelWorkerRunInput = z29.object({
+var UniversalChannelWorkerRunInput = z30.object({
   agentTurnId: Id,
   workerId: Id,
   organizationId: Id,
   channelContext: ChannelContext,
   runContext: RunContext,
   agentContext: AgentContext,
-  promptMd: z29.string(),
-  skills: z29.array(ChannelWorkerSkillBundle).default([]),
+  promptMd: z30.string(),
+  skills: z30.array(ChannelWorkerSkillBundle).default([]),
   options: ChannelWorkerPumpRunOptions
 }).strict().superRefine((input, ctx) => {
   if (input.runContext.turnKind === "task_turn" && input.runContext.taskContext === undefined) {
     ctx.addIssue({
-      code: z29.ZodIssueCode.custom,
+      code: z30.ZodIssueCode.custom,
       message: "task_turn requires runContext.taskContext",
       path: ["runContext", "taskContext"]
     });
   }
   if (input.channelContext.trellisScope === "project" && input.channelContext.trellisProjectKey === undefined) {
     ctx.addIssue({
-      code: z29.ZodIssueCode.custom,
+      code: z30.ZodIssueCode.custom,
       message: "channelContext.trellisScope='project' requires trellisProjectKey",
       path: ["channelContext", "trellisProjectKey"]
     });
   }
 });
 // ../../packages/protocol/src/feedback.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 
 // ../../packages/protocol/src/rest/organizations.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // ../../packages/protocol/src/onboarding-state.ts
-import { z as z30 } from "zod";
+import { z as z31 } from "zod";
 var LIVE_ONBOARDING_COMPLETION_PATHS = [
   "full",
   "runtime_skipped",
@@ -5251,33 +5281,33 @@ var ONBOARDING_CHECKLIST_ITEMS = [
   "git_auth"
 ];
 var userOnboardingStateFields = {
-  invite_step_skipped: z30.boolean().optional(),
-  profile_complete: z30.boolean().optional(),
-  profile_skipped: z30.boolean().optional(),
-  runtime_skipped: z30.boolean().optional(),
-  agent_key_skipped: z30.boolean().optional(),
-  completion_path: z30.enum(ONBOARDING_COMPLETION_PATHS).optional(),
-  dismissed_checklist_items: z30.array(z30.enum(ONBOARDING_CHECKLIST_ITEMS)).optional(),
-  tour_seen_at: z30.string().optional(),
-  last_step_key: z30.string().optional(),
-  dismissed_hints: z30.array(z30.string()).optional(),
-  next_step_hint: z30.string().optional()
+  invite_step_skipped: z31.boolean().optional(),
+  profile_complete: z31.boolean().optional(),
+  profile_skipped: z31.boolean().optional(),
+  runtime_skipped: z31.boolean().optional(),
+  agent_key_skipped: z31.boolean().optional(),
+  completion_path: z31.enum(ONBOARDING_COMPLETION_PATHS).optional(),
+  dismissed_checklist_items: z31.array(z31.enum(ONBOARDING_CHECKLIST_ITEMS)).optional(),
+  tour_seen_at: z31.string().optional(),
+  last_step_key: z31.string().optional(),
+  dismissed_hints: z31.array(z31.string()).optional(),
+  next_step_hint: z31.string().optional()
 };
-var UserOnboardingStateServerStrict = z30.object(userOnboardingStateFields).strict();
-var UserOnboardingStateClientReadCompat = z30.object(userOnboardingStateFields).passthrough();
+var UserOnboardingStateServerStrict = z31.object(userOnboardingStateFields).strict();
+var UserOnboardingStateClientReadCompat = z31.object(userOnboardingStateFields).passthrough();
 var UserOnboardingLivePatchInput = UserOnboardingStateServerStrict.omit({
   completion_path: true
 }).partial();
 var organizationOnboardingStateFields = {
-  completed_steps: z30.array(z30.string()).optional(),
-  skipped_steps: z30.array(z30.string()).optional(),
-  last_active_step: z30.string().optional()
+  completed_steps: z31.array(z31.string()).optional(),
+  skipped_steps: z31.array(z31.string()).optional(),
+  last_active_step: z31.string().optional()
 };
-var OrganizationOnboardingStateServerStrict = z30.object(organizationOnboardingStateFields).strict();
-var OrganizationOnboardingStateClientReadCompat = z30.object(organizationOnboardingStateFields).passthrough();
+var OrganizationOnboardingStateServerStrict = z31.object(organizationOnboardingStateFields).strict();
+var OrganizationOnboardingStateClientReadCompat = z31.object(organizationOnboardingStateFields).passthrough();
 
 // ../../packages/protocol/src/permissions.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 var PERMISSION_DEFINITIONS = [
   {
     key: "org.read",
@@ -5422,20 +5452,20 @@ var PERMISSION_DEFINITIONS = [
 ];
 var PERMISSION_KEYS = PERMISSION_DEFINITIONS.map((definition) => definition.key);
 var PERMISSION_DEFINITIONS_BY_KEY = Object.fromEntries(PERMISSION_DEFINITIONS.map((definition) => [definition.key, definition]));
-var PermissionKey = z31.enum(PERMISSION_KEYS);
+var PermissionKey = z32.enum(PERMISSION_KEYS);
 var SYSTEM_ORGANIZATION_ROLE_KEYS = [
   "owner",
   "admin",
   "member",
   "viewer"
 ];
-var SystemOrganizationRoleKey = z31.enum(SYSTEM_ORGANIZATION_ROLE_KEYS);
+var SystemOrganizationRoleKey = z32.enum(SYSTEM_ORGANIZATION_ROLE_KEYS);
 var ORGANIZATION_INVITE_ROLE_KEYS = [
   "admin",
   "member",
   "viewer"
 ];
-var OrganizationInviteRoleKey = z31.enum(ORGANIZATION_INVITE_ROLE_KEYS);
+var OrganizationInviteRoleKey = z32.enum(ORGANIZATION_INVITE_ROLE_KEYS);
 var DEFAULT_ORGANIZATION_ROLE_PERMISSION_KEYS = {
   owner: PERMISSION_KEYS,
   admin: PERMISSION_KEYS,
@@ -5509,137 +5539,137 @@ var SYSTEM_ORGANIZATION_ROLE_DEFINITIONS_BY_KEY = {
 };
 
 // ../../packages/protocol/src/rest/organizations.ts
-var UserIdentityDto = z32.object({
+var UserIdentityDto = z33.object({
   id: Id,
-  name: z32.string(),
-  email: z32.string(),
-  image: z32.string().nullable()
+  name: z33.string(),
+  email: z33.string(),
+  image: z33.string().nullable()
 });
 var CurrentUserDto = UserIdentityDto.extend({
-  first_run_exited_at: z32.string().nullable(),
+  first_run_exited_at: z33.string().nullable(),
   onboarding_state: UserOnboardingStateClientReadCompat,
-  system_role: z32.string().nullable()
+  system_role: z33.string().nullable()
 });
-var MeDto = z32.object({
+var MeDto = z33.object({
   user: CurrentUserDto,
   active_organization_id: Id.nullable()
 });
-var OrganizationMemberDto = z32.object({
+var OrganizationMemberDto = z33.object({
   id: Id,
   organization_id: Id,
   user_id: Id,
-  role: z32.string(),
-  joined_at: z32.string(),
+  role: z33.string(),
+  joined_at: z33.string(),
   user: UserIdentityDto
 });
-var OrganizationMembersListInput = z32.object({}).strict();
-var OrganizationMembersPageInput = z32.object({
-  limit: z32.number().int().positive().max(100).default(50),
-  cursor_created_at: z32.string().datetime().optional(),
+var OrganizationMembersListInput = z33.object({}).strict();
+var OrganizationMembersPageInput = z33.object({
+  limit: z33.number().int().positive().max(100).default(50),
+  cursor_created_at: z33.string().datetime().optional(),
   cursor_id: Id.optional()
 });
-var OrganizationMembersPageResultDto = z32.object({
-  members: z32.array(OrganizationMemberDto),
-  current_member_role: z32.string(),
-  total_count: z32.number().int().nonnegative(),
-  next_cursor: z32.object({
-    created_at: z32.string(),
+var OrganizationMembersPageResultDto = z33.object({
+  members: z33.array(OrganizationMemberDto),
+  current_member_role: z33.string(),
+  total_count: z33.number().int().nonnegative(),
+  next_cursor: z33.object({
+    created_at: z33.string(),
     id: Id
   }).nullable()
 });
-var OrganizationMemberRoleUpdateInput = z32.object({
+var OrganizationMemberRoleUpdateInput = z33.object({
   member_id: Id,
   role: OrganizationInviteRoleKey
 }).strict();
-var OrganizationMemberRemoveInput = z32.object({
+var OrganizationMemberRemoveInput = z33.object({
   member_id: Id
 }).strict();
-var MediaImageContentType = z32.enum([
+var MediaImageContentType = z33.enum([
   "image/png",
   "image/jpeg",
   "image/webp"
 ]);
-var MediaAvatarUploadCreateInput = z32.object({
+var MediaAvatarUploadCreateInput = z33.object({
   content_type: MediaImageContentType,
-  byte_size: z32.number().int().positive().max(10 * 1024 * 1024)
+  byte_size: z33.number().int().positive().max(10 * 1024 * 1024)
 }).strict();
-var MediaUploadCreateDto = z32.object({
-  upload_url: z32.string().url(),
-  object_key: z32.string().min(1),
-  public_url: z32.string().url(),
-  headers: z32.record(z32.string(), z32.string()),
-  expires_at: z32.string()
-});
-var MediaAvatarUploadCommitInput = z32.object({
-  object_key: z32.string().min(1),
-  public_url: z32.string().url()
+var MediaUploadCreateDto = z33.object({
+  upload_url: z33.string().url(),
+  object_key: z33.string().min(1),
+  public_url: z33.string().url(),
+  headers: z33.record(z33.string(), z33.string()),
+  expires_at: z33.string()
+});
+var MediaAvatarUploadCommitInput = z33.object({
+  object_key: z33.string().min(1),
+  public_url: z33.string().url()
 }).strict();
-var OrgAgentProfileDto = z32.object({
+var OrgAgentProfileDto = z33.object({
   id: Id,
   organization_id: Id,
-  key: z32.string(),
-  description: z32.string().nullable(),
+  key: z33.string(),
+  description: z33.string().nullable(),
   agent_type: AgentProfileType,
   profile_kind: AgentProfileKind,
   backend_kind: BackendKind.nullable(),
-  default_model: z32.string().nullable(),
-  avatar_url: z32.string().nullable(),
+  default_model: z33.string().nullable(),
+  avatar_url: z33.string().nullable(),
   prompt_profile: JsonObject,
   settings: AgentProfileSettingsDto,
-  archived_at: z32.string().nullable(),
-  created_at: z32.string(),
-  updated_at: z32.string()
+  archived_at: z33.string().nullable(),
+  created_at: z33.string(),
+  updated_at: z33.string()
 });
-var OrgAgentProfileListInput = z32.object({
-  include_archived: z32.boolean().default(false),
+var OrgAgentProfileListInput = z33.object({
+  include_archived: z33.boolean().default(false),
   profile_kind: AgentProfileKind.optional()
 });
-var OnboardingUserDto = z32.object({
+var OnboardingUserDto = z33.object({
   id: Id,
-  email: z32.string().email(),
-  name: z32.string(),
-  image: z32.string().nullable(),
-  locale: z32.string().nullable(),
-  timezone: z32.string().nullable(),
-  first_run_exited_at: z32.string().nullable(),
+  email: z33.string().email(),
+  name: z33.string(),
+  image: z33.string().nullable(),
+  locale: z33.string().nullable(),
+  timezone: z33.string().nullable(),
+  first_run_exited_at: z33.string().nullable(),
   onboarding_state: UserOnboardingStateClientReadCompat,
   preferences: JsonObject,
-  settings_version: z32.number().int().positive()
+  settings_version: z33.number().int().positive()
 });
-var OnboardingOrganizationDto = z32.object({
+var OnboardingOrganizationDto = z33.object({
   id: Id,
-  name: z32.string(),
-  slug: z32.string(),
-  logo: z32.string().nullable()
+  name: z33.string(),
+  slug: z33.string(),
+  logo: z33.string().nullable()
 });
-var OnboardingInvitationDto = z32.object({
+var OnboardingInvitationDto = z33.object({
   id: Id,
   organization_id: Id,
-  email: z32.string().email(),
+  email: z33.string().email(),
   role: OrganizationInviteRoleKey.nullable(),
-  status: z32.string(),
-  expires_at: z32.string(),
-  created_at: z32.string(),
+  status: z33.string(),
+  expires_at: z33.string(),
+  created_at: z33.string(),
   inviter_id: Id.nullable(),
-  inviter_name: z32.string().nullable(),
-  inviter_email: z32.string().email().nullable(),
-  inviter_image: z32.string().nullable(),
-  organization_name: z32.string().nullable(),
-  organization_slug: z32.string().nullable(),
-  organization_logo: z32.string().nullable()
-});
-var OnboardingActionStateDto = z32.object({
-  can_create_organization: z32.boolean(),
-  can_join_organization: z32.boolean(),
-  invite_step_skipped: z32.boolean(),
-  org_has_any_active_project: z32.boolean(),
-  project_step_skipped: z32.boolean()
-});
-var OnboardingStateDto = z32.object({
+  inviter_name: z33.string().nullable(),
+  inviter_email: z33.string().email().nullable(),
+  inviter_image: z33.string().nullable(),
+  organization_name: z33.string().nullable(),
+  organization_slug: z33.string().nullable(),
+  organization_logo: z33.string().nullable()
+});
+var OnboardingActionStateDto = z33.object({
+  can_create_organization: z33.boolean(),
+  can_join_organization: z33.boolean(),
+  invite_step_skipped: z33.boolean(),
+  org_has_any_active_project: z33.boolean(),
+  project_step_skipped: z33.boolean()
+});
+var OnboardingStateDto = z33.object({
   user: OnboardingUserDto,
   active_organization: OnboardingOrganizationDto.nullable(),
-  organizations: z32.array(OnboardingOrganizationDto),
-  pending_invitations: z32.array(OnboardingInvitationDto).default([]),
+  organizations: z33.array(OnboardingOrganizationDto),
+  pending_invitations: z33.array(OnboardingInvitationDto).default([]),
   onboarding_state: OnboardingActionStateDto.default({
     can_create_organization: true,
     can_join_organization: true,
@@ -5648,118 +5678,118 @@ var OnboardingStateDto = z32.object({
     project_step_skipped: false
   })
 });
-var OnboardingCompleteInput = z32.object({
-  user: z32.object({
-    name: z32.string().trim().min(1).max(120).optional(),
-    image: z32.string().url().nullable().optional(),
-    locale: z32.string().trim().min(1).max(35).nullable().optional(),
-    timezone: z32.string().trim().min(1).max(64).nullable().optional(),
+var OnboardingCompleteInput = z33.object({
+  user: z33.object({
+    name: z33.string().trim().min(1).max(120).optional(),
+    image: z33.string().url().nullable().optional(),
+    locale: z33.string().trim().min(1).max(35).nullable().optional(),
+    timezone: z33.string().trim().min(1).max(64).nullable().optional(),
     onboarding_state: UserOnboardingLivePatchInput.optional()
   }).default({}),
-  organization: z32.object({
+  organization: z33.object({
     id: Id.optional(),
-    name: z32.string().trim().min(1).max(120).optional(),
-    slug: z32.string().trim().min(1).max(80).optional(),
-    logo: z32.string().url().nullable().optional()
+    name: z33.string().trim().min(1).max(120).optional(),
+    slug: z33.string().trim().min(1).max(80).optional(),
+    logo: z33.string().url().nullable().optional()
   }).optional()
 }).default({ user: {} });
-var UserOnboardingCompleteInput = z32.object({
-  completion_path: z32.enum(LIVE_ONBOARDING_COMPLETION_PATHS),
+var UserOnboardingCompleteInput = z33.object({
+  completion_path: z33.enum(LIVE_ONBOARDING_COMPLETION_PATHS),
   skips: UserOnboardingLivePatchInput.optional()
 }).strict();
-var OrganizationOnboardingInviteStepInput = z32.object({
-  skipped: z32.boolean().default(true)
+var OrganizationOnboardingInviteStepInput = z33.object({
+  skipped: z33.boolean().default(true)
 }).default({ skipped: true });
-var OrganizationOnboardingProjectStepInput = z32.object({
-  skipped: z32.boolean().default(true)
+var OrganizationOnboardingProjectStepInput = z33.object({
+  skipped: z33.boolean().default(true)
 }).default({ skipped: true });
-var OrganizationActiveSessionInput = z32.object({
+var OrganizationActiveSessionInput = z33.object({
   organization_id: Id.nullable()
 });
-var OrganizationInviteLinkStatus = z32.enum([
+var OrganizationInviteLinkStatus = z33.enum([
   "active",
   "revoked",
   "expired",
   "exhausted"
 ]);
-var NormalizedDomainInput = z32.string().trim().min(1).max(253).transform((value) => value.toLowerCase());
-var OrganizationInviteLinkDto = z32.object({
+var NormalizedDomainInput = z33.string().trim().min(1).max(253).transform((value) => value.toLowerCase());
+var OrganizationInviteLinkDto = z33.object({
   id: Id,
   organization_id: Id,
-  display_code_prefix: z32.string().min(1),
+  display_code_prefix: z33.string().min(1),
   default_role: OrganizationInviteRoleKey,
-  expires_at: z32.string().nullable(),
-  max_uses: z32.number().int().positive().nullable(),
-  used_count: z32.number().int().nonnegative(),
-  allowed_email_domain: z32.string().nullable(),
+  expires_at: z33.string().nullable(),
+  max_uses: z33.number().int().positive().nullable(),
+  used_count: z33.number().int().nonnegative(),
+  allowed_email_domain: z33.string().nullable(),
   status: OrganizationInviteLinkStatus,
   created_by_user_id: Id.nullable(),
-  revoked_at: z32.string().nullable(),
+  revoked_at: z33.string().nullable(),
   revoked_by_user_id: Id.nullable(),
-  version: z32.number().int().positive(),
-  created_at: z32.string(),
-  updated_at: z32.string()
+  version: z33.number().int().positive(),
+  created_at: z33.string(),
+  updated_at: z33.string()
 });
-var OrganizationInviteLinkCreateInput = z32.object({
+var OrganizationInviteLinkCreateInput = z33.object({
   default_role: OrganizationInviteRoleKey.default("member"),
-  expires_at: z32.string().datetime().nullable().optional(),
-  max_uses: z32.number().int().positive().nullable().optional(),
+  expires_at: z33.string().datetime().nullable().optional(),
+  max_uses: z33.number().int().positive().nullable().optional(),
   allowed_email_domain: NormalizedDomainInput.nullable().optional()
 });
-var OrganizationInviteLinkCreateResultDto = z32.object({
+var OrganizationInviteLinkCreateResultDto = z33.object({
   invite_link: OrganizationInviteLinkDto,
-  code: z32.string().min(8)
+  code: z33.string().min(8)
 });
-var OrganizationInviteLinkListInput = z32.object({
-  status: z32.array(OrganizationInviteLinkStatus).optional(),
-  limit: z32.number().int().positive().max(100).default(50),
-  cursor_created_at: z32.string().datetime().optional(),
+var OrganizationInviteLinkListInput = z33.object({
+  status: z33.array(OrganizationInviteLinkStatus).optional(),
+  limit: z33.number().int().positive().max(100).default(50),
+  cursor_created_at: z33.string().datetime().optional(),
   cursor_id: Id.optional()
 });
-var OrganizationInviteLinkListResultDto = z32.object({
-  items: z32.array(OrganizationInviteLinkDto),
-  next_cursor: z32.object({
-    created_at: z32.string(),
+var OrganizationInviteLinkListResultDto = z33.object({
+  items: z33.array(OrganizationInviteLinkDto),
+  next_cursor: z33.object({
+    created_at: z33.string(),
     id: Id
   }).nullable()
 });
-var OrganizationInviteLinkRevokeInput = z32.object({
+var OrganizationInviteLinkRevokeInput = z33.object({
   id: Id
 });
-var OrganizationInviteLinkJoinByCodeInput = z32.object({
-  code: z32.string().trim().min(8).max(256)
+var OrganizationInviteLinkJoinByCodeInput = z33.object({
+  code: z33.string().trim().min(8).max(256)
 });
-var OrganizationInviteLinkUseResultDto = z32.object({
+var OrganizationInviteLinkUseResultDto = z33.object({
   invite_link_id: Id,
   organization: OnboardingOrganizationDto,
   member_id: Id,
   role: OrganizationInviteRoleKey,
-  already_member: z32.boolean()
+  already_member: z33.boolean()
 });
-var OrganizationInvitationListResultDto = z32.object({
-  items: z32.array(OnboardingInvitationDto)
+var OrganizationInvitationListResultDto = z33.object({
+  items: z33.array(OnboardingInvitationDto)
 });
-var OrganizationInvitationAcceptInput = z32.object({
+var OrganizationInvitationAcceptInput = z33.object({
   id: Id
 });
-var OrganizationInvitationRejectInput = z32.object({
+var OrganizationInvitationRejectInput = z33.object({
   id: Id
 });
-var OrganizationInvitationUseResultDto = z32.object({
+var OrganizationInvitationUseResultDto = z33.object({
   invitation: OnboardingInvitationDto,
   organization: OnboardingOrganizationDto,
   member_id: Id,
   role: OrganizationInviteRoleKey,
-  already_member: z32.boolean()
+  already_member: z33.boolean()
 });
-var OrganizationInvitationBatchCreateInput = z32.object({
-  invitations: z32.array(z32.object({
-    email: z32.string().trim().min(1).max(320).transform((value) => value.toLowerCase()),
-    role: z32.string().trim().min(1).max(64).default("member")
+var OrganizationInvitationBatchCreateInput = z33.object({
+  invitations: z33.array(z33.object({
+    email: z33.string().trim().min(1).max(320).transform((value) => value.toLowerCase()),
+    role: z33.string().trim().min(1).max(64).default("member")
   })).min(1).max(100),
-  resend: z32.boolean().default(false)
+  resend: z33.boolean().default(false)
 });
-var OrganizationInvitationBatchCreateItemStatus = z32.enum([
+var OrganizationInvitationBatchCreateItemStatus = z33.enum([
   "created",
   "resent",
   "already_member",
@@ -5768,117 +5798,117 @@ var OrganizationInvitationBatchCreateItemStatus = z32.enum([
   "forbidden_role",
   "failed"
 ]);
-var OrganizationInvitationBatchCreateResultDto = z32.object({
-  items: z32.array(z32.object({
-    email: z32.string().min(1),
+var OrganizationInvitationBatchCreateResultDto = z33.object({
+  items: z33.array(z33.object({
+    email: z33.string().min(1),
     status: OrganizationInvitationBatchCreateItemStatus,
     invitation: OnboardingInvitationDto.nullable(),
-    error: z32.string().nullable()
+    error: z33.string().nullable()
   }))
 });
-var OrganizationSlugAvailabilityInput = z32.object({
-  slug: z32.string().trim().min(1).max(80).transform((value) => value.toLowerCase())
+var OrganizationSlugAvailabilityInput = z33.object({
+  slug: z33.string().trim().min(1).max(80).transform((value) => value.toLowerCase())
 });
-var OrganizationSlugAvailabilityDto = z32.object({
-  slug: z32.string(),
-  available: z32.boolean(),
-  reason: z32.enum(["invalid", "taken"]).nullable()
+var OrganizationSlugAvailabilityDto = z33.object({
+  slug: z33.string(),
+  available: z33.boolean(),
+  reason: z33.enum(["invalid", "taken"]).nullable()
 });
-var OrganizationSettingsDto = z32.object({
+var OrganizationSettingsDto = z33.object({
   organization: OnboardingOrganizationDto,
   settings: JsonObject,
   onboarding_state: JsonObject,
-  version: z32.number().int().positive(),
+  version: z33.number().int().positive(),
   updated_by_user_id: Id.nullable(),
-  created_at: z32.string(),
-  updated_at: z32.string()
+  created_at: z33.string(),
+  updated_at: z33.string()
 });
-var OrganizationSettingsUpdateInput = z32.object({
-  name: z32.string().trim().min(1).max(120).optional(),
-  slug: z32.string().trim().min(1).max(80).transform((value) => value.toLowerCase()).optional(),
-  logo: z32.string().url().nullable().optional(),
+var OrganizationSettingsUpdateInput = z33.object({
+  name: z33.string().trim().min(1).max(120).optional(),
+  slug: z33.string().trim().min(1).max(80).transform((value) => value.toLowerCase()).optional(),
+  logo: z33.string().url().nullable().optional(),
   settings: JsonObject.optional()
 }).refine((input) => Object.keys(input).length > 0, {
   message: "at least one organization setting field is required"
 });
-var OrganizationAuditCursorDto = z32.object({
-  created_at: z32.string(),
+var OrganizationAuditCursorDto = z33.object({
+  created_at: z33.string(),
   id: Id
 });
-var OrganizationAuditLogDto = z32.object({
+var OrganizationAuditLogDto = z33.object({
   id: Id,
   organization_id: Id,
   actor_user_id: Id.nullable(),
   actor_type: OrganizationAuditActorType,
-  action: z32.string(),
-  target_type: z32.string(),
+  action: z33.string(),
+  target_type: z33.string(),
   target_id: Id.nullable(),
   risk_level: OrganizationAuditRiskLevel,
   before: JsonObject,
   after: JsonObject,
   metadata: JsonObject,
-  ip_address: z32.string().nullable(),
-  user_agent: z32.string().nullable(),
-  created_at: z32.string()
+  ip_address: z33.string().nullable(),
+  user_agent: z33.string().nullable(),
+  created_at: z33.string()
 });
-var OrganizationAuditLogListInput = z32.object({
-  target_type: z32.string().min(1).optional(),
+var OrganizationAuditLogListInput = z33.object({
+  target_type: z33.string().min(1).optional(),
   target_id: Id.optional(),
   actor_user_id: Id.optional(),
-  limit: z32.number().int().positive().max(100).default(50),
-  cursor_created_at: z32.string().datetime().optional(),
+  limit: z33.number().int().positive().max(100).default(50),
+  cursor_created_at: z33.string().datetime().optional(),
   cursor_id: Id.optional()
 });
-var OrganizationAuditLogListResultDto = z32.object({
-  items: z32.array(OrganizationAuditLogDto),
+var OrganizationAuditLogListResultDto = z33.object({
+  items: z33.array(OrganizationAuditLogDto),
   next_cursor: OrganizationAuditCursorDto.nullable()
 });
-var OrganizationApprovalRequestDto = z32.object({
+var OrganizationApprovalRequestDto = z33.object({
   id: Id,
   organization_id: Id,
   requester_user_id: Id.nullable(),
-  action: z32.string(),
-  target_type: z32.string(),
+  action: z33.string(),
+  target_type: z33.string(),
   target_id: Id.nullable(),
   payload: JsonObject,
   status: OrganizationApprovalStatus,
-  required_approvals: z32.number().int().positive(),
-  approved_count: z32.number().int().nonnegative(),
+  required_approvals: z33.number().int().positive(),
+  approved_count: z33.number().int().nonnegative(),
   resolved_by_user_id: Id.nullable(),
-  expires_at: z32.string().nullable(),
-  resolved_at: z32.string().nullable(),
-  version: z32.number().int().positive(),
-  created_at: z32.string(),
-  updated_at: z32.string()
-});
-var OrganizationApprovalRequestCreateInput = z32.object({
-  action: z32.string().min(1).max(160),
-  target_type: z32.string().min(1).max(80),
+  expires_at: z33.string().nullable(),
+  resolved_at: z33.string().nullable(),
+  version: z33.number().int().positive(),
+  created_at: z33.string(),
+  updated_at: z33.string()
+});
+var OrganizationApprovalRequestCreateInput = z33.object({
+  action: z33.string().min(1).max(160),
+  target_type: z33.string().min(1).max(80),
   target_id: Id.optional(),
   payload: JsonObject.default({}),
-  required_approvals: z32.number().int().positive().max(20).default(1),
-  expires_at: z32.string().datetime().optional()
+  required_approvals: z33.number().int().positive().max(20).default(1),
+  expires_at: z33.string().datetime().optional()
 });
-var OrganizationApprovalRequestGetInput = z32.object({
+var OrganizationApprovalRequestGetInput = z33.object({
   id: Id
 });
-var OrganizationApprovalRequestListInput = z32.object({
-  status: z32.array(OrganizationApprovalStatus).optional(),
+var OrganizationApprovalRequestListInput = z33.object({
+  status: z33.array(OrganizationApprovalStatus).optional(),
   requester_user_id: Id.optional(),
-  target_type: z32.string().min(1).optional(),
+  target_type: z33.string().min(1).optional(),
   target_id: Id.optional(),
-  limit: z32.number().int().positive().max(100).default(50)
+  limit: z33.number().int().positive().max(100).default(50)
 });
-var OrganizationApprovalRequestResolveInput = z32.object({
+var OrganizationApprovalRequestResolveInput = z33.object({
   id: Id,
   status: OrganizationApprovalTerminalStatus,
-  approved_count: z32.number().int().nonnegative().optional()
+  approved_count: z33.number().int().nonnegative().optional()
 });
-var SignupInvitePrepareOauthInput = z32.object({
-  code: z32.string().min(1).max(128)
+var SignupInvitePrepareOauthInput = z33.object({
+  code: z33.string().min(1).max(128)
 }).strict();
-var SignupInvitePrepareOauthDto = z32.object({
-  prepare_id: z32.string().min(1)
+var SignupInvitePrepareOauthDto = z33.object({
+  prepare_id: z33.string().min(1)
 }).strict();
 
 // ../../packages/protocol/src/feedback.ts
@@ -5894,15 +5924,15 @@ var FEEDBACK_REPORT_STATUSES = [
   "resolved",
   "closed"
 ];
-var FeedbackReportSeverity = z33.enum(FEEDBACK_REPORT_SEVERITIES);
-var FeedbackReportStatus = z33.enum(FEEDBACK_REPORT_STATUSES);
+var FeedbackReportSeverity = z34.enum(FEEDBACK_REPORT_SEVERITIES);
+var FeedbackReportStatus = z34.enum(FEEDBACK_REPORT_STATUSES);
 var FEEDBACK_REPORT_ATTACHMENT_LIMIT = 4;
-var FeedbackReportSource = z33.enum([
+var FeedbackReportSource = z34.enum([
   "shell_rail",
   "help_sheet",
   "error_page"
 ]);
-var FeedbackReportRouteScope = z33.enum([
+var FeedbackReportRouteScope = z34.enum([
   "home",
   "org_home",
   "tasks",
@@ -5913,190 +5943,190 @@ var FeedbackReportRouteScope = z33.enum([
   "error_page",
   "unknown"
 ]);
-var FeedbackReportAttachmentDto = z33.object({
+var FeedbackReportAttachmentDto = z34.object({
   id: Id,
-  filename: z33.string().min(1).max(255),
+  filename: z34.string().min(1).max(255),
   content_type: MediaImageContentType,
-  byte_size: z33.number().int().nonnegative(),
-  public_url: z33.string().url()
+  byte_size: z34.number().int().nonnegative(),
+  public_url: z34.string().url()
 });
 var FeedbackReportAttachmentInput = FeedbackReportAttachmentDto.extend({
-  object_key: z33.string().min(1)
+  object_key: z34.string().min(1)
 }).strict();
-var FeedbackAttachmentUploadCreateInput = z33.object({
-  filename: z33.string().trim().min(1).max(255),
+var FeedbackAttachmentUploadCreateInput = z34.object({
+  filename: z34.string().trim().min(1).max(255),
   content_type: MediaImageContentType,
-  byte_size: z33.number().int().positive().max(10 * 1024 * 1024)
+  byte_size: z34.number().int().positive().max(10 * 1024 * 1024)
 }).strict();
 var FeedbackAttachmentUploadCreateDto = MediaUploadCreateDto.extend({
   attachment_id: Id,
   attachment: FeedbackReportAttachmentInput
 });
-var NullableIsoString = z33.string().nullable();
-var FeedbackReportContextV1 = z33.object({
-  schema_version: z33.literal(1),
+var NullableIsoString = z34.string().nullable();
+var FeedbackReportContextV1 = z34.object({
+  schema_version: z34.literal(1),
   source: FeedbackReportSource.optional(),
-  url: z33.object({
-    origin: z33.string().max(200).optional(),
-    pathname: z33.string().min(1).max(1024),
-    search: z33.string().max(2048).optional(),
-    hash: z33.string().max(512).optional()
+  url: z34.object({
+    origin: z34.string().max(200).optional(),
+    pathname: z34.string().min(1).max(1024),
+    search: z34.string().max(2048).optional(),
+    hash: z34.string().max(512).optional()
   }).optional(),
-  route: z33.object({
+  route: z34.object({
     scope: FeedbackReportRouteScope.optional(),
-    route_id: z33.string().max(256).optional()
+    route_id: z34.string().max(256).optional()
   }).optional(),
-  ids: z33.object({
+  ids: z34.object({
     project_id: Id.optional(),
     channel_id: Id.optional(),
     task_id: Id.optional(),
     agent_turn_id: Id.optional(),
     runtime_session_id: Id.optional()
   }).optional(),
-  build: z33.object({
-    sha: z33.string().min(1).max(80)
+  build: z34.object({
+    sha: z34.string().min(1).max(80)
   }).optional(),
-  browser: z33.object({
-    user_agent: z33.string().max(512).optional(),
-    locale: z33.string().max(64).optional(),
-    timezone: z33.string().max(128).optional(),
-    viewport: z33.object({
-      width: z33.number().int().positive().max(1e5),
-      height: z33.number().int().positive().max(1e5),
-      device_pixel_ratio: z33.number().positive().max(100).optional()
+  browser: z34.object({
+    user_agent: z34.string().max(512).optional(),
+    locale: z34.string().max(64).optional(),
+    timezone: z34.string().max(128).optional(),
+    viewport: z34.object({
+      width: z34.number().int().positive().max(1e5),
+      height: z34.number().int().positive().max(1e5),
+      device_pixel_ratio: z34.number().positive().max(100).optional()
     }).optional()
   }).optional(),
-  api: z33.object({
-    recent: z33.array(z33.object({
-      request_id: z33.string().min(1).max(128),
-      trace_id: z33.string().min(1).max(128).optional(),
-      observed_at: z33.string().min(1).max(64),
-      status: z33.number().int().min(100).max(599).optional()
+  api: z34.object({
+    recent: z34.array(z34.object({
+      request_id: z34.string().min(1).max(128),
+      trace_id: z34.string().min(1).max(128).optional(),
+      observed_at: z34.string().min(1).max(64),
+      status: z34.number().int().min(100).max(599).optional()
     })).max(10)
   }).optional(),
-  error: z33.object({
-    summary: z33.string().max(1000).optional(),
-    stack: z33.string().max(8000).optional()
+  error: z34.object({
+    summary: z34.string().max(1000).optional(),
+    stack: z34.string().max(8000).optional()
   }).optional(),
-  tracelab: z33.object({
-    url_path: z33.string().max(1024).optional()
+  tracelab: z34.object({
+    url_path: z34.string().max(1024).optional()
   }).optional(),
-  attachments: z33.array(FeedbackReportAttachmentDto).max(FEEDBACK_REPORT_ATTACHMENT_LIMIT).optional()
+  attachments: z34.array(FeedbackReportAttachmentDto).max(FEEDBACK_REPORT_ATTACHMENT_LIMIT).optional()
 });
-var FeedbackReportCreateInput = z33.object({
-  title: z33.string().trim().min(1).max(160),
-  body_md: z33.string().trim().min(1).max(8000),
-  expected_md: z33.string().trim().max(4000).optional(),
+var FeedbackReportCreateInput = z34.object({
+  title: z34.string().trim().min(1).max(160),
+  body_md: z34.string().trim().min(1).max(8000),
+  expected_md: z34.string().trim().max(4000).optional(),
   severity: FeedbackReportSeverity,
-  attachments: z33.array(FeedbackReportAttachmentInput).max(FEEDBACK_REPORT_ATTACHMENT_LIMIT).default([]),
-  context: z33.unknown().optional()
+  attachments: z34.array(FeedbackReportAttachmentInput).max(FEEDBACK_REPORT_ATTACHMENT_LIMIT).default([]),
+  context: z34.unknown().optional()
 });
-var FeedbackReportListInput = z33.object({
-  limit: z33.number().int().min(1).max(100).default(50)
+var FeedbackReportListInput = z34.object({
+  limit: z34.number().int().min(1).max(100).default(50)
 });
-var FeedbackReportUpdateStatusInput = z33.object({
+var FeedbackReportUpdateStatusInput = z34.object({
   id: Id,
   status: FeedbackReportStatus
 });
-var FeedbackReportReporterDto = z33.object({
+var FeedbackReportReporterDto = z34.object({
   user_id: Id,
-  name: z33.string().nullable(),
-  email: z33.string().nullable(),
-  avatar_url: z33.string().nullable()
+  name: z34.string().nullable(),
+  email: z34.string().nullable(),
+  avatar_url: z34.string().nullable()
 });
-var FeedbackReportDto = z33.object({
+var FeedbackReportDto = z34.object({
   id: Id,
   reporter_user_id: Id,
   reporter: FeedbackReportReporterDto,
-  title: z33.string(),
-  body_md: z33.string(),
-  expected_md: z33.string().nullable(),
+  title: z34.string(),
+  body_md: z34.string(),
+  expected_md: z34.string().nullable(),
   severity: FeedbackReportSeverity,
   status: FeedbackReportStatus,
   context: FeedbackReportContextV1,
-  created_at: z33.string(),
-  updated_at: z33.string(),
+  created_at: z34.string(),
+  updated_at: z34.string(),
   terminal_at: NullableIsoString,
   terminal_by_user_id: Id.nullable(),
   status_updated_by_user_id: Id.nullable()
 });
-var FeedbackReportListResultDto = z33.object({
-  items: z33.array(FeedbackReportDto)
+var FeedbackReportListResultDto = z34.object({
+  items: z34.array(FeedbackReportDto)
 });
 // ../../packages/protocol/src/inbox.ts
-import { z as z34 } from "zod";
-var InboxEntryKind = z34.enum(["mention", "task_assigned"]);
-var InboxActorDto = z34.object({
+import { z as z35 } from "zod";
+var InboxEntryKind = z35.enum(["mention", "task_assigned"]);
+var InboxActorDto = z35.object({
   user_id: Id,
-  name: z34.string(),
-  avatar_url: z34.string().nullable()
+  name: z35.string(),
+  avatar_url: z35.string().nullable()
 });
-var InboxEntryTargetDto = z34.discriminatedUnion("kind", [
-  z34.object({
-    kind: z34.literal("channel"),
+var InboxEntryTargetDto = z35.discriminatedUnion("kind", [
+  z35.object({
+    kind: z35.literal("channel"),
     channel_id: Id,
-    channel_name: z34.string(),
+    channel_name: z35.string(),
     message_id: Id,
     thread_id: Id.nullable()
   }),
-  z34.object({
-    kind: z34.literal("task"),
+  z35.object({
+    kind: z35.literal("task"),
     project_id: Id,
     task_id: Id,
-    task_title: z34.string()
+    task_title: z35.string()
   })
 ]);
-var InboxEntryDto = z34.object({
+var InboxEntryDto = z35.object({
   id: Id,
   kind: InboxEntryKind,
-  created_at: z34.string(),
-  read_at: z34.string().nullable(),
+  created_at: z35.string(),
+  read_at: z35.string().nullable(),
   actor: InboxActorDto.nullable(),
-  summary: z34.string().nullable(),
+  summary: z35.string().nullable(),
   target: InboxEntryTargetDto
 });
-var InboxListInput = z34.object({
-  limit: z34.number().int().positive().max(100).optional(),
-  after_cursor: z34.string().max(512).nullable().optional(),
-  unread_only: z34.boolean().optional()
+var InboxListInput = z35.object({
+  limit: z35.number().int().positive().max(100).optional(),
+  after_cursor: z35.string().max(512).nullable().optional(),
+  unread_only: z35.boolean().optional()
 });
-var InboxListResultDto = z34.object({
-  items: z34.array(InboxEntryDto),
-  next_cursor: z34.string().nullable(),
-  unread_count: z34.number().int().nonnegative()
+var InboxListResultDto = z35.object({
+  items: z35.array(InboxEntryDto),
+  next_cursor: z35.string().nullable(),
+  unread_count: z35.number().int().nonnegative()
 });
-var MarkInboxReadInput = z34.object({
-  ids: z34.array(Id).min(1).max(100)
+var MarkInboxReadInput = z35.object({
+  ids: z35.array(Id).min(1).max(100)
 });
 // ../../packages/protocol/src/mappers.ts
-import { z as z39 } from "zod";
+import { z as z40 } from "zod";
 
 // ../../packages/protocol/src/rest/channels.ts
-import { z as z36 } from "zod";
+import { z as z37 } from "zod";
 
 // ../../packages/protocol/src/runtime-defaults.ts
-import { z as z35 } from "zod";
-var RuntimeRepositorySelectionDto = z35.object({
+import { z as z36 } from "zod";
+var RuntimeRepositorySelectionDto = z36.object({
   project_repository_id: Id,
-  checkout_ref: z35.string().nullable()
+  checkout_ref: z36.string().nullable()
 });
-var RuntimeRepositorySelectionInput = z35.object({
+var RuntimeRepositorySelectionInput = z36.object({
   project_repository_id: Id,
-  checkout_ref: z35.string().max(255).nullable().optional()
+  checkout_ref: z36.string().max(255).nullable().optional()
 }).strict();
-var RuntimeRepositorySelectionsInput = z35.array(RuntimeRepositorySelectionInput).max(20).refine((selections) => new Set(selections.map((selection) => selection.project_repository_id)).size === selections.length, "duplicate project_repository_id");
-var RuntimeDefaultsEffectiveSource = z35.enum([
+var RuntimeRepositorySelectionsInput = z36.array(RuntimeRepositorySelectionInput).max(20).refine((selections) => new Set(selections.map((selection) => selection.project_repository_id)).size === selections.length, "duplicate project_repository_id");
+var RuntimeDefaultsEffectiveSource = z36.enum([
   "channel",
   "project",
   "empty"
 ]);
-var RuntimeDefaultsEffectiveDto = z35.object({
+var RuntimeDefaultsEffectiveDto = z36.object({
   source: RuntimeDefaultsEffectiveSource,
   profile_id: Id.nullable(),
   project_id: Id.nullable(),
-  repositories: z35.array(RuntimeRepositorySelectionDto),
-  project_repository_ids: z35.array(Id),
-  default_checkout_ref: z35.string().nullable(),
+  repositories: z36.array(RuntimeRepositorySelectionDto),
+  project_repository_ids: z36.array(Id),
+  default_checkout_ref: z36.string().nullable(),
   default_provider_kind: RuntimeProviderKind.nullable(),
   default_remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable(),
   default_execution_mode: RuntimeExecutionMode.nullable()
@@ -6104,385 +6134,385 @@ var RuntimeDefaultsEffectiveDto = z35.object({
 
 // ../../packages/protocol/src/rest/channels.ts
 var ChannelRuntimeProfileStatus2 = ChannelRuntimeProfileStatus;
-var ChannelAttachmentUploadCreateInput = z36.object({
+var ChannelAttachmentUploadCreateInput = z37.object({
   channel_id: Id,
-  filename: z36.string().trim().min(1).max(255),
+  filename: z37.string().trim().min(1).max(255),
   content_type: MediaImageContentType,
-  byte_size: z36.number().int().positive().max(10 * 1024 * 1024)
+  byte_size: z37.number().int().positive().max(10 * 1024 * 1024)
 }).strict();
-var ChannelMessageAttachmentDto = z36.object({
+var ChannelMessageAttachmentDto = z37.object({
   id: Id,
-  filename: z36.string(),
+  filename: z37.string(),
   content_type: MediaImageContentType,
-  byte_size: z36.number().int().nonnegative(),
-  public_url: z36.string().url()
+  byte_size: z37.number().int().nonnegative(),
+  public_url: z37.string().url()
 });
 var ChannelAttachmentUploadCreateDto = MediaUploadCreateDto.extend({
   attachment_id: Id,
   attachment: ChannelMessageAttachmentDto
 });
-var ForumThreadReceiptDto = z36.object({
+var ForumThreadReceiptDto = z37.object({
   id: Id,
   channel_id: Id,
-  thread: z36.string(),
-  action_type: z36.string(),
-  status: z36.enum(["pending", "committed", "failed"]),
-  idempotency_key: z36.string(),
-  event_seq: z36.number().int().positive().nullable(),
-  error: z36.unknown(),
-  poll_after_ms: z36.number().int().positive().optional(),
-  created_at: z36.string(),
-  updated_at: z36.string()
-});
-var ForumThreadDto = z36.object({
-  id: z36.string(),
-  thread: z36.string(),
+  thread: z37.string(),
+  action_type: z37.string(),
+  status: z37.enum(["pending", "committed", "failed"]),
+  idempotency_key: z37.string(),
+  event_seq: z37.number().int().positive().nullable(),
+  error: z37.unknown(),
+  poll_after_ms: z37.number().int().positive().optional(),
+  created_at: z37.string(),
+  updated_at: z37.string()
+});
+var ForumThreadDto = z37.object({
+  id: z37.string(),
+  thread: z37.string(),
   channel_id: Id,
-  title: z36.string().nullable(),
-  description_md: z36.string().nullable(),
-  summary_md: z36.string().nullable(),
-  status: z36.string(),
-  labels: z36.array(z36.string()),
-  assignee_user_ids: z36.array(z36.string()),
-  opened_at: z36.string().nullable(),
-  updated_at: z36.string().nullable(),
-  last_event_seq: z36.number().int().nonnegative(),
-  comment_count: z36.number().int().nonnegative(),
-  aliases: z36.array(z36.string())
-});
-var ForumThreadEventDto = z36.record(z36.string(), z36.unknown());
-var ForumThreadsListInput = z36.object({
+  title: z37.string().nullable(),
+  description_md: z37.string().nullable(),
+  summary_md: z37.string().nullable(),
+  status: z37.string(),
+  labels: z37.array(z37.string()),
+  assignee_user_ids: z37.array(z37.string()),
+  opened_at: z37.string().nullable(),
+  updated_at: z37.string().nullable(),
+  last_event_seq: z37.number().int().nonnegative(),
+  comment_count: z37.number().int().nonnegative(),
+  aliases: z37.array(z37.string())
+});
+var ForumThreadEventDto = z37.record(z37.string(), z37.unknown());
+var ForumThreadsListInput = z37.object({
   channel_id: Id
 });
-var ForumThreadsGetInput = z36.object({
+var ForumThreadsGetInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1)
+  thread: z37.string().min(1)
 });
-var ForumThreadReceiptGetInput = z36.object({
+var ForumThreadReceiptGetInput = z37.object({
   id: Id
 });
-var ForumThreadsCreateInput = z36.object({
+var ForumThreadsCreateInput = z37.object({
   channel_id: Id,
-  idempotency_key: z36.string().min(1),
-  title: z36.string().min(1).max(200),
-  description_md: z36.string().max(20000).optional(),
-  labels: z36.array(z36.string().min(1).max(64)).default([]),
-  assignee_user_ids: z36.array(Id).default([])
+  idempotency_key: z37.string().min(1),
+  title: z37.string().min(1).max(200),
+  description_md: z37.string().max(20000).optional(),
+  labels: z37.array(z37.string().min(1).max(64)).default([]),
+  assignee_user_ids: z37.array(Id).default([])
 });
-var ForumThreadsCommentInput = z36.object({
+var ForumThreadsCommentInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
-  body_md: z36.string().min(1),
-  attachment_ids: z36.array(Id).max(8).default([])
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
+  body_md: z37.string().min(1),
+  attachment_ids: z37.array(Id).max(8).default([])
 });
-var ForumThreadsLinkTaskInput = z36.object({
+var ForumThreadsLinkTaskInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
+  thread: z37.string().min(1),
   task_id: Id,
-  link_kind: z36.enum(["primary_task", "reference_task"]).default("primary_task")
+  link_kind: z37.enum(["primary_task", "reference_task"]).default("primary_task")
 });
-var ForumThreadsCreateTaskInput = z36.object({
+var ForumThreadsCreateTaskInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
-  title: z36.string().trim().min(1).max(200).optional()
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
+  title: z37.string().trim().min(1).max(200).optional()
 });
-var ForumThreadsLinkChannelInput = z36.object({
+var ForumThreadsLinkChannelInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
+  thread: z37.string().min(1),
   target_channel_id: Id,
-  link_kind: z36.enum(["discussion_channel", "reference_channel"]).default("discussion_channel")
+  link_kind: z37.enum(["discussion_channel", "reference_channel"]).default("discussion_channel")
 });
-var ForumThreadsCreateChannelInput = z36.object({
+var ForumThreadsCreateChannelInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
-  title: z36.string().trim().min(1).max(200).optional()
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
+  title: z37.string().trim().min(1).max(200).optional()
 });
-var ForumThreadsUnlinkInput = z36.object({
+var ForumThreadsUnlinkInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
+  thread: z37.string().min(1),
   link_id: Id
 });
-var ForumThreadPublicStatus = z36.enum(["open", "resolved", "closed"]);
-var ForumThreadsSetStatusInput = z36.object({
+var ForumThreadPublicStatus = z37.enum(["open", "resolved", "closed"]);
+var ForumThreadsSetStatusInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
   status: ForumThreadPublicStatus
 });
-var ForumThreadsSetLabelsInput = z36.object({
+var ForumThreadsSetLabelsInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
-  labels: z36.array(z36.string().trim().min(1).max(64)).default([])
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
+  labels: z37.array(z37.string().trim().min(1).max(64)).default([])
 });
-var ForumThreadsSetAssigneesInput = z36.object({
+var ForumThreadsSetAssigneesInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
-  assignee_user_ids: z36.array(Id).default([])
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
+  assignee_user_ids: z37.array(Id).default([])
 });
-var ForumThreadsSetSummaryInput = z36.object({
+var ForumThreadsSetSummaryInput = z37.object({
   channel_id: Id,
-  thread: z36.string().min(1),
-  idempotency_key: z36.string().min(1),
-  summary_md: z36.string().max(4000)
+  thread: z37.string().min(1),
+  idempotency_key: z37.string().min(1),
+  summary_md: z37.string().max(4000)
 });
 var ChannelRuntimeStatus = ChannelRuntimeProfileStatus2;
-var ChannelRuntimeWritableStatus = z36.enum([
+var ChannelRuntimeWritableStatus = z37.enum([
   "active",
   "inherit_project",
   "disabled"
 ]);
-var ChannelRuntimeProfileDto = z36.object({
+var ChannelRuntimeProfileDto = z37.object({
   id: Id,
   channel_id: Id,
   project_id: Id.nullable(),
-  repositories: z36.array(RuntimeRepositorySelectionDto),
-  project_repository_ids: z36.array(Id),
-  default_checkout_ref: z36.string().nullable(),
+  repositories: z37.array(RuntimeRepositorySelectionDto),
+  project_repository_ids: z37.array(Id),
+  default_checkout_ref: z37.string().nullable(),
   default_provider_kind: RuntimeProviderKind,
   default_remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable(),
   default_execution_mode: RuntimeExecutionMode,
   status: ChannelRuntimeStatus,
-  version: z36.number().int().nonnegative(),
-  created_at: z36.string().nullable(),
-  updated_at: z36.string().nullable()
+  version: z37.number().int().nonnegative(),
+  created_at: z37.string().nullable(),
+  updated_at: z37.string().nullable()
 });
-var ChannelRuntimeGetInput = z36.object({
+var ChannelRuntimeGetInput = z37.object({
   channel_id: Id
 });
-var ChannelRuntimeGetDto = z36.object({
+var ChannelRuntimeGetDto = z37.object({
   channel_id: Id,
   profile: ChannelRuntimeProfileDto.nullable(),
   effective: RuntimeDefaultsEffectiveDto,
-  version: z36.number().int().nonnegative()
+  version: z37.number().int().nonnegative()
 });
-var ChannelRuntimeUpdatePatch = z36.object({
+var ChannelRuntimeUpdatePatch = z37.object({
   repositories: RuntimeRepositorySelectionsInput.optional(),
-  project_repository_ids: z36.array(Id).max(20).refine((ids) => new Set(ids).size === ids.length, "duplicate project_repository_id").optional(),
-  default_checkout_ref: z36.string().max(255).nullable().optional(),
+  project_repository_ids: z37.array(Id).max(20).refine((ids) => new Set(ids).size === ids.length, "duplicate project_repository_id").optional(),
+  default_checkout_ref: z37.string().max(255).nullable().optional(),
   default_provider_kind: RuntimeProviderKind.optional(),
   default_remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable().optional(),
   default_execution_mode: RuntimeExecutionMode.optional(),
   status: ChannelRuntimeWritableStatus.optional()
 }).strict();
-var ChannelRuntimeUpdateInput = z36.object({
+var ChannelRuntimeUpdateInput = z37.object({
   channel_id: Id,
-  expected_version: z36.number().int().nonnegative(),
+  expected_version: z37.number().int().nonnegative(),
   patch: ChannelRuntimeUpdatePatch
 }).strict();
 // ../../packages/protocol/src/rest/projects.ts
-import { z as z38 } from "zod";
+import { z as z39 } from "zod";
 
 // ../../packages/protocol/src/runtime-env-patch.ts
-import { z as z37 } from "zod";
-var RuntimeEnvPatch = z37.record(AllowedEnvKey, z37.string().min(1).nullable());
+import { z as z38 } from "zod";
+var RuntimeEnvPatch = z38.record(AllowedEnvKey, z38.string().min(1).nullable());
 
 // ../../packages/protocol/src/rest/projects.ts
 var ProjectRuntimeProfileStatus2 = ProjectRuntimeProfileStatus;
-var ProjectDto = z38.object({
+var ProjectDto = z39.object({
   id: Id,
   organization_id: Id,
-  slug: z38.string(),
-  name: z38.string(),
-  description: z38.string().nullable(),
-  git_remote_url: z38.string(),
-  git_remote_key: z38.string(),
-  default_branch: z38.string(),
+  slug: z39.string(),
+  name: z39.string(),
+  description: z39.string().nullable(),
+  git_remote_url: z39.string(),
+  git_remote_key: z39.string(),
+  default_branch: z39.string(),
   default_backend: BackendKind,
-  archived_at: z38.string().nullable(),
-  created_at: z38.string(),
-  updated_at: z38.string()
+  archived_at: z39.string().nullable(),
+  created_at: z39.string(),
+  updated_at: z39.string()
 });
-var ProjectListInput = z38.object({
-  include_archived: z38.boolean().default(false)
+var ProjectListInput = z39.object({
+  include_archived: z39.boolean().default(false)
 });
-var ProjectGetInput = z38.object({
+var ProjectGetInput = z39.object({
   id: Id
 });
-var ProjectCreateInput = z38.object({
-  slug: z38.string().min(1).optional(),
-  name: z38.string().min(1),
-  description: z38.string().optional(),
-  git_remote_url: z38.string().min(1),
-  default_branch: z38.string().min(1).default("main"),
+var ProjectCreateInput = z39.object({
+  slug: z39.string().min(1).optional(),
+  name: z39.string().min(1),
+  description: z39.string().optional(),
+  git_remote_url: z39.string().min(1),
+  default_branch: z39.string().min(1).default("main"),
   default_backend: BackendKind.default("claude")
 });
-var ProjectUpdateInput = z38.object({
+var ProjectUpdateInput = z39.object({
   id: Id,
-  name: z38.string().min(1).optional(),
-  description: z38.string().nullable().optional(),
-  default_branch: z38.string().min(1).optional(),
+  name: z39.string().min(1).optional(),
+  description: z39.string().nullable().optional(),
+  default_branch: z39.string().min(1).optional(),
   default_backend: BackendKind.optional()
 });
-var ProjectArchiveInput = z38.object({
+var ProjectArchiveInput = z39.object({
   id: Id
 });
-var ProjectSettingsDto = z38.object({
+var ProjectSettingsDto = z39.object({
   project_id: Id,
   settings: JsonObject,
-  version: z38.number().int().nonnegative()
+  version: z39.number().int().nonnegative()
 });
-var ProjectSettingsGetInput = z38.object({
+var ProjectSettingsGetInput = z39.object({
   project_id: Id
 });
-var ProjectSettingsUpdateInput = z38.object({
+var ProjectSettingsUpdateInput = z39.object({
   project_id: Id,
-  expected_version: z38.number().int().nonnegative(),
+  expected_version: z39.number().int().nonnegative(),
   runtime_env_patch: RuntimeEnvPatch.optional()
 }).strict();
 var ProjectRuntimeStatus = ProjectRuntimeProfileStatus2;
-var ProjectRuntimeWritableStatus = z38.enum(["active", "disabled"]);
-var ProjectRuntimeProfileDto = z38.object({
+var ProjectRuntimeWritableStatus = z39.enum(["active", "disabled"]);
+var ProjectRuntimeProfileDto = z39.object({
   id: Id,
   project_id: Id,
-  repositories: z38.array(RuntimeRepositorySelectionDto),
-  project_repository_ids: z38.array(Id),
-  default_checkout_ref: z38.string().nullable(),
+  repositories: z39.array(RuntimeRepositorySelectionDto),
+  project_repository_ids: z39.array(Id),
+  default_checkout_ref: z39.string().nullable(),
   default_provider_kind: RuntimeProviderKind,
   default_remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable(),
   default_execution_mode: RuntimeExecutionMode,
   status: ProjectRuntimeStatus,
-  version: z38.number().int().nonnegative(),
-  created_at: z38.string().nullable(),
-  updated_at: z38.string().nullable()
+  version: z39.number().int().nonnegative(),
+  created_at: z39.string().nullable(),
+  updated_at: z39.string().nullable()
 });
-var ProjectRuntimeGetInput = z38.object({
+var ProjectRuntimeGetInput = z39.object({
   project_id: Id
 });
-var ProjectRuntimeGetDto = z38.object({
+var ProjectRuntimeGetDto = z39.object({
   project_id: Id,
   profile: ProjectRuntimeProfileDto.nullable(),
   effective: RuntimeDefaultsEffectiveDto,
-  version: z38.number().int().nonnegative()
+  version: z39.number().int().nonnegative()
 });
-var ProjectRuntimeUpdatePatch = z38.object({
+var ProjectRuntimeUpdatePatch = z39.object({
   repositories: RuntimeRepositorySelectionsInput.optional(),
-  project_repository_ids: z38.array(Id).max(20).refine((ids) => new Set(ids).size === ids.length, "duplicate project_repository_id").optional(),
-  default_checkout_ref: z38.string().max(255).nullable().optional(),
+  project_repository_ids: z39.array(Id).max(20).refine((ids) => new Set(ids).size === ids.length, "duplicate project_repository_id").optional(),
+  default_checkout_ref: z39.string().max(255).nullable().optional(),
   default_provider_kind: RuntimeProviderKind.optional(),
   default_remote_sandbox_backend: RuntimeRemoteSandboxBackend.nullable().optional(),
   default_execution_mode: RuntimeExecutionMode.optional(),
   status: ProjectRuntimeWritableStatus.optional()
 }).strict();
-var ProjectRuntimeUpdateInput = z38.object({
+var ProjectRuntimeUpdateInput = z39.object({
   project_id: Id,
-  expected_version: z38.number().int().nonnegative(),
+  expected_version: z39.number().int().nonnegative(),
   patch: ProjectRuntimeUpdatePatch
 }).strict();
-var ProjectAgentProfileDto = z38.object({
+var ProjectAgentProfileDto = z39.object({
   id: Id,
   organization_id: Id,
   project_id: Id,
   agent_profile_id: Id,
-  key: z38.string(),
-  description: z38.string().nullable(),
+  key: z39.string(),
+  description: z39.string().nullable(),
   agent_type: AgentProfileType,
   profile_kind: AgentProfileKind,
   backend_kind: BackendKind.nullable(),
-  default_model: z38.string().nullable(),
-  enabled: z38.boolean(),
+  default_model: z39.string().nullable(),
+  enabled: z39.boolean(),
   prompt_profile: JsonObject,
   prompt_profile_override: JsonObject,
   settings: AgentProfileSettingsDto,
   settings_override: AgentProfileSettingsOverrideDto,
-  version: z38.number().int().nonnegative(),
-  created_at: z38.string(),
-  updated_at: z38.string()
+  version: z39.number().int().nonnegative(),
+  created_at: z39.string(),
+  updated_at: z39.string()
 });
-var ProjectAgentProfileListInput = z38.object({
+var ProjectAgentProfileListInput = z39.object({
   project_id: Id,
-  include_disabled: z38.boolean().default(false),
+  include_disabled: z39.boolean().default(false),
   profile_kind: AgentProfileKind.optional()
 });
-var ProjectAgentProfileUpdateInput = z38.object({
+var ProjectAgentProfileUpdateInput = z39.object({
   id: Id,
-  expected_version: z38.number().int().nonnegative(),
-  key: z38.string().trim().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/).optional(),
-  enabled: z38.boolean().optional(),
+  expected_version: z39.number().int().nonnegative(),
+  key: z39.string().trim().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/).optional(),
+  enabled: z39.boolean().optional(),
   backend_kind_override: BackendKind.nullable().optional(),
-  default_model_override: z38.string().trim().min(1).max(120).nullable().optional(),
-  base_persona_md_override: z38.string().min(1).max(40000).nullable().optional(),
+  default_model_override: z39.string().trim().min(1).max(120).nullable().optional(),
+  base_persona_md_override: z39.string().min(1).max(40000).nullable().optional(),
   runtime_env_patch: RuntimeEnvPatch.optional()
 }).strict();
-var SkillFileDto = z38.object({
-  path: z38.string(),
-  content: z38.string()
+var SkillFileDto = z39.object({
+  path: z39.string(),
+  content: z39.string()
 });
-var SkillDto = z38.object({
+var SkillDto = z39.object({
   id: Id,
   organization_id: Id,
   project_id: Id.nullable(),
-  slug: z38.string(),
-  name: z38.string(),
-  description: z38.string().nullable(),
-  content_md: z38.string(),
-  files: z38.array(SkillFileDto),
+  slug: z39.string(),
+  name: z39.string(),
+  description: z39.string().nullable(),
+  content_md: z39.string(),
+  files: z39.array(SkillFileDto),
   config: JsonObject,
   origin: JsonObject,
-  archived_at: z38.string().nullable(),
-  version: z38.number().int().positive(),
-  created_at: z38.string(),
-  updated_at: z38.string()
+  archived_at: z39.string().nullable(),
+  version: z39.number().int().positive(),
+  created_at: z39.string(),
+  updated_at: z39.string()
 });
 var SkillSummaryDto = SkillDto.omit({
   content_md: true,
   files: true
 });
-var SkillBundleInput = z38.object({
-  slug: z38.string().trim().min(1).max(64),
-  name: z38.string().trim().min(1).max(120),
-  description: z38.string().trim().max(1000).nullable().optional(),
-  content_md: z38.string().min(1).max(200000),
-  files: z38.array(SkillFileDto).default([])
+var SkillBundleInput = z39.object({
+  slug: z39.string().trim().min(1).max(64),
+  name: z39.string().trim().min(1).max(120),
+  description: z39.string().trim().max(1000).nullable().optional(),
+  content_md: z39.string().min(1).max(200000),
+  files: z39.array(SkillFileDto).default([])
 }).strict();
-var SkillUpdateInput = z38.object({
+var SkillUpdateInput = z39.object({
   id: Id,
-  slug: z38.string().trim().min(1).max(64).optional(),
-  name: z38.string().trim().min(1).max(120).optional(),
-  description: z38.string().trim().max(1000).nullable().optional(),
-  content_md: z38.string().min(1).max(200000).optional(),
-  files: z38.array(SkillFileDto).optional()
+  slug: z39.string().trim().min(1).max(64).optional(),
+  name: z39.string().trim().min(1).max(120).optional(),
+  description: z39.string().trim().max(1000).nullable().optional(),
+  content_md: z39.string().min(1).max(200000).optional(),
+  files: z39.array(SkillFileDto).optional()
 }).strict();
-var SkillListInput = z38.object({
-  include_archived: z38.boolean().default(false)
+var SkillListInput = z39.object({
+  include_archived: z39.boolean().default(false)
 });
-var SkillGetInput = z38.object({
+var SkillGetInput = z39.object({
   id: Id
 });
-var SkillArchiveInput = z38.object({
+var SkillArchiveInput = z39.object({
   id: Id
 });
-var ProjectAgentSkillAttachInput = z38.object({
+var ProjectAgentSkillAttachInput = z39.object({
   project_agent_profile_id: Id,
   skill_id: Id
 });
-var ProjectAgentSkillListInput = z38.object({
+var ProjectAgentSkillListInput = z39.object({
   project_agent_profile_id: Id
 });
-var ProjectRepositoryServicePortPresetInput = z38.object({
-  port: z38.number().int().min(1).max(65535),
+var ProjectRepositoryServicePortPresetInput = z39.object({
+  port: z39.number().int().min(1).max(65535),
   protocol: RuntimeServicePortProtocol.default("http"),
-  label: z38.string().trim().min(1).max(80).nullable().optional()
+  label: z39.string().trim().min(1).max(80).nullable().optional()
 }).strict().transform((preset) => ({
   ...preset,
   label: preset.label?.trim() || null
 }));
-var ProjectRepositoryServicePortPresetDto = z38.object({
-  port: z38.number().int().min(1).max(65535),
+var ProjectRepositoryServicePortPresetDto = z39.object({
+  port: z39.number().int().min(1).max(65535),
   protocol: RuntimeServicePortProtocol,
-  label: z38.string().min(1).max(80).nullable()
+  label: z39.string().min(1).max(80).nullable()
 }).strict();
-var ProjectRepositoryServicePortPresetsInput = z38.object({
-  version: z38.literal(1).default(1),
-  ports: z38.array(ProjectRepositoryServicePortPresetInput).max(20).default([])
+var ProjectRepositoryServicePortPresetsInput = z39.object({
+  version: z39.literal(1).default(1),
+  ports: z39.array(ProjectRepositoryServicePortPresetInput).max(20).default([])
 }).strict().superRefine((value, ctx) => refineProjectRepositoryServicePortPresets(value.ports, ctx));
-var ProjectRepositoryServicePortPresetsDto = z38.object({
-  version: z38.literal(1),
-  ports: z38.array(ProjectRepositoryServicePortPresetDto).max(20).default([])
+var ProjectRepositoryServicePortPresetsDto = z39.object({
+  version: z39.literal(1),
+  ports: z39.array(ProjectRepositoryServicePortPresetDto).max(20).default([])
 }).strict().superRefine((value, ctx) => refineProjectRepositoryServicePortPresets(value.ports, ctx));
 function refineProjectRepositoryServicePortPresets(ports, ctx) {
   const seen = new Set;
@@ -6498,84 +6528,112 @@ function refineProjectRepositoryServicePortPresets(ports, ctx) {
     seen.add(key);
   });
 }
-var ProjectRepositorySummaryDto = z38.object({
+var ProjectRepositorySummaryDto = z39.object({
   id: Id,
-  display_name: z38.string(),
-  remote_url: z38.string(),
-  remote_key: z38.string(),
-  default_branch: z38.string(),
-  setup_script: z38.string().nullable(),
+  provider_kind: GitCredentialProviderKind,
+  display_name: z39.string(),
+  remote_url: z39.string(),
+  remote_key: z39.string(),
+  default_branch: z39.string(),
+  setup_script: z39.string().nullable(),
   env_template: RepoEnvTemplateDto,
-  env_prepare_script: z38.string().nullable(),
+  env_prepare_script: z39.string().nullable(),
   service_port_presets: ProjectRepositoryServicePortPresetsDto,
-  is_default: z38.boolean(),
-  status: z38.enum(["active", "disabled", "archived"]),
-  version: z38.number().int().nonnegative()
+  is_default: z39.boolean(),
+  status: z39.enum(["active", "disabled", "archived"]),
+  version: z39.number().int().nonnegative()
 });
-var ProjectRepositoryListInput = z38.object({
+var ProjectRepositoryListInput = z39.object({
   project_id: Id
 });
-var ProjectRepositoryCreateInput = z38.object({
+var ProjectRepositoryCreateInput = z39.object({
   project_id: Id,
-  display_name: z38.string().min(1).optional(),
-  git_remote_url: z38.string().min(1),
-  default_branch: z38.string().min(1).default("main"),
-  setup_script: z38.string().nullable().optional(),
+  display_name: z39.string().min(1).optional(),
+  git_remote_url: z39.string().min(1),
+  provider_kind: GitCredentialProviderKind.optional(),
+  default_branch: z39.string().min(1).default("main"),
+  setup_script: z39.string().nullable().optional(),
   env_template: RepoEnvTemplateInput.nullable().optional(),
-  env_prepare_script: z38.string().nullable().optional(),
+  env_prepare_script: z39.string().nullable().optional(),
   service_port_presets: ProjectRepositoryServicePortPresetsInput.nullable().optional()
 }).strict();
-var ProjectRepositoryUpdateInput = z38.object({
+var ProjectRepositoryUpdateInput = z39.object({
   project_id: Id,
   project_repository_id: Id,
-  expected_version: z38.number().int().nonnegative(),
-  display_name: z38.string().min(1).optional(),
-  default_branch: z38.string().min(1).optional(),
-  setup_script: z38.string().nullable().optional(),
+  expected_version: z39.number().int().nonnegative(),
+  display_name: z39.string().min(1).optional(),
+  provider_kind: GitCredentialProviderKind.optional(),
+  default_branch: z39.string().min(1).optional(),
+  setup_script: z39.string().nullable().optional(),
   env_template: RepoEnvTemplateInput.nullable().optional(),
-  env_prepare_script: z38.string().nullable().optional(),
+  env_prepare_script: z39.string().nullable().optional(),
   service_port_presets: ProjectRepositoryServicePortPresetsInput.nullable().optional()
 }).strict();
+var ProjectRepositoryBranchDto = z39.object({
+  name: z39.string().min(1),
+  commit_sha: z39.string().min(1).nullable().optional(),
+  protected: z39.boolean().nullable().optional(),
+  default: z39.boolean().default(false)
+}).strict();
+var ProjectRepositoryBranchListInput = z39.object({
+  project_id: Id,
+  project_repository_id: Id,
+  query: z39.string().trim().min(1).max(120).optional(),
+  limit: z39.number().int().min(1).max(100).default(50),
+  cursor: z39.string().min(1).max(120).optional()
+}).strict();
+var ProjectRepositoryBranchListDto = z39.object({
+  project_repository_id: Id,
+  provider_kind: GitCredentialProviderKind,
+  default_branch: z39.string().min(1),
+  branches: z39.array(ProjectRepositoryBranchDto),
+  next_cursor: z39.string().nullable(),
+  capabilities: z39.object({
+    can_list_branches: z39.boolean(),
+    can_create_review_request: z39.boolean()
+  }).strict(),
+  unavailable_reason: z39.string().min(1).nullable()
+}).strict();
 // ../../packages/protocol/src/mappers.ts
-var JsonObject2 = z39.record(z39.string(), z39.unknown());
+var JsonObject2 = z40.record(z40.string(), z40.unknown());
 // ../../packages/protocol/src/organization-settings.ts
-import { z as z40 } from "zod";
+import { z as z41 } from "zod";
 var organizationSettingsFields = {
-  feature_flags: z40.record(z40.string(), z40.boolean()).optional()
+  feature_flags: z41.record(z41.string(), z41.boolean()).optional()
 };
-var OrganizationSettingsServerStrict = z40.object(organizationSettingsFields).strict();
-var OrganizationSettingsClientReadCompat = z40.object(organizationSettingsFields).passthrough();
+var OrganizationSettingsServerStrict = z41.object(organizationSettingsFields).strict();
+var OrganizationSettingsClientReadCompat = z41.object(organizationSettingsFields).passthrough();
 // ../../packages/protocol/src/project-settings.ts
-import { z as z41 } from "zod";
+import { z as z42 } from "zod";
 var projectSettingsFields = {
   runtimeEnv: RuntimeEnvRecord.optional(),
   runtimeEnvRefs: RuntimeEnvRefsPersistCompat.optional()
 };
-var ProjectSettingsServerStrict = z41.object(projectSettingsFields).strict();
-var ProjectSettingsClientReadCompat = z41.object({
+var ProjectSettingsServerStrict = z42.object(projectSettingsFields).strict();
+var ProjectSettingsClientReadCompat = z42.object({
   ...projectSettingsFields,
   runtimeEnvRefs: RuntimeEnvRefsReadCompat.optional()
 }).passthrough();
 // ../../packages/protocol/src/prompt-directive.ts
-import { z as z42 } from "zod";
+import { z as z43 } from "zod";
 var TASK_SLUG_RE = /^[A-Za-z0-9._-]+$/;
-var TaskSlug = z42.string().min(1).max(128).regex(TASK_SLUG_RE, {
+var TaskSlug = z43.string().min(1).max(128).regex(TASK_SLUG_RE, {
   message: "linkedTaskSlug must match [A-Za-z0-9._-]+ (no `/`, `\\`, or path segments)"
 }).refine((s) => !s.includes(".."), {
   message: "linkedTaskSlug must not contain `..`"
 });
-var PromptDirective = z42.object({
+var PromptDirective = z43.object({
   agentProfileId: Id,
   contextPolicy: ContextPolicy,
-  basePersonaMd: z42.string(),
+  basePersonaMd: z43.string(),
   channelId: Id,
-  triggerEventSeq: z42.number().int().nonnegative(),
-  channelHistoryStart: z42.number().int().positive().nullable().optional(),
+  triggerEventSeq: z43.number().int().nonnegative(),
+  channelHistoryStart: z43.number().int().positive().nullable().optional(),
   linkedTaskId: Id.nullable(),
-  linkedTaskTrellisId: z42.string().min(1).nullable(),
+  linkedTaskTrellisId: z43.string().min(1).nullable(),
   linkedTaskSlug: TaskSlug.nullable(),
-  priorSessionId: z42.string().min(1).nullable(),
-  channelHistoryLimitOverride: z42.number().int().positive().nullable()
+  priorSessionId: z43.string().min(1).nullable(),
+  channelHistoryLimitOverride: z43.number().int().positive().nullable()
 }).strict();
 // ../../packages/protocol/src/runtime-provider-ui.ts
 var RUNTIME_PROVIDER_UI_DESCRIPTORS = {
@@ -6614,8 +6672,8 @@ var RUNTIME_PROVIDER_UI_DESCRIPTORS = {
 };
 var RUNTIME_PROVIDER_UI_DESCRIPTOR_LIST = RUNTIME_PROVIDER_KINDS.map((kind) => RUNTIME_PROVIDER_UI_DESCRIPTORS[kind]);
 // ../../packages/protocol/src/vine-cli.ts
-import { z as z43 } from "zod";
-var VineCliCommandName = z43.enum([
+import { z as z44 } from "zod";
+var VineCliCommandName = z44.enum([
   "task.update_prd",
   "task.update_design",
   "task.update_implement",
@@ -6623,55 +6681,55 @@ var VineCliCommandName = z43.enum([
   "task.update_status",
   "task.ask"
 ]);
-var VineCliTaskUpdateArgs = z43.object({
-  task_id: z43.string().min(1),
-  content: z43.string(),
-  expected_version: z43.number().int().optional()
+var VineCliTaskUpdateArgs = z44.object({
+  task_id: z44.string().min(1),
+  content: z44.string(),
+  expected_version: z44.number().int().optional()
 });
-var VineCliTaskUpdatePrdCommand = z43.object({
-  command: z43.literal("task.update_prd"),
+var VineCliTaskUpdatePrdCommand = z44.object({
+  command: z44.literal("task.update_prd"),
   args: VineCliTaskUpdateArgs
 });
-var VineCliTaskUpdateDesignCommand = z43.object({
-  command: z43.literal("task.update_design"),
+var VineCliTaskUpdateDesignCommand = z44.object({
+  command: z44.literal("task.update_design"),
   args: VineCliTaskUpdateArgs
 });
-var VineCliTaskUpdateImplementCommand = z43.object({
-  command: z43.literal("task.update_implement"),
+var VineCliTaskUpdateImplementCommand = z44.object({
+  command: z44.literal("task.update_implement"),
   args: VineCliTaskUpdateArgs
 });
-var VineCliTaskCreateArgs = z43.object({
-  title: z43.string().min(1),
-  trellis_id: z43.string().min(1).optional(),
+var VineCliTaskCreateArgs = z44.object({
+  title: z44.string().min(1),
+  trellis_id: z44.string().min(1).optional(),
   status: TaskStatus.optional(),
-  priority: z43.string().min(1).nullable().optional(),
-  prd_md: z43.string().optional(),
-  design_md: z43.string().optional(),
-  implement_md: z43.string().optional()
+  priority: z44.string().min(1).nullable().optional(),
+  prd_md: z44.string().optional(),
+  design_md: z44.string().optional(),
+  implement_md: z44.string().optional()
 });
-var VineCliTaskCreateCommand = z43.object({
-  command: z43.literal("task.create"),
+var VineCliTaskCreateCommand = z44.object({
+  command: z44.literal("task.create"),
   args: VineCliTaskCreateArgs
 });
-var VineCliTaskStatusUpdateArgs = z43.object({
+var VineCliTaskStatusUpdateArgs = z44.object({
   status: TaskStatus,
-  expected_version: z43.number().int().optional()
+  expected_version: z44.number().int().optional()
 });
-var VineCliTaskStatusUpdateCommand = z43.object({
-  command: z43.literal("task.update_status"),
+var VineCliTaskStatusUpdateCommand = z44.object({
+  command: z44.literal("task.update_status"),
   args: VineCliTaskStatusUpdateArgs
 });
-var VineCliAskArgs = z43.object({
-  questions: z43.array(AgentQuestionSpec).min(1)
+var VineCliAskArgs = z44.object({
+  questions: z44.array(AgentQuestionSpec).min(1)
 });
-var VineCliAskCommand = z43.object({
-  command: z43.literal("task.ask"),
+var VineCliAskCommand = z44.object({
+  command: z44.literal("task.ask"),
   args: VineCliAskArgs
 });
-var VineCliAskOkBody = z43.object({
-  ticket: z43.string().min(1)
+var VineCliAskOkBody = z44.object({
+  ticket: z44.string().min(1)
 });
-var VineCliCommand = z43.discriminatedUnion("command", [
+var VineCliCommand = z44.discriminatedUnion("command", [
   VineCliTaskUpdatePrdCommand,
   VineCliTaskUpdateDesignCommand,
   VineCliTaskUpdateImplementCommand,
@@ -6693,41 +6751,42 @@ var TASK_DOC_WRITEBACK = {
     invocation: "vine task update-implement"
   }
 };
-var VineCliRequest = z43.object({
-  request_id: z43.string().min(1),
-  cli_version: z43.string().min(1).optional(),
+var VineCliRequest = z44.object({
+  request_id: z44.string().min(1),
+  cli_version: z44.string().min(1).optional(),
   command: VineCliCommandName,
-  args: z43.record(z43.string(), z43.unknown())
-});
-var VineCliTaskUpdateOkBody = z43.object({
-  task_id: z43.string().min(1),
-  version: z43.number().int()
-});
-var VineCliTaskCreateOkBody = z43.object({
-  task_id: z43.string().min(1),
-  trellis_id: z43.string().min(1),
-  version: z43.number().int(),
-  channel_id: z43.string().min(1),
-  project_id: z43.string().min(1),
-  status: TaskStatus
+  args: z44.record(z44.string(), z44.unknown())
+});
+var VineCliTaskUpdateOkBody = z44.object({
+  task_id: z44.string().min(1),
+  version: z44.number().int()
 });
-var VineCliTaskStatusUpdateOkBody = z43.object({
-  task_id: z43.string().min(1),
-  version: z43.number().int(),
+var VineCliTaskCreateOkBody = z44.object({
+  task_id: z44.string().min(1),
+  trellis_id: z44.string().min(1),
+  version: z44.number().int(),
+  channel_id: z44.string().min(1),
+  project_id: z44.string().min(1),
+  status: TaskStatus,
+  work_branches: z44.array(TaskWorkBranchTarget).optional()
+});
+var VineCliTaskStatusUpdateOkBody = z44.object({
+  task_id: z44.string().min(1),
+  version: z44.number().int(),
   status: TaskStatus
 });
-var VineCliErrorBody = z43.object({
-  code: z43.string().min(1),
-  message: z43.string().min(1)
+var VineCliErrorBody = z44.object({
+  code: z44.string().min(1),
+  message: z44.string().min(1)
 });
-var VineCliResponse = z43.object({
-  request_id: z43.string().min(1),
-  status: z43.enum(["ok", "error", "conflict"]),
-  body: z43.unknown().optional(),
+var VineCliResponse = z44.object({
+  request_id: z44.string().min(1),
+  status: z44.enum(["ok", "error", "conflict"]),
+  body: z44.unknown().optional(),
   error: VineCliErrorBody.optional()
 });
 // ../../packages/protocol/src/ws-manager-runner.ts
-import { z as z44 } from "zod";
+import { z as z45 } from "zod";
 var RunnerKind = RuntimeRunnerKind;
 var RunnerBackendKind = RuntimeAgentBackendKind;
 var RUNNER_CAPABILITY_TERMINAL = "terminal";
@@ -6742,18 +6801,18 @@ function runnerSupportsPromptUserLayers(capabilities) {
 function runnerSupportsServicePortProxy(capabilities) {
   return capabilities?.includes(RUNNER_CAPABILITY_SERVICE_PORT_PROXY) ?? false;
 }
-var RunnerHelloPayload = z44.object({
-  session_token: z44.string().min(1),
-  session_id: z44.string().min(1),
+var RunnerHelloPayload = z45.object({
+  session_token: z45.string().min(1),
+  session_id: z45.string().min(1),
   runner_kind: RunnerKind,
-  runner_version: z44.string(),
-  pid: z44.number().int(),
-  capabilities: z44.array(z44.string()).default([])
+  runner_version: z45.string(),
+  pid: z45.number().int(),
+  capabilities: z45.array(z45.string()).default([])
 });
-var RunnerReadyPayload = z44.object({
-  session_id: z44.string().min(1)
+var RunnerReadyPayload = z45.object({
+  session_id: z45.string().min(1)
 });
-var TurnEventKind = z44.enum([
+var TurnEventKind = z45.enum([
   "text_delta",
   "tool_call",
   "tool_result",
@@ -6761,359 +6820,359 @@ var TurnEventKind = z44.enum([
   "error",
   "meta"
 ]);
-var TurnEventPayload = z44.object({
-  turn_id: z44.string().min(1),
-  session_id: z44.string().min(1),
+var TurnEventPayload = z45.object({
+  turn_id: z45.string().min(1),
+  session_id: z45.string().min(1),
   kind: TurnEventKind,
-  data: z44.record(z44.string(), z44.unknown())
+  data: z45.record(z45.string(), z45.unknown())
 });
-var TurnFinishedStatus = z44.enum([
+var TurnFinishedStatus = z45.enum([
   "completed",
   "failed",
   "cancelled",
   "resume_failed"
 ]);
-var TurnFinishedPayload = z44.object({
-  turn_id: z44.string().min(1),
-  session_id: z44.string().min(1),
+var TurnFinishedPayload = z45.object({
+  turn_id: z45.string().min(1),
+  session_id: z45.string().min(1),
   status: TurnFinishedStatus,
-  exit_code: z44.number().int().nullable(),
-  external_session_id: z44.string().nullable(),
-  final_text: z44.string(),
-  failure_detail: z44.string().nullable(),
-  attempted_external_session_id: z44.string().nullable().optional(),
+  exit_code: z45.number().int().nullable(),
+  external_session_id: z45.string().nullable(),
+  final_text: z45.string(),
+  failure_detail: z45.string().nullable(),
+  attempted_external_session_id: z45.string().nullable().optional(),
   prompt_context_summary: PromptContextSummary.nullable().optional()
 });
-var HelloAckPayload = z44.object({
-  session_id: z44.string().min(1),
-  result: z44.enum(["accepted", "rejected"]),
-  reason: z44.string().optional()
+var HelloAckPayload = z45.object({
+  session_id: z45.string().min(1),
+  result: z45.enum(["accepted", "rejected"]),
+  reason: z45.string().optional()
 });
-var TurnStartPayload = z44.object({
-  turn_id: z44.string().min(1),
-  session_id: z44.string().min(1),
+var TurnStartPayload = z45.object({
+  turn_id: z45.string().min(1),
+  session_id: z45.string().min(1),
   backend_kind: RunnerBackendKind,
-  prompt: z44.string(),
+  prompt: z45.string(),
   prompt_context: PromptContext.default(EMPTY_PROMPT_CONTEXT),
-  model: z44.string().nullable(),
-  external_session_id: z44.string().nullable(),
-  env_overrides: z44.record(z44.string(), z44.string()).default({}),
-  skills: z44.array(TurnSkillBundle).default([]),
-  cwd: z44.string().min(1),
-  repo_path: z44.string().min(1).nullable().default(null)
-});
-var TurnCancelPayload = z44.object({
-  turn_id: z44.string().min(1),
-  session_id: z44.string().min(1),
-  reason: z44.string()
-});
-var SessionPrepareReleasePayload = z44.object({
-  session_id: z44.string().min(1)
-});
-var SessionDirtyReportPayload = z44.object({
-  session_id: z44.string().min(1),
-  repo_present: z44.boolean(),
-  dirty: z44.boolean(),
-  dirty_files: z44.number().int().nonnegative()
-});
-var RunnerBootFailedPayload = z44.object({
-  session_id: z44.string().min(1),
-  last_error: z44.string()
-});
-var CliRequestPayload = z44.object({
-  request_id: z44.string().min(1),
-  command: z44.string().min(1),
-  args: z44.record(z44.string(), z44.unknown()),
-  cli_version: z44.string().min(1).optional()
+  model: z45.string().nullable(),
+  external_session_id: z45.string().nullable(),
+  env_overrides: z45.record(z45.string(), z45.string()).default({}),
+  skills: z45.array(TurnSkillBundle).default([]),
+  cwd: z45.string().min(1),
+  repo_path: z45.string().min(1).nullable().default(null)
+});
+var TurnCancelPayload = z45.object({
+  turn_id: z45.string().min(1),
+  session_id: z45.string().min(1),
+  reason: z45.string()
+});
+var SessionPrepareReleasePayload = z45.object({
+  session_id: z45.string().min(1)
+});
+var SessionDirtyReportPayload = z45.object({
+  session_id: z45.string().min(1),
+  repo_present: z45.boolean(),
+  dirty: z45.boolean(),
+  dirty_files: z45.number().int().nonnegative()
+});
+var RunnerBootFailedPayload = z45.object({
+  session_id: z45.string().min(1),
+  last_error: z45.string()
+});
+var CliRequestPayload = z45.object({
+  request_id: z45.string().min(1),
+  command: z45.string().min(1),
+  args: z45.record(z45.string(), z45.unknown()),
+  cli_version: z45.string().min(1).optional()
 });
 var RunnerTaskRefsSnapshotPayload = TaskRefsSnapshotPayload;
-var CliResponsePayload = z44.object({
-  request_id: z44.string().min(1),
-  status: z44.enum(["ok", "error", "conflict"]),
-  body: z44.unknown().optional(),
-  error: z44.object({
-    code: z44.string().min(1),
-    message: z44.string().min(1)
+var CliResponsePayload = z45.object({
+  request_id: z45.string().min(1),
+  status: z45.enum(["ok", "error", "conflict"]),
+  body: z45.unknown().optional(),
+  error: z45.object({
+    code: z45.string().min(1),
+    message: z45.string().min(1)
   }).optional()
 });
-var TaskProjectionPushPayload = z44.object({
-  task_id: z44.string().min(1),
-  trellis_id: z44.string().min(1),
-  project_id: z44.string().min(1),
-  version: z44.number().int(),
-  title: z44.string(),
+var TaskProjectionPushPayload = z45.object({
+  task_id: z45.string().min(1),
+  trellis_id: z45.string().min(1),
+  project_id: z45.string().min(1),
+  version: z45.number().int(),
+  title: z45.string(),
   status: TaskStatus,
-  prd_md: z44.string(),
-  design_md: z44.string(),
-  implement_md: z44.string()
-});
-var RunnerPingPayload = z44.object({
-  session_id: z44.string().min(1)
-});
-var ManagerPongPayload = z44.object({
-  session_id: z44.string().min(1)
-});
-var TerminalOpenPayload = z44.object({
-  session_id: z44.string().min(1),
-  terminal_session_id: z44.string().min(1),
-  cols: z44.number().int().positive(),
-  rows: z44.number().int().positive()
-});
-var TerminalInputPayload = z44.object({
-  session_id: z44.string().min(1),
-  terminal_session_id: z44.string().min(1),
-  data: z44.string()
-});
-var TerminalResizePayload = z44.object({
-  session_id: z44.string().min(1),
-  terminal_session_id: z44.string().min(1),
-  cols: z44.number().int().positive(),
-  rows: z44.number().int().positive()
-});
-var TerminalDataPayload = z44.object({
-  session_id: z44.string().min(1),
-  terminal_session_id: z44.string().min(1),
-  data_base64: z44.string(),
-  seq: z44.number().int().min(1)
-});
-var TerminalCloseRequestPayload = z44.object({
-  session_id: z44.string().min(1),
-  terminal_session_id: z44.string().min(1),
-  reason: z44.string().optional()
-});
-var TerminalCloseReportPayload = z44.object({
-  session_id: z44.string().min(1),
-  terminal_session_id: z44.string().min(1),
-  reason: z44.string().optional(),
-  exit_code: z44.number().int().optional(),
-  signal: z44.string().optional(),
-  final_seq: z44.number().int().nonnegative().optional()
-});
-var ManagerRunnerServicePortHttpProtocol = z44.enum(["http", "https"]);
-var ManagerRunnerServicePortHeaderBag = z44.record(z44.string(), z44.string());
-var ServicePortHttpRequestPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  target_host: z44.string().min(1),
-  target_port: z44.number().int().min(1).max(65535),
+  prd_md: z45.string(),
+  design_md: z45.string(),
+  implement_md: z45.string()
+});
+var RunnerPingPayload = z45.object({
+  session_id: z45.string().min(1)
+});
+var ManagerPongPayload = z45.object({
+  session_id: z45.string().min(1)
+});
+var TerminalOpenPayload = z45.object({
+  session_id: z45.string().min(1),
+  terminal_session_id: z45.string().min(1),
+  cols: z45.number().int().positive(),
+  rows: z45.number().int().positive()
+});
+var TerminalInputPayload = z45.object({
+  session_id: z45.string().min(1),
+  terminal_session_id: z45.string().min(1),
+  data: z45.string()
+});
+var TerminalResizePayload = z45.object({
+  session_id: z45.string().min(1),
+  terminal_session_id: z45.string().min(1),
+  cols: z45.number().int().positive(),
+  rows: z45.number().int().positive()
+});
+var TerminalDataPayload = z45.object({
+  session_id: z45.string().min(1),
+  terminal_session_id: z45.string().min(1),
+  data_base64: z45.string(),
+  seq: z45.number().int().min(1)
+});
+var TerminalCloseRequestPayload = z45.object({
+  session_id: z45.string().min(1),
+  terminal_session_id: z45.string().min(1),
+  reason: z45.string().optional()
+});
+var TerminalCloseReportPayload = z45.object({
+  session_id: z45.string().min(1),
+  terminal_session_id: z45.string().min(1),
+  reason: z45.string().optional(),
+  exit_code: z45.number().int().optional(),
+  signal: z45.string().optional(),
+  final_seq: z45.number().int().nonnegative().optional()
+});
+var ManagerRunnerServicePortHttpProtocol = z45.enum(["http", "https"]);
+var ManagerRunnerServicePortHeaderBag = z45.record(z45.string(), z45.string());
+var ServicePortHttpRequestPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  target_host: z45.string().min(1),
+  target_port: z45.number().int().min(1).max(65535),
   protocol: ManagerRunnerServicePortHttpProtocol,
-  method: z44.string().min(1),
-  path: z44.string().min(1),
+  method: z45.string().min(1),
+  path: z45.string().min(1),
   headers: ManagerRunnerServicePortHeaderBag.default({}),
-  body_base64: z44.string().nullable().default(null)
+  body_base64: z45.string().nullable().default(null)
 });
-var ServicePortHttpCancelPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  reason: z44.string().optional()
+var ServicePortHttpCancelPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  reason: z45.string().optional()
 });
-var ServicePortHttpResponseStartPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  status: z44.number().int().min(100).max(599),
+var ServicePortHttpResponseStartPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  status: z45.number().int().min(100).max(599),
   headers: ManagerRunnerServicePortHeaderBag.default({})
 });
-var ServicePortHttpBodyPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  body_base64: z44.string()
+var ServicePortHttpBodyPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  body_base64: z45.string()
 });
-var ServicePortHttpEndPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1)
+var ServicePortHttpEndPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1)
 });
-var ServicePortHttpErrorPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  reason: z44.enum([
+var ServicePortHttpErrorPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  reason: z45.enum([
     "runner_unsupported",
     "session_unavailable",
     "port_unavailable",
     "proxy_failed",
     "invalid_target"
   ]),
-  message: z44.string().optional()
+  message: z45.string().optional()
 });
-var ServicePortWsOpenPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  target_host: z44.string().min(1),
-  target_port: z44.number().int().min(1).max(65535),
+var ServicePortWsOpenPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  target_host: z45.string().min(1),
+  target_port: z45.number().int().min(1).max(65535),
   protocol: ManagerRunnerServicePortHttpProtocol,
-  path: z44.string().min(1),
+  path: z45.string().min(1),
   headers: ManagerRunnerServicePortHeaderBag.default({})
 });
-var ServicePortWsDataPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  data_base64: z44.string(),
-  is_binary: z44.boolean().default(false)
-});
-var ServicePortWsClosePayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  code: z44.number().int().min(1000).max(4999).optional(),
-  reason: z44.string().optional()
-});
-var ServicePortWsOpenedPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1)
-});
-var ServicePortWsErrorPayload = z44.object({
-  session_id: z44.string().min(1),
-  proxy_request_id: z44.string().min(1),
-  reason: z44.enum([
+var ServicePortWsDataPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  data_base64: z45.string(),
+  is_binary: z45.boolean().default(false)
+});
+var ServicePortWsClosePayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  code: z45.number().int().min(1000).max(4999).optional(),
+  reason: z45.string().optional()
+});
+var ServicePortWsOpenedPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1)
+});
+var ServicePortWsErrorPayload = z45.object({
+  session_id: z45.string().min(1),
+  proxy_request_id: z45.string().min(1),
+  reason: z45.enum([
     "runner_unsupported",
     "session_unavailable",
     "port_unavailable",
     "proxy_failed",
     "invalid_target"
   ]),
-  message: z44.string().optional()
-});
-var RunnerToManagerMessage = z44.discriminatedUnion("type", [
-  z44.object({ type: z44.literal("runner.hello"), payload: RunnerHelloPayload }),
-  z44.object({ type: z44.literal("runner.ready"), payload: RunnerReadyPayload }),
-  z44.object({ type: z44.literal("turn.event"), payload: TurnEventPayload }),
-  z44.object({ type: z44.literal("turn.finished"), payload: TurnFinishedPayload }),
-  z44.object({
-    type: z44.literal("session.dirty_report"),
+  message: z45.string().optional()
+});
+var RunnerToManagerMessage = z45.discriminatedUnion("type", [
+  z45.object({ type: z45.literal("runner.hello"), payload: RunnerHelloPayload }),
+  z45.object({ type: z45.literal("runner.ready"), payload: RunnerReadyPayload }),
+  z45.object({ type: z45.literal("turn.event"), payload: TurnEventPayload }),
+  z45.object({ type: z45.literal("turn.finished"), payload: TurnFinishedPayload }),
+  z45.object({
+    type: z45.literal("session.dirty_report"),
     payload: SessionDirtyReportPayload
   }),
-  z44.object({
-    type: z44.literal("runner.boot_failed"),
+  z45.object({
+    type: z45.literal("runner.boot_failed"),
     payload: RunnerBootFailedPayload
   }),
-  z44.object({ type: z44.literal("cli.request"), payload: CliRequestPayload }),
-  z44.object({
-    type: z44.literal("task.refs_snapshot"),
+  z45.object({ type: z45.literal("cli.request"), payload: CliRequestPayload }),
+  z45.object({
+    type: z45.literal("task.refs_snapshot"),
     payload: RunnerTaskRefsSnapshotPayload
   }),
-  z44.object({ type: z44.literal("runner.ping"), payload: RunnerPingPayload }),
-  z44.object({ type: z44.literal("terminal.data"), payload: TerminalDataPayload }),
-  z44.object({
-    type: z44.literal("terminal.close"),
+  z45.object({ type: z45.literal("runner.ping"), payload: RunnerPingPayload }),
+  z45.object({ type: z45.literal("terminal.data"), payload: TerminalDataPayload }),
+  z45.object({
+    type: z45.literal("terminal.close"),
     payload: TerminalCloseReportPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.http.response_start"),
+  z45.object({
+    type: z45.literal("service_port.http.response_start"),
     payload: ServicePortHttpResponseStartPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.http.body"),
+  z45.object({
+    type: z45.literal("service_port.http.body"),
     payload: ServicePortHttpBodyPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.http.end"),
+  z45.object({
+    type: z45.literal("service_port.http.end"),
     payload: ServicePortHttpEndPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.http.error"),
+  z45.object({
+    type: z45.literal("service_port.http.error"),
     payload: ServicePortHttpErrorPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.opened"),
+  z45.object({
+    type: z45.literal("service_port.ws.opened"),
     payload: ServicePortWsOpenedPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.data"),
+  z45.object({
+    type: z45.literal("service_port.ws.data"),
     payload: ServicePortWsDataPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.close"),
+  z45.object({
+    type: z45.literal("service_port.ws.close"),
     payload: ServicePortWsClosePayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.error"),
+  z45.object({
+    type: z45.literal("service_port.ws.error"),
     payload: ServicePortWsErrorPayload
   })
 ]);
-var ManagerToRunnerMessage = z44.discriminatedUnion("type", [
-  z44.object({ type: z44.literal("hello.ack"), payload: HelloAckPayload }),
-  z44.object({ type: z44.literal("turn.start"), payload: TurnStartPayload }),
-  z44.object({ type: z44.literal("turn.cancel"), payload: TurnCancelPayload }),
-  z44.object({ type: z44.literal("cli.response"), payload: CliResponsePayload }),
-  z44.object({
-    type: z44.literal("task.projection_push"),
+var ManagerToRunnerMessage = z45.discriminatedUnion("type", [
+  z45.object({ type: z45.literal("hello.ack"), payload: HelloAckPayload }),
+  z45.object({ type: z45.literal("turn.start"), payload: TurnStartPayload }),
+  z45.object({ type: z45.literal("turn.cancel"), payload: TurnCancelPayload }),
+  z45.object({ type: z45.literal("cli.response"), payload: CliResponsePayload }),
+  z45.object({
+    type: z45.literal("task.projection_push"),
     payload: TaskProjectionPushPayload
   }),
-  z44.object({
-    type: z44.literal("session.prepare_release"),
+  z45.object({
+    type: z45.literal("session.prepare_release"),
     payload: SessionPrepareReleasePayload
   }),
-  z44.object({ type: z44.literal("manager.pong"), payload: ManagerPongPayload }),
-  z44.object({ type: z44.literal("terminal.open"), payload: TerminalOpenPayload }),
-  z44.object({
-    type: z44.literal("terminal.input"),
+  z45.object({ type: z45.literal("manager.pong"), payload: ManagerPongPayload }),
+  z45.object({ type: z45.literal("terminal.open"), payload: TerminalOpenPayload }),
+  z45.object({
+    type: z45.literal("terminal.input"),
     payload: TerminalInputPayload
   }),
-  z44.object({
-    type: z44.literal("terminal.resize"),
+  z45.object({
+    type: z45.literal("terminal.resize"),
     payload: TerminalResizePayload
   }),
-  z44.object({
-    type: z44.literal("terminal.close"),
+  z45.object({
+    type: z45.literal("terminal.close"),
     payload: TerminalCloseRequestPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.http.request"),
+  z45.object({
+    type: z45.literal("service_port.http.request"),
     payload: ServicePortHttpRequestPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.http.cancel"),
+  z45.object({
+    type: z45.literal("service_port.http.cancel"),
     payload: ServicePortHttpCancelPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.open"),
+  z45.object({
+    type: z45.literal("service_port.ws.open"),
     payload: ServicePortWsOpenPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.data"),
+  z45.object({
+    type: z45.literal("service_port.ws.data"),
     payload: ServicePortWsDataPayload
   }),
-  z44.object({
-    type: z44.literal("service_port.ws.close"),
+  z45.object({
+    type: z45.literal("service_port.ws.close"),
     payload: ServicePortWsClosePayload
   })
 ]);
 // ../../packages/protocol/src/ws-server-to-web.ts
-import { z as z45 } from "zod";
+import { z as z46 } from "zod";
 var SUBSCRIBABLE_SCOPE_KEY_REGEX = /^channel:[a-zA-Z0-9_-]+$/;
-var WebClientSubscribeFrame = z45.object({
-  type: z45.literal("subscribe"),
-  scopeKey: z45.string().regex(SUBSCRIBABLE_SCOPE_KEY_REGEX)
+var WebClientSubscribeFrame = z46.object({
+  type: z46.literal("subscribe"),
+  scopeKey: z46.string().regex(SUBSCRIBABLE_SCOPE_KEY_REGEX)
 });
-var WebClientUnsubscribeFrame = z45.object({
-  type: z45.literal("unsubscribe"),
-  scopeKey: z45.string().regex(SUBSCRIBABLE_SCOPE_KEY_REGEX)
+var WebClientUnsubscribeFrame = z46.object({
+  type: z46.literal("unsubscribe"),
+  scopeKey: z46.string().regex(SUBSCRIBABLE_SCOPE_KEY_REGEX)
 });
-var WebClientPingFrame = z45.object({
-  type: z45.literal("ping")
+var WebClientPingFrame = z46.object({
+  type: z46.literal("ping")
 });
-var WebClientTerminalOpenFrame = z45.object({
-  type: z45.literal("terminal.open"),
+var WebClientTerminalOpenFrame = z46.object({
+  type: z46.literal("terminal.open"),
   channelId: Id,
   terminalSessionId: Id,
-  cols: z45.number().int().positive(),
-  rows: z45.number().int().positive()
+  cols: z46.number().int().positive(),
+  rows: z46.number().int().positive()
 });
-var WebClientTerminalInputFrame = z45.object({
-  type: z45.literal("terminal.input"),
+var WebClientTerminalInputFrame = z46.object({
+  type: z46.literal("terminal.input"),
   terminalSessionId: Id,
-  data: z45.string()
+  data: z46.string()
 });
-var WebClientTerminalResizeFrame = z45.object({
-  type: z45.literal("terminal.resize"),
+var WebClientTerminalResizeFrame = z46.object({
+  type: z46.literal("terminal.resize"),
   terminalSessionId: Id,
-  cols: z45.number().int().positive(),
-  rows: z45.number().int().positive()
+  cols: z46.number().int().positive(),
+  rows: z46.number().int().positive()
 });
-var WebClientTerminalCloseFrame = z45.object({
-  type: z45.literal("terminal.close"),
+var WebClientTerminalCloseFrame = z46.object({
+  type: z46.literal("terminal.close"),
   terminalSessionId: Id,
-  reason: z45.string().optional()
+  reason: z46.string().optional()
 });
-var WebClientFrame = z45.discriminatedUnion("type", [
+var WebClientFrame = z46.discriminatedUnion("type", [
   WebClientSubscribeFrame,
   WebClientUnsubscribeFrame,
   WebClientPingFrame,
@@ -7122,106 +7181,106 @@ var WebClientFrame = z45.discriminatedUnion("type", [
   WebClientTerminalResizeFrame,
   WebClientTerminalCloseFrame
 ]);
-var WebServerSubscribedFrame = z45.object({
-  type: z45.literal("subscribed"),
-  scopeKey: z45.string().regex(SUBSCRIBABLE_SCOPE_KEY_REGEX)
+var WebServerSubscribedFrame = z46.object({
+  type: z46.literal("subscribed"),
+  scopeKey: z46.string().regex(SUBSCRIBABLE_SCOPE_KEY_REGEX)
 });
-var WebServerMessageCreatedFrame = z45.object({
-  type: z45.literal("message.created"),
+var WebServerMessageCreatedFrame = z46.object({
+  type: z46.literal("message.created"),
   channelId: Id,
   threadId: Id.nullable(),
-  message: z45.unknown()
+  message: z46.unknown()
 });
-var WebServerMessageChangedFrame = z45.object({
-  type: z45.literal("message.changed"),
+var WebServerMessageChangedFrame = z46.object({
+  type: z46.literal("message.changed"),
   channelId: Id,
   threadId: Id.nullable(),
-  message: z45.unknown()
+  message: z46.unknown()
 });
-var WebServerTurnStatusFrame = z45.object({
-  type: z45.literal("turn.status"),
+var WebServerTurnStatusFrame = z46.object({
+  type: z46.literal("turn.status"),
   channelId: Id,
   threadId: Id.nullable(),
   agentTurnId: Id,
   agentProfileId: Id,
   status: AgentTurnStatus,
-  errorCode: z45.string().optional(),
-  failureDetail: z45.string().optional()
+  errorCode: z46.string().optional(),
+  failureDetail: z46.string().optional()
 });
-var WebServerTurnDeltaFrame = z45.object({
-  type: z45.literal("turn.delta"),
+var WebServerTurnDeltaFrame = z46.object({
+  type: z46.literal("turn.delta"),
   channelId: Id,
   threadId: Id.nullable(),
   agentTurnId: Id,
   agentProfileId: Id,
-  textDelta: z45.string(),
-  seq: z45.number().int().min(1)
+  textDelta: z46.string(),
+  seq: z46.number().int().min(1)
 });
-var AgentTurnPhase = z45.enum([
+var AgentTurnPhase = z46.enum([
   "provisioning_runtime",
   "starting_runner",
   "starting_agent",
   "awaiting_first_token",
   "thinking"
 ]);
-var WebServerTurnPhaseFrame = z45.object({
-  type: z45.literal("turn.phase"),
+var WebServerTurnPhaseFrame = z46.object({
+  type: z46.literal("turn.phase"),
   channelId: Id,
   threadId: Id.nullable(),
   agentTurnId: Id,
   agentProfileId: Id,
   phase: AgentTurnPhase
 });
-var WebServerRuntimeManagersChangedFrame = z45.object({
-  type: z45.literal("runtime.managers.changed"),
+var WebServerRuntimeManagersChangedFrame = z46.object({
+  type: z46.literal("runtime.managers.changed"),
   organizationId: Id
 });
-var WebServerTaskChangedFrame = z45.object({
-  type: z45.literal("task.changed"),
+var WebServerTaskChangedFrame = z46.object({
+  type: z46.literal("task.changed"),
   channelId: Id,
   taskId: Id,
-  version: z45.number().int()
+  version: z46.number().int()
 });
-var WebServerTaskCollectionChangedFrame = z45.object({
-  type: z45.literal("task.collection.changed"),
+var WebServerTaskCollectionChangedFrame = z46.object({
+  type: z46.literal("task.collection.changed"),
   organizationId: Id,
   projectId: Id,
   taskId: Id,
-  version: z45.number().int()
+  version: z46.number().int()
 });
-var WebServerInboxEntryCreatedFrame = z45.object({
-  type: z45.literal("inbox.entry.created"),
+var WebServerInboxEntryCreatedFrame = z46.object({
+  type: z46.literal("inbox.entry.created"),
   entry: InboxEntryDto
 });
-var WebServerInboxEntryReadFrame = z45.object({
-  type: z45.literal("inbox.entry.read"),
-  ids: z45.array(Id)
+var WebServerInboxEntryReadFrame = z46.object({
+  type: z46.literal("inbox.entry.read"),
+  ids: z46.array(Id)
 });
-var WebServerTerminalDataFrame = z45.object({
-  type: z45.literal("terminal.data"),
+var WebServerTerminalDataFrame = z46.object({
+  type: z46.literal("terminal.data"),
   channelId: Id,
   terminalSessionId: Id,
-  dataBase64: z45.string(),
-  seq: z45.number().int().min(1)
+  dataBase64: z46.string(),
+  seq: z46.number().int().min(1)
 });
-var WebServerTerminalCloseFrame = z45.object({
-  type: z45.literal("terminal.close"),
+var WebServerTerminalCloseFrame = z46.object({
+  type: z46.literal("terminal.close"),
   channelId: Id,
   terminalSessionId: Id,
-  reason: z45.string().optional(),
-  exitCode: z45.number().int().optional(),
-  signal: z45.string().optional(),
-  finalSeq: z45.number().int().nonnegative().optional()
+  reason: z46.string().optional(),
+  exitCode: z46.number().int().optional(),
+  signal: z46.string().optional(),
+  finalSeq: z46.number().int().nonnegative().optional()
 });
-var WebServerPongFrame = z45.object({
-  type: z45.literal("pong")
+var WebServerPongFrame = z46.object({
+  type: z46.literal("pong")
 });
-var WebServerErrorFrame = z45.object({
-  type: z45.literal("error"),
-  message: z45.string(),
-  code: z45.string().optional()
+var WebServerErrorFrame = z46.object({
+  type: z46.literal("error"),
+  message: z46.string(),
+  code: z46.string().optional()
 });
-var WebServerFrame = z45.discriminatedUnion("type", [
+var WebServerFrame = z46.discriminatedUnion("type", [
   WebServerSubscribedFrame,
   WebServerMessageCreatedFrame,
   WebServerMessageChangedFrame,
@@ -8217,7 +8276,8 @@ async function handleTaskCreateCommand(input, command, deps) {
     const bound = deps.applyCreatedTaskBinding({
       sessionId: input.sessionId,
       projectId: result.project_id,
-      taskId: result.task_id
+      taskId: result.task_id,
+      workBranches: result.work_branches ?? []
     });
     if (!bound) {
       return errorResponse2(input.request.request_id, "RUNTIME_SESSION_NOT_FOUND", "runtime session disappeared before task binding was applied");
@@ -8231,7 +8291,8 @@ async function handleTaskCreateCommand(input, command, deps) {
         version: result.version,
         channel_id: result.channel_id,
         project_id: result.project_id,
-        status: result.task_status
+        status: result.task_status,
+        ...result.work_branches && result.work_branches.length > 0 ? { work_branches: result.work_branches } : {}
       }
     };
   }
@@ -11048,7 +11109,7 @@ class SessionLifecycle {
       repoPath: join8(workspaceRoot, "repos", r.repo_slug),
       repoRemote: r.remote_url,
       repoBranch: r.default_branch,
-      workBranch: runtimeWorkBranch({
+      workBranch: r.work_branch ?? runtimeWorkBranch({
         taskId: spec.task_id,
         sessionId,
         repoSlug: r.repo_slug
@@ -13386,7 +13447,12 @@ class RuntimeManager {
           taskId: session.taskId
         } : null;
       },
-      applyCreatedTaskBinding: ({ sessionId, projectId, taskId }) => {
+      applyCreatedTaskBinding: ({
+        sessionId,
+        projectId,
+        taskId,
+        workBranches
+      }) => {
         const session = this.sessionsById.get(sessionId);
         if (!session) {
           return false;
@@ -13396,6 +13462,17 @@ class RuntimeManager {
         }
         session.projectId = projectId;
         session.taskId = taskId;
+        const workBranchByRepositoryId = new Map((workBranches ?? []).map((branch) => [branch.repository_id, branch]));
+        if (workBranchByRepositoryId.size > 0) {
+          session.repos = session.repos.map((repo) => {
+            const branch = workBranchByRepositoryId.get(repo.repositoryId);
+            return branch ? {
+              ...repo,
+              repoBranch: branch.base_ref,
+              workBranch: branch.work_branch
+            } : repo;
+          });
+        }
         this.emitSessionState(session, session.lastStatus === "failed" ? "active" : session.lastStatus ?? "active");
         return true;
       },
@@ -14247,7 +14324,12 @@ class RuntimeManager2 {
           taskId: session.taskId
         } : null;
       },
-      applyCreatedTaskBinding: ({ sessionId, projectId, taskId }) => {
+      applyCreatedTaskBinding: ({
+        sessionId,
+        projectId,
+        taskId,
+        workBranches
+      }) => {
         const session = this.sessionsById.get(sessionId);
         if (!session) {
           return false;
@@ -14257,6 +14339,17 @@ class RuntimeManager2 {
         }
         session.projectId = projectId;
         session.taskId = taskId;
+        const workBranchByRepositoryId = new Map((workBranches ?? []).map((branch) => [branch.repository_id, branch]));
+        if (workBranchByRepositoryId.size > 0) {
+          session.repos = session.repos.map((repo) => {
+            const branch = workBranchByRepositoryId.get(repo.repositoryId);
+            return branch ? {
+              ...repo,
+              repoBranch: branch.base_ref,
+              workBranch: branch.work_branch
+            } : repo;
+          });
+        }
         this.emitSessionState(session, session.lastStatus === "failed" ? "active" : session.lastStatus ?? "active");
         return true;
       },