@locusai/shared 0.13.3 → 0.14.1

package/dist/index.js

@@ -63,9 +63,11 @@ __export(exports_src, {
   UpdateUserSchema: () => UpdateUserSchema,
   UpdateTaskSchema: () => UpdateTaskSchema,
   UpdateSprintSchema: () => UpdateSprintSchema,
+  UpdateSecurityRulesSchema: () => UpdateSecurityRulesSchema,
   UpdateOrganizationSchema: () => UpdateOrganizationSchema,
   UpdateDocSchema: () => UpdateDocSchema,
   UpdateDocGroupSchema: () => UpdateDocGroupSchema,
+  UpdateAwsInstanceSchema: () => UpdateAwsInstanceSchema,
   UnlockSchema: () => UnlockSchema,
   UIIntentTypeSchema: () => UIIntentTypeSchema,
   UIIntentType: () => UIIntentType,
@@ -110,6 +112,7 @@ __export(exports_src, {
   SessionListEventSchema: () => SessionListEventSchema,
   SessionCompletedEventSchema: () => SessionCompletedEventSchema,
   SelectionContextSchema: () => SelectionContextSchema,
+  SaveAwsCredentialsSchema: () => SaveAwsCredentialsSchema,
   STALE_AGENT_TIMEOUT_MS: () => STALE_AGENT_TIMEOUT_MS,
   SESSION_TRANSITIONS: () => SESSION_TRANSITIONS,
   ResumeSessionIntentSchema: () => ResumeSessionIntentSchema,
@@ -117,6 +120,7 @@ __export(exports_src, {
   RequestSessionDetailIntentSchema: () => RequestSessionDetailIntentSchema,
   ReportCiResultSchema: () => ReportCiResultSchema,
   RecordCiSchema: () => RecordCiSchema,
+  ProvisionAwsInstanceSchema: () => ProvisionAwsInstanceSchema,
   ProtocolVersionSchema: () => ProtocolVersionSchema,
   ProtocolErrorSchema: () => ProtocolErrorSchema,
   ProtocolErrorCodeSchema: () => ProtocolErrorCodeSchema,
@@ -146,6 +150,11 @@ __export(exports_src, {
   InvitationResponseSchema: () => InvitationResponseSchema,
   InvitationQuerySchema: () => InvitationQuerySchema,
   InvitationIdParamSchema: () => InvitationIdParamSchema,
+  IntegrationSchema: () => IntegrationSchema,
+  InstanceStatus: () => InstanceStatus,
+  InstanceIdParamSchema: () => InstanceIdParamSchema,
+  InstanceActionBodySchema: () => InstanceActionBodySchema,
+  InstanceAction: () => InstanceAction,
   HostEventTypeSchema: () => HostEventTypeSchema,
   HostEventType: () => HostEventType,
   HostEventSchema: () => HostEventSchema,
@@ -177,6 +186,7 @@ __export(exports_src, {
   CreateInvitationSchema: () => CreateInvitationSchema,
   CreateDocSchema: () => CreateDocSchema,
   CreateDocGroupSchema: () => CreateDocGroupSchema,
+  CreateAwsInstanceSchema: () => CreateAwsInstanceSchema,
   CreateArtifactSchema: () => CreateArtifactSchema,
   CreateApiKeySchema: () => CreateApiKeySchema,
   ContextPayloadSchema: () => ContextPayloadSchema,
@@ -200,6 +210,9 @@ __export(exports_src, {
   ChecklistItemSchema: () => ChecklistItemSchema,
   ChecklistInitializedPayloadSchema: () => ChecklistInitializedPayloadSchema,
   BaseEntitySchema: () => BaseEntitySchema,
+  AwsRegion: () => AwsRegion,
+  AwsInstanceSchema: () => AwsInstanceSchema,
+  AwsCredentialsSchema: () => AwsCredentialsSchema,
   AuthenticatedUserSchema: () => AuthenticatedUserSchema,
   AuthResponseSchema: () => AuthResponseSchema,
   AuthContextSchema: () => AuthContextSchema,
@@ -323,6 +336,18 @@ var SprintStatus;
   SprintStatus2["ACTIVE"] = "ACTIVE";
   SprintStatus2["COMPLETED"] = "COMPLETED";
 })(SprintStatus ||= {});
+var InstanceStatus;
+((InstanceStatus2) => {
+  InstanceStatus2["PROVISIONING"] = "PROVISIONING";
+  InstanceStatus2["RUNNING"] = "RUNNING";
+  InstanceStatus2["STOPPED"] = "STOPPED";
+  InstanceStatus2["TERMINATED"] = "TERMINATED";
+  InstanceStatus2["ERROR"] = "ERROR";
+})(InstanceStatus ||= {});
+var AwsRegion;
+((AwsRegion2) => {
+  AwsRegion2["US_EAST_1"] = "us-east-1";
+})(AwsRegion ||= {});
 var EventType;
 ((EventType2) => {
   EventType2["TASK_CREATED"] = "TASK_CREATED";
@@ -659,28 +684,93 @@ var CreateApiKeySchema = import_zod5.z.object({
   name: import_zod5.z.string().min(1, "Name is required").max(100),
   expiresInDays: import_zod5.z.number().int().positive().optional()
 });
-// src/models/ci.ts
+// src/models/aws-instance.ts
 var import_zod6 = require("zod");
-var RecordCiSchema = import_zod6.z.object({
-  taskId: import_zod6.z.uuid(),
+var InstanceAction;
+((InstanceAction2) => {
+  InstanceAction2["START"] = "START";
+  InstanceAction2["STOP"] = "STOP";
+  InstanceAction2["TERMINATE"] = "TERMINATE";
+})(InstanceAction ||= {});
+var AwsCredentialsSchema = import_zod6.z.object({
+  accessKeyId: import_zod6.z.string().min(1),
+  secretAccessKey: import_zod6.z.string().min(1),
+  region: import_zod6.z.enum(AwsRegion).default("us-east-1" /* US_EAST_1 */)
+});
+var IntegrationSchema = import_zod6.z.object({
+  name: import_zod6.z.string(),
+  config: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string())
+});
+var AwsInstanceSchema = BaseEntitySchema.extend({
+  workspaceId: import_zod6.z.uuid(),
+  instanceId: import_zod6.z.string(),
+  status: import_zod6.z.enum(InstanceStatus),
+  instanceType: import_zod6.z.enum(["t3.micro", "t3.small", "t3.medium"]),
+  region: import_zod6.z.enum(AwsRegion).default("us-east-1" /* US_EAST_1 */),
+  publicIp: import_zod6.z.string().nullable().optional(),
+  launchTime: import_zod6.z.union([import_zod6.z.date(), import_zod6.z.number()]).nullable().optional(),
+  repoUrl: import_zod6.z.string().nullable().optional(),
+  integrations: import_zod6.z.array(IntegrationSchema).default([])
+});
+var CreateAwsInstanceSchema = import_zod6.z.object({
   workspaceId: import_zod6.z.uuid(),
-  result: import_zod6.z.object({
-    ok: import_zod6.z.boolean(),
-    summary: import_zod6.z.string(),
-    commands: import_zod6.z.array(import_zod6.z.object({
-      cmd: import_zod6.z.string(),
-      exitCode: import_zod6.z.number(),
-      durationMs: import_zod6.z.number().optional(),
-      error: import_zod6.z.string().optional()
+  instanceType: import_zod6.z.enum(["t3.micro", "t3.small", "t3.medium"]).default("t3.micro"),
+  region: import_zod6.z.enum(AwsRegion).default("us-east-1" /* US_EAST_1 */),
+  repoUrl: import_zod6.z.string().optional(),
+  integrations: import_zod6.z.array(IntegrationSchema).optional().default([])
+});
+var UpdateAwsInstanceSchema = import_zod6.z.object({
+  status: import_zod6.z.enum(InstanceStatus).optional(),
+  instanceType: import_zod6.z.enum(["t3.micro", "t3.small", "t3.medium"]).optional(),
+  publicIp: import_zod6.z.string().nullable().optional(),
+  launchTime: import_zod6.z.union([import_zod6.z.date(), import_zod6.z.number()]).nullable().optional(),
+  repoUrl: import_zod6.z.string().nullable().optional(),
+  integrations: import_zod6.z.array(IntegrationSchema).optional()
+});
+var SaveAwsCredentialsSchema = import_zod6.z.object({
+  accessKeyId: import_zod6.z.string().min(16),
+  secretAccessKey: import_zod6.z.string().min(1),
+  region: import_zod6.z.string().default("us-east-1")
+});
+var ProvisionAwsInstanceSchema = import_zod6.z.object({
+  repoUrl: import_zod6.z.string().min(1),
+  githubToken: import_zod6.z.string().min(1),
+  instanceType: import_zod6.z.enum(["t3.micro", "t3.small", "t3.medium"]).default("t3.small"),
+  integrations: import_zod6.z.array(IntegrationSchema).optional().default([])
+});
+var InstanceActionBodySchema = import_zod6.z.object({
+  action: import_zod6.z.nativeEnum(InstanceAction)
+});
+var InstanceIdParamSchema = import_zod6.z.object({
+  workspaceId: import_zod6.z.string().uuid("Invalid Workspace ID"),
+  instanceId: import_zod6.z.string().uuid("Invalid Instance ID")
+});
+var CIDR_REGEX = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\/\d{1,2}$/;
+var UpdateSecurityRulesSchema = import_zod6.z.object({
+  allowedIps: import_zod6.z.array(import_zod6.z.string().regex(CIDR_REGEX, "Invalid CIDR format (e.g. 1.2.3.4/32)"))
+});
+// src/models/ci.ts
+var import_zod7 = require("zod");
+var RecordCiSchema = import_zod7.z.object({
+  taskId: import_zod7.z.uuid(),
+  workspaceId: import_zod7.z.uuid(),
+  result: import_zod7.z.object({
+    ok: import_zod7.z.boolean(),
+    summary: import_zod7.z.string(),
+    commands: import_zod7.z.array(import_zod7.z.object({
+      cmd: import_zod7.z.string(),
+      exitCode: import_zod7.z.number(),
+      durationMs: import_zod7.z.number().optional(),
+      error: import_zod7.z.string().optional()
     })),
-    preset: import_zod6.z.string()
+    preset: import_zod7.z.string()
   })
 });
 // src/models/doc.ts
-var import_zod7 = require("zod");
-var DocGroupSchemaForDoc = import_zod7.z.object({
-  id: import_zod7.z.uuid(),
-  name: import_zod7.z.string()
+var import_zod8 = require("zod");
+var DocGroupSchemaForDoc = import_zod8.z.object({
+  id: import_zod8.z.uuid(),
+  name: import_zod8.z.string()
 });
 var DocType;
 ((DocType2) => {
@@ -691,170 +781,170 @@ var DocType;
   DocType2["API_DESIGN"] = "API_DESIGN";
 })(DocType ||= {});
 var DocSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod7.z.uuid(),
-  groupId: import_zod7.z.uuid().nullable().optional(),
-  title: import_zod7.z.string().min(1, "Title is required"),
-  content: import_zod7.z.string().default(""),
-  type: import_zod7.z.enum(DocType).default("GENERAL" /* GENERAL */),
+  workspaceId: import_zod8.z.uuid(),
+  groupId: import_zod8.z.uuid().nullable().optional(),
+  title: import_zod8.z.string().min(1, "Title is required"),
+  content: import_zod8.z.string().default(""),
+  type: import_zod8.z.enum(DocType).default("GENERAL" /* GENERAL */),
   group: DocGroupSchemaForDoc.nullable().optional()
 });
-var CreateDocSchema = import_zod7.z.object({
-  title: import_zod7.z.string().min(1, "Title is required"),
-  content: import_zod7.z.string().optional(),
-  type: import_zod7.z.enum(DocType).optional().default("GENERAL" /* GENERAL */),
-  groupId: import_zod7.z.string().optional()
+var CreateDocSchema = import_zod8.z.object({
+  title: import_zod8.z.string().min(1, "Title is required"),
+  content: import_zod8.z.string().optional(),
+  type: import_zod8.z.enum(DocType).optional().default("GENERAL" /* GENERAL */),
+  groupId: import_zod8.z.string().optional()
 });
-var UpdateDocSchema = import_zod7.z.object({
-  title: import_zod7.z.string().min(1).optional(),
-  content: import_zod7.z.string().optional(),
-  type: import_zod7.z.enum(DocType).optional(),
-  groupId: import_zod7.z.string().nullable().optional()
+var UpdateDocSchema = import_zod8.z.object({
+  title: import_zod8.z.string().min(1).optional(),
+  content: import_zod8.z.string().optional(),
+  type: import_zod8.z.enum(DocType).optional(),
+  groupId: import_zod8.z.string().nullable().optional()
 });
-var DocResponseSchema = import_zod7.z.object({
+var DocResponseSchema = import_zod8.z.object({
   doc: DocSchema
 });
-var DocsResponseSchema = import_zod7.z.object({
-  docs: import_zod7.z.array(DocSchema)
+var DocsResponseSchema = import_zod8.z.object({
+  docs: import_zod8.z.array(DocSchema)
 });
-var DocIdParamSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid("Invalid Doc ID")
+var DocIdParamSchema = import_zod8.z.object({
+  id: import_zod8.z.string().uuid("Invalid Doc ID")
 });
-var DocQuerySchema = import_zod7.z.object({
-  workspaceId: import_zod7.z.string().uuid("Invalid Workspace ID").optional()
+var DocQuerySchema = import_zod8.z.object({
+  workspaceId: import_zod8.z.string().uuid("Invalid Workspace ID").optional()
 });
 // src/models/doc-group.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var DocGroupSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod8.z.uuid(),
-  name: import_zod8.z.string().min(1, "Name is required"),
-  order: import_zod8.z.number().default(0)
+  workspaceId: import_zod9.z.uuid(),
+  name: import_zod9.z.string().min(1, "Name is required"),
+  order: import_zod9.z.number().default(0)
 });
-var CreateDocGroupSchema = import_zod8.z.object({
-  name: import_zod8.z.string().min(1, "Name is required"),
-  order: import_zod8.z.number().optional()
+var CreateDocGroupSchema = import_zod9.z.object({
+  name: import_zod9.z.string().min(1, "Name is required"),
+  order: import_zod9.z.number().optional()
 });
-var UpdateDocGroupSchema = import_zod8.z.object({
-  name: import_zod8.z.string().min(1).optional(),
-  order: import_zod8.z.number().optional()
+var UpdateDocGroupSchema = import_zod9.z.object({
+  name: import_zod9.z.string().min(1).optional(),
+  order: import_zod9.z.number().optional()
 });
-var DocGroupResponseSchema = import_zod8.z.object({
+var DocGroupResponseSchema = import_zod9.z.object({
   group: DocGroupSchema
 });
-var DocGroupsResponseSchema = import_zod8.z.object({
-  groups: import_zod8.z.array(DocGroupSchema)
+var DocGroupsResponseSchema = import_zod9.z.object({
+  groups: import_zod9.z.array(DocGroupSchema)
 });
-var DocGroupIdParamSchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid("Invalid Group ID")
+var DocGroupIdParamSchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid("Invalid Group ID")
 });
 // src/models/invitation.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var InvitationSchema = BaseEntitySchema.extend({
-  orgId: import_zod9.z.string().uuid("Invalid Organization ID"),
-  email: import_zod9.z.string().email("Invalid email address"),
-  role: import_zod9.z.enum(MembershipRole),
-  token: import_zod9.z.string(),
-  expiresAt: import_zod9.z.number(),
-  acceptedAt: import_zod9.z.number().nullable().optional(),
-  invitedBy: import_zod9.z.uuid()
+  orgId: import_zod10.z.string().uuid("Invalid Organization ID"),
+  email: import_zod10.z.string().email("Invalid email address"),
+  role: import_zod10.z.enum(MembershipRole),
+  token: import_zod10.z.string(),
+  expiresAt: import_zod10.z.number(),
+  acceptedAt: import_zod10.z.number().nullable().optional(),
+  invitedBy: import_zod10.z.uuid()
 });
-var CreateInvitationSchema = import_zod9.z.object({
-  orgId: import_zod9.z.string().uuid("Invalid Organization ID"),
-  email: import_zod9.z.string().email("Invalid email address"),
-  role: import_zod9.z.enum(MembershipRole).default("MEMBER" /* MEMBER */)
+var CreateInvitationSchema = import_zod10.z.object({
+  orgId: import_zod10.z.string().uuid("Invalid Organization ID"),
+  email: import_zod10.z.string().email("Invalid email address"),
+  role: import_zod10.z.enum(MembershipRole).default("MEMBER" /* MEMBER */)
 });
-var AcceptInvitationSchema = import_zod9.z.object({
-  token: import_zod9.z.string().min(1, "Invitation token is required"),
-  name: import_zod9.z.string().min(1, "Name is required").optional()
+var AcceptInvitationSchema = import_zod10.z.object({
+  token: import_zod10.z.string().min(1, "Invitation token is required"),
+  name: import_zod10.z.string().min(1, "Name is required").optional()
 });
-var InvitationIdParamSchema = import_zod9.z.object({
-  id: import_zod9.z.string().uuid("Invalid Invitation ID")
+var InvitationIdParamSchema = import_zod10.z.object({
+  id: import_zod10.z.string().uuid("Invalid Invitation ID")
 });
-var InvitationVerifyParamSchema = import_zod9.z.object({
-  token: import_zod9.z.string().min(1, "Token required")
+var InvitationVerifyParamSchema = import_zod10.z.object({
+  token: import_zod10.z.string().min(1, "Token required")
 });
-var InvitationQuerySchema = import_zod9.z.object({
-  orgId: import_zod9.z.string().uuid("Invalid Organization ID").optional()
+var InvitationQuerySchema = import_zod10.z.object({
+  orgId: import_zod10.z.string().uuid("Invalid Organization ID").optional()
 });
-var InvitationResponseSchema = import_zod9.z.object({
+var InvitationResponseSchema = import_zod10.z.object({
   invitation: InvitationSchema,
-  userExists: import_zod9.z.boolean().optional()
-});
-var InvitationsResponseSchema = import_zod9.z.object({
-  invitations: import_zod9.z.array(InvitationSchema)
-});
-var AcceptInvitationResponseSchema = import_zod9.z.object({
-  membership: import_zod9.z.object({
-    id: import_zod9.z.uuid(),
-    userId: import_zod9.z.uuid(),
-    orgId: import_zod9.z.uuid(),
-    role: import_zod9.z.enum(MembershipRole),
-    createdAt: import_zod9.z.number()
+  userExists: import_zod10.z.boolean().optional()
+});
+var InvitationsResponseSchema = import_zod10.z.object({
+  invitations: import_zod10.z.array(InvitationSchema)
+});
+var AcceptInvitationResponseSchema = import_zod10.z.object({
+  membership: import_zod10.z.object({
+    id: import_zod10.z.uuid(),
+    userId: import_zod10.z.uuid(),
+    orgId: import_zod10.z.uuid(),
+    role: import_zod10.z.enum(MembershipRole),
+    createdAt: import_zod10.z.number()
   })
 });
 // src/models/organization.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var OrganizationSchema = BaseEntitySchema.extend({
-  name: import_zod10.z.string().min(1, "Name is required").max(100),
-  avatarUrl: import_zod10.z.string().url("Invalid avatar URL").nullable().optional().or(import_zod10.z.literal(""))
+  name: import_zod11.z.string().min(1, "Name is required").max(100),
+  avatarUrl: import_zod11.z.string().url("Invalid avatar URL").nullable().optional().or(import_zod11.z.literal(""))
 });
-var CreateOrganizationSchema = import_zod10.z.object({
-  name: import_zod10.z.string().min(1, "Name is required").max(100),
-  avatarUrl: import_zod10.z.string().url("Invalid avatar URL").optional().or(import_zod10.z.literal(""))
+var CreateOrganizationSchema = import_zod11.z.object({
+  name: import_zod11.z.string().min(1, "Name is required").max(100),
+  avatarUrl: import_zod11.z.string().url("Invalid avatar URL").optional().or(import_zod11.z.literal(""))
 });
 var UpdateOrganizationSchema = OrganizationSchema.partial().omit({
   id: true,
   createdAt: true,
   updatedAt: true
 });
-var AddMemberSchema = import_zod10.z.object({
-  userId: import_zod10.z.string().uuid("Invalid User ID"),
-  role: import_zod10.z.enum(["ADMIN", "MEMBER"]).default("MEMBER")
-});
-var MembershipWithUserSchema = import_zod10.z.object({
-  id: import_zod10.z.uuid(),
-  userId: import_zod10.z.uuid(),
-  orgId: import_zod10.z.uuid(),
-  role: import_zod10.z.string(),
-  createdAt: import_zod10.z.number(),
-  user: import_zod10.z.object({
-    id: import_zod10.z.uuid(),
-    email: import_zod10.z.string().email(),
-    name: import_zod10.z.string(),
-    avatarUrl: import_zod10.z.string().url().nullable().optional()
+var AddMemberSchema = import_zod11.z.object({
+  userId: import_zod11.z.string().uuid("Invalid User ID"),
+  role: import_zod11.z.enum(["ADMIN", "MEMBER"]).default("MEMBER")
+});
+var MembershipWithUserSchema = import_zod11.z.object({
+  id: import_zod11.z.uuid(),
+  userId: import_zod11.z.uuid(),
+  orgId: import_zod11.z.uuid(),
+  role: import_zod11.z.string(),
+  createdAt: import_zod11.z.number(),
+  user: import_zod11.z.object({
+    id: import_zod11.z.uuid(),
+    email: import_zod11.z.string().email(),
+    name: import_zod11.z.string(),
+    avatarUrl: import_zod11.z.string().url().nullable().optional()
   })
 });
-var OrgIdParamSchema = import_zod10.z.object({
-  orgId: import_zod10.z.string().uuid("Invalid Organization ID")
+var OrgIdParamSchema = import_zod11.z.object({
+  orgId: import_zod11.z.string().uuid("Invalid Organization ID")
 });
-var MembershipIdParamSchema = import_zod10.z.object({
-  id: import_zod10.z.string().uuid("Invalid Membership ID")
+var MembershipIdParamSchema = import_zod11.z.object({
+  id: import_zod11.z.string().uuid("Invalid Membership ID")
 });
-var OrganizationResponseSchema = import_zod10.z.object({
+var OrganizationResponseSchema = import_zod11.z.object({
   organization: OrganizationSchema
 });
-var OrganizationsResponseSchema = import_zod10.z.object({
-  organizations: import_zod10.z.array(OrganizationSchema)
+var OrganizationsResponseSchema = import_zod11.z.object({
+  organizations: import_zod11.z.array(OrganizationSchema)
 });
-var MembersResponseSchema = import_zod10.z.object({
-  members: import_zod10.z.array(MembershipWithUserSchema)
+var MembersResponseSchema = import_zod11.z.object({
+  members: import_zod11.z.array(MembershipWithUserSchema)
 });
-var MembershipResponseSchema = import_zod10.z.object({
+var MembershipResponseSchema = import_zod11.z.object({
   membership: MembershipWithUserSchema
 });
 // src/models/sprint.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var SprintSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod11.z.uuid().nullable().optional(),
-  name: import_zod11.z.string().min(1, "Name is required").max(100),
-  status: import_zod11.z.enum(SprintStatus),
-  startDate: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional(),
-  endDate: import_zod11.z.union([import_zod11.z.date(), import_zod11.z.number()]).nullable().optional()
+  workspaceId: import_zod12.z.uuid().nullable().optional(),
+  name: import_zod12.z.string().min(1, "Name is required").max(100),
+  status: import_zod12.z.enum(SprintStatus),
+  startDate: import_zod12.z.union([import_zod12.z.date(), import_zod12.z.number()]).nullable().optional(),
+  endDate: import_zod12.z.union([import_zod12.z.date(), import_zod12.z.number()]).nullable().optional()
 });
-var CreateSprintSchema = import_zod11.z.object({
-  name: import_zod11.z.string().min(1, "Name is required").max(100),
-  startDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional(),
-  endDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional(),
-  taskIds: import_zod11.z.array(import_zod11.z.string()).optional()
+var CreateSprintSchema = import_zod12.z.object({
+  name: import_zod12.z.string().min(1, "Name is required").max(100),
+  startDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional(),
+  endDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional(),
+  taskIds: import_zod12.z.array(import_zod12.z.string()).optional()
 });
 var UpdateSprintSchema = SprintSchema.partial().omit({
   id: true,
@@ -863,60 +953,60 @@ var UpdateSprintSchema = SprintSchema.partial().omit({
   startDate: true,
   endDate: true
 }).extend({
-  name: import_zod11.z.string().min(1).max(100).optional(),
-  startDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional().nullable(),
-  endDate: import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number()]).optional().nullable()
+  name: import_zod12.z.string().min(1).max(100).optional(),
+  startDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional().nullable(),
+  endDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional().nullable()
 });
-var SprintIdParamSchema = import_zod11.z.object({
-  id: import_zod11.z.string().uuid("Invalid Sprint ID")
+var SprintIdParamSchema = import_zod12.z.object({
+  id: import_zod12.z.string().uuid("Invalid Sprint ID")
 });
-var SprintQuerySchema = import_zod11.z.object({});
-var SprintResponseSchema = import_zod11.z.object({
+var SprintQuerySchema = import_zod12.z.object({});
+var SprintResponseSchema = import_zod12.z.object({
   sprint: SprintSchema
 });
-var SprintsResponseSchema = import_zod11.z.object({
-  sprints: import_zod11.z.array(SprintSchema)
+var SprintsResponseSchema = import_zod12.z.object({
+  sprints: import_zod12.z.array(SprintSchema)
 });
 // src/models/task.ts
-var import_zod12 = require("zod");
-var AcceptanceItemSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  text: import_zod12.z.string(),
-  done: import_zod12.z.boolean()
+var import_zod13 = require("zod");
+var AcceptanceItemSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  text: import_zod13.z.string(),
+  done: import_zod13.z.boolean()
 });
 var TaskSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod12.z.uuid().nullable().optional(),
-  title: import_zod12.z.string().min(1, "Title is required").max(200),
-  description: import_zod12.z.string(),
-  status: import_zod12.z.enum(TaskStatus),
-  priority: import_zod12.z.enum(TaskPriority),
-  labels: import_zod12.z.array(import_zod12.z.string()),
-  assigneeRole: import_zod12.z.enum(AssigneeRole).nullable().optional(),
-  assignedTo: import_zod12.z.string().nullable().optional(),
-  sprintId: import_zod12.z.uuid().nullable().optional(),
-  parentId: import_zod12.z.uuid().nullable().optional(),
-  dueDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).nullable().optional(),
-  prUrl: import_zod12.z.string().nullable().optional(),
-  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema),
-  comments: import_zod12.z.array(CommentSchema).optional(),
-  activityLog: import_zod12.z.array(EventSchema).optional(),
-  docs: import_zod12.z.array(DocSchema),
-  order: import_zod12.z.number().optional()
-});
-var CreateTaskSchema = import_zod12.z.object({
-  title: import_zod12.z.string().min(1, "Title is required").max(200),
-  description: import_zod12.z.string().optional().default(""),
-  status: import_zod12.z.enum(TaskStatus).optional().default("BACKLOG" /* BACKLOG */),
-  priority: import_zod12.z.enum(TaskPriority).optional().default("MEDIUM" /* MEDIUM */),
-  labels: import_zod12.z.array(import_zod12.z.string()).optional().default([]),
-  assigneeRole: import_zod12.z.enum(AssigneeRole).optional(),
-  assignedTo: import_zod12.z.string().nullable().optional(),
-  dueDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).nullable().optional(),
-  parentId: import_zod12.z.string().nullable().optional(),
-  sprintId: import_zod12.z.string().nullable().optional(),
-  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).optional(),
-  docIds: import_zod12.z.array(import_zod12.z.string()).optional(),
-  order: import_zod12.z.number().optional()
+  workspaceId: import_zod13.z.uuid().nullable().optional(),
+  title: import_zod13.z.string().min(1, "Title is required").max(200),
+  description: import_zod13.z.string(),
+  status: import_zod13.z.enum(TaskStatus),
+  priority: import_zod13.z.enum(TaskPriority),
+  labels: import_zod13.z.array(import_zod13.z.string()),
+  assigneeRole: import_zod13.z.enum(AssigneeRole).nullable().optional(),
+  assignedTo: import_zod13.z.string().nullable().optional(),
+  sprintId: import_zod13.z.uuid().nullable().optional(),
+  parentId: import_zod13.z.uuid().nullable().optional(),
+  dueDate: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).nullable().optional(),
+  prUrl: import_zod13.z.string().nullable().optional(),
+  acceptanceChecklist: import_zod13.z.array(AcceptanceItemSchema),
+  comments: import_zod13.z.array(CommentSchema).optional(),
+  activityLog: import_zod13.z.array(EventSchema).optional(),
+  docs: import_zod13.z.array(DocSchema),
+  order: import_zod13.z.number().optional()
+});
+var CreateTaskSchema = import_zod13.z.object({
+  title: import_zod13.z.string().min(1, "Title is required").max(200),
+  description: import_zod13.z.string().optional().default(""),
+  status: import_zod13.z.enum(TaskStatus).optional().default("BACKLOG" /* BACKLOG */),
+  priority: import_zod13.z.enum(TaskPriority).optional().default("MEDIUM" /* MEDIUM */),
+  labels: import_zod13.z.array(import_zod13.z.string()).optional().default([]),
+  assigneeRole: import_zod13.z.enum(AssigneeRole).optional(),
+  assignedTo: import_zod13.z.string().nullable().optional(),
+  dueDate: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).nullable().optional(),
+  parentId: import_zod13.z.string().nullable().optional(),
+  sprintId: import_zod13.z.string().nullable().optional(),
+  acceptanceChecklist: import_zod13.z.array(AcceptanceItemSchema).optional(),
+  docIds: import_zod13.z.array(import_zod13.z.string()).optional(),
+  order: import_zod13.z.number().optional()
 });
 var UpdateTaskSchema = TaskSchema.partial().omit({
   id: true,
@@ -928,44 +1018,44 @@ var UpdateTaskSchema = TaskSchema.partial().omit({
   activityLog: true,
   docs: true
 }).extend({
-  title: import_zod12.z.string().min(1).max(200).optional(),
-  dueDate: import_zod12.z.union([import_zod12.z.string(), import_zod12.z.number()]).optional().nullable(),
-  prUrl: import_zod12.z.string().nullable().optional(),
-  acceptanceChecklist: import_zod12.z.array(AcceptanceItemSchema).optional(),
-  docIds: import_zod12.z.array(import_zod12.z.string()).optional()
+  title: import_zod13.z.string().min(1).max(200).optional(),
+  dueDate: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().nullable(),
+  prUrl: import_zod13.z.string().nullable().optional(),
+  acceptanceChecklist: import_zod13.z.array(AcceptanceItemSchema).optional(),
+  docIds: import_zod13.z.array(import_zod13.z.string()).optional()
 });
-var AddCommentSchema = import_zod12.z.object({
-  author: import_zod12.z.string().min(1, "Author is required"),
-  text: import_zod12.z.string().min(1, "Comment text is required")
+var AddCommentSchema = import_zod13.z.object({
+  author: import_zod13.z.string().min(1, "Author is required"),
+  text: import_zod13.z.string().min(1, "Comment text is required")
 });
-var DispatchTaskSchema = import_zod12.z.object({
-  workerId: import_zod12.z.string().optional(),
-  sprintId: import_zod12.z.uuid().optional().nullable()
+var DispatchTaskSchema = import_zod13.z.object({
+  workerId: import_zod13.z.string().optional(),
+  sprintId: import_zod13.z.uuid().optional().nullable()
 });
-var TaskIdParamSchema = import_zod12.z.object({
-  id: import_zod12.z.string().uuid("Invalid Task ID")
+var TaskIdParamSchema = import_zod13.z.object({
+  id: import_zod13.z.string().uuid("Invalid Task ID")
 });
-var TaskQuerySchema = import_zod12.z.object({});
-var TaskResponseSchema = import_zod12.z.object({
+var TaskQuerySchema = import_zod13.z.object({});
+var TaskResponseSchema = import_zod13.z.object({
   task: TaskSchema
 });
-var TasksResponseSchema = import_zod12.z.object({
-  tasks: import_zod12.z.array(TaskSchema)
+var TasksResponseSchema = import_zod13.z.object({
+  tasks: import_zod13.z.array(TaskSchema)
 });
 // src/models/workspace.ts
-var import_zod13 = require("zod");
-var ChecklistItemSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  text: import_zod13.z.string(),
-  done: import_zod13.z.boolean()
+var import_zod14 = require("zod");
+var ChecklistItemSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  text: import_zod14.z.string(),
+  done: import_zod14.z.boolean()
 });
 var WorkspaceSchema = BaseEntitySchema.extend({
-  orgId: import_zod13.z.uuid(),
-  name: import_zod13.z.string().min(1, "Name is required").max(100),
-  defaultChecklist: import_zod13.z.array(ChecklistItemSchema).nullable().optional()
+  orgId: import_zod14.z.uuid(),
+  name: import_zod14.z.string().min(1, "Name is required").max(100),
+  defaultChecklist: import_zod14.z.array(ChecklistItemSchema).nullable().optional()
 });
-var CreateWorkspaceSchema = import_zod13.z.object({
-  name: import_zod13.z.string().min(1, "Name is required").max(100)
+var CreateWorkspaceSchema = import_zod14.z.object({
+  name: import_zod14.z.string().min(1, "Name is required").max(100)
 });
 var UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
   id: true,
@@ -973,45 +1063,45 @@ var UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
   createdAt: true,
   updatedAt: true
 });
-var AddWorkspaceMemberSchema = import_zod13.z.object({
-  userId: import_zod13.z.string().uuid("Invalid User ID"),
-  role: import_zod13.z.string().optional()
+var AddWorkspaceMemberSchema = import_zod14.z.object({
+  userId: import_zod14.z.string().uuid("Invalid User ID"),
+  role: import_zod14.z.string().optional()
 });
-var WorkspaceIdParamSchema = import_zod13.z.object({
-  workspaceId: import_zod13.z.string().uuid("Invalid Workspace ID")
+var WorkspaceIdParamSchema = import_zod14.z.object({
+  workspaceId: import_zod14.z.string().uuid("Invalid Workspace ID")
 });
-var WorkspaceAndUserParamSchema = import_zod13.z.object({
-  workspaceId: import_zod13.z.string().uuid("Invalid Workspace ID"),
-  userId: import_zod13.z.string().uuid("Invalid User ID")
+var WorkspaceAndUserParamSchema = import_zod14.z.object({
+  workspaceId: import_zod14.z.string().uuid("Invalid Workspace ID"),
+  userId: import_zod14.z.string().uuid("Invalid User ID")
 });
-var WorkspaceResponseSchema = import_zod13.z.object({
+var WorkspaceResponseSchema = import_zod14.z.object({
   workspace: WorkspaceSchema
 });
-var WorkspacesResponseSchema = import_zod13.z.object({
-  workspaces: import_zod13.z.array(WorkspaceSchema)
+var WorkspacesResponseSchema = import_zod14.z.object({
+  workspaces: import_zod14.z.array(WorkspaceSchema)
 });
-var WorkspaceStatsSchema = import_zod13.z.object({
-  workspaceName: import_zod13.z.string(),
-  taskCounts: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.number()),
-  memberCount: import_zod13.z.number()
+var WorkspaceStatsSchema = import_zod14.z.object({
+  workspaceName: import_zod14.z.string(),
+  taskCounts: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number()),
+  memberCount: import_zod14.z.number()
 });
-var WorkspaceStatsResponseSchema = import_zod13.z.object({
+var WorkspaceStatsResponseSchema = import_zod14.z.object({
   stats: WorkspaceStatsSchema
 });
 // src/protocol/cli-stream.ts
-var import_zod16 = require("zod");
+var import_zod17 = require("zod");
 
 // src/protocol/envelope.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var PROTOCOL_VERSION = 1;
-var ProtocolVersionSchema = import_zod14.z.literal(PROTOCOL_VERSION);
-var ProtocolEnvelopeSchema = import_zod14.z.object({
+var ProtocolVersionSchema = import_zod15.z.literal(PROTOCOL_VERSION);
+var ProtocolEnvelopeSchema = import_zod15.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod14.z.string()
+  type: import_zod15.z.string()
 });
 
 // src/protocol/errors.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var ProtocolErrorCode = {
   CLI_NOT_FOUND: "CLI_NOT_FOUND",
   AUTH_EXPIRED: "AUTH_EXPIRED",
@@ -1022,12 +1112,12 @@ var ProtocolErrorCode = {
   SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
   UNKNOWN: "UNKNOWN"
 };
-var ProtocolErrorCodeSchema = import_zod15.z.enum(ProtocolErrorCode);
-var ProtocolErrorSchema = import_zod15.z.object({
+var ProtocolErrorCodeSchema = import_zod16.z.enum(ProtocolErrorCode);
+var ProtocolErrorSchema = import_zod16.z.object({
   code: ProtocolErrorCodeSchema,
-  message: import_zod15.z.string(),
-  details: import_zod15.z.unknown().optional(),
-  recoverable: import_zod15.z.boolean()
+  message: import_zod16.z.string(),
+  details: import_zod16.z.unknown().optional(),
+  recoverable: import_zod16.z.boolean()
 });
 
 // src/protocol/cli-stream.ts
@@ -1041,75 +1131,75 @@ var CliStreamEventType = {
   ERROR: "error",
   DONE: "done"
 };
-var CliStreamEventTypeSchema = import_zod16.z.enum(CliStreamEventType);
-var CliStreamBaseSchema = import_zod16.z.object({
+var CliStreamEventTypeSchema = import_zod17.z.enum(CliStreamEventType);
+var CliStreamBaseSchema = import_zod17.z.object({
   protocol: ProtocolVersionSchema,
-  sessionId: import_zod16.z.string(),
-  timestamp: import_zod16.z.number()
+  sessionId: import_zod17.z.string(),
+  timestamp: import_zod17.z.number()
 });
 var CliStartEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.START),
-  payload: import_zod16.z.object({
-    command: import_zod16.z.string(),
-    model: import_zod16.z.string().optional(),
-    provider: import_zod16.z.string().optional(),
-    cwd: import_zod16.z.string().optional()
+  type: import_zod17.z.literal(CliStreamEventType.START),
+  payload: import_zod17.z.object({
+    command: import_zod17.z.string(),
+    model: import_zod17.z.string().optional(),
+    provider: import_zod17.z.string().optional(),
+    cwd: import_zod17.z.string().optional()
   })
 });
 var CliTextDeltaEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.TEXT_DELTA),
-  payload: import_zod16.z.object({
-    content: import_zod16.z.string()
+  type: import_zod17.z.literal(CliStreamEventType.TEXT_DELTA),
+  payload: import_zod17.z.object({
+    content: import_zod17.z.string()
   })
 });
 var CliThinkingEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.THINKING),
-  payload: import_zod16.z.object({
-    content: import_zod16.z.string().optional()
+  type: import_zod17.z.literal(CliStreamEventType.THINKING),
+  payload: import_zod17.z.object({
+    content: import_zod17.z.string().optional()
   })
 });
 var CliToolStartedEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.TOOL_STARTED),
-  payload: import_zod16.z.object({
-    tool: import_zod16.z.string(),
-    toolId: import_zod16.z.string().optional(),
-    parameters: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional()
+  type: import_zod17.z.literal(CliStreamEventType.TOOL_STARTED),
+  payload: import_zod17.z.object({
+    tool: import_zod17.z.string(),
+    toolId: import_zod17.z.string().optional(),
+    parameters: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional()
   })
 });
 var CliToolCompletedEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.TOOL_COMPLETED),
-  payload: import_zod16.z.object({
-    tool: import_zod16.z.string(),
-    toolId: import_zod16.z.string().optional(),
-    success: import_zod16.z.boolean(),
-    duration: import_zod16.z.number().optional(),
-    error: import_zod16.z.string().optional()
+  type: import_zod17.z.literal(CliStreamEventType.TOOL_COMPLETED),
+  payload: import_zod17.z.object({
+    tool: import_zod17.z.string(),
+    toolId: import_zod17.z.string().optional(),
+    success: import_zod17.z.boolean(),
+    duration: import_zod17.z.number().optional(),
+    error: import_zod17.z.string().optional()
   })
 });
 var CliStatusEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.STATUS),
-  payload: import_zod16.z.object({
-    status: import_zod16.z.string(),
-    message: import_zod16.z.string().optional()
+  type: import_zod17.z.literal(CliStreamEventType.STATUS),
+  payload: import_zod17.z.object({
+    status: import_zod17.z.string(),
+    message: import_zod17.z.string().optional()
   })
 });
 var CliErrorEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.ERROR),
-  payload: import_zod16.z.object({
+  type: import_zod17.z.literal(CliStreamEventType.ERROR),
+  payload: import_zod17.z.object({
     error: ProtocolErrorSchema
   })
 });
 var CliDoneEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod16.z.literal(CliStreamEventType.DONE),
-  payload: import_zod16.z.object({
-    exitCode: import_zod16.z.number().int(),
-    duration: import_zod16.z.number(),
-    toolsUsed: import_zod16.z.array(import_zod16.z.string()).optional(),
-    tokensUsed: import_zod16.z.number().optional(),
-    success: import_zod16.z.boolean()
+  type: import_zod17.z.literal(CliStreamEventType.DONE),
+  payload: import_zod17.z.object({
+    exitCode: import_zod17.z.number().int(),
+    duration: import_zod17.z.number(),
+    toolsUsed: import_zod17.z.array(import_zod17.z.string()).optional(),
+    tokensUsed: import_zod17.z.number().optional(),
+    success: import_zod17.z.boolean()
   })
 });
-var CliStreamEventSchema = import_zod16.z.discriminatedUnion("type", [
+var CliStreamEventSchema = import_zod17.z.discriminatedUnion("type", [
   CliStartEventSchema,
   CliTextDeltaEventSchema,
   CliThinkingEventSchema,
@@ -1136,34 +1226,34 @@ function parseCliStreamEvent(value) {
   return { success: false, error: result.error };
 }
 // src/protocol/context.ts
-var import_zod17 = require("zod");
-var ActiveFileContextSchema = import_zod17.z.object({
-  filePath: import_zod17.z.string(),
-  languageId: import_zod17.z.string().optional()
-});
-var SelectionContextSchema = import_zod17.z.object({
-  filePath: import_zod17.z.string(),
-  languageId: import_zod17.z.string().optional(),
-  startLine: import_zod17.z.number().int().min(0),
-  startColumn: import_zod17.z.number().int().min(0),
-  endLine: import_zod17.z.number().int().min(0),
-  endColumn: import_zod17.z.number().int().min(0),
-  text: import_zod17.z.string()
-});
-var WorkspaceContextSchema = import_zod17.z.object({
-  rootPath: import_zod17.z.string(),
-  name: import_zod17.z.string().optional()
-});
-var ContextPayloadSchema = import_zod17.z.object({
+var import_zod18 = require("zod");
+var ActiveFileContextSchema = import_zod18.z.object({
+  filePath: import_zod18.z.string(),
+  languageId: import_zod18.z.string().optional()
+});
+var SelectionContextSchema = import_zod18.z.object({
+  filePath: import_zod18.z.string(),
+  languageId: import_zod18.z.string().optional(),
+  startLine: import_zod18.z.number().int().min(0),
+  startColumn: import_zod18.z.number().int().min(0),
+  endLine: import_zod18.z.number().int().min(0),
+  endColumn: import_zod18.z.number().int().min(0),
+  text: import_zod18.z.string()
+});
+var WorkspaceContextSchema = import_zod18.z.object({
+  rootPath: import_zod18.z.string(),
+  name: import_zod18.z.string().optional()
+});
+var ContextPayloadSchema = import_zod18.z.object({
   workspace: WorkspaceContextSchema.optional(),
   activeFile: ActiveFileContextSchema.optional(),
   selection: SelectionContextSchema.optional()
 });
 // src/protocol/host-events.ts
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/protocol/session.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var SessionStatus = {
   IDLE: "idle",
   STARTING: "starting",
@@ -1175,7 +1265,7 @@ var SessionStatus = {
   FAILED: "failed",
   RESUMING: "resuming"
 };
-var SessionStatusSchema = import_zod18.z.enum(SessionStatus);
+var SessionStatusSchema = import_zod19.z.enum(SessionStatus);
 var SessionTransitionEvent = {
   CREATE_SESSION: "create_session",
   CLI_SPAWNED: "cli_spawned",
@@ -1186,7 +1276,7 @@ var SessionTransitionEvent = {
   RESUME: "resume",
   ERROR: "error"
 };
-var SessionTransitionEventSchema = import_zod18.z.enum(SessionTransitionEvent);
+var SessionTransitionEventSchema = import_zod19.z.enum(SessionTransitionEvent);
 var SESSION_TRANSITIONS = [
   {
     from: SessionStatus.IDLE,
@@ -1279,24 +1369,24 @@ var TERMINAL_STATUSES = new Set([
   SessionStatus.CANCELED,
   SessionStatus.FAILED
 ]);
-var SessionMetadataSchema = import_zod18.z.object({
-  sessionId: import_zod18.z.string(),
+var SessionMetadataSchema = import_zod19.z.object({
+  sessionId: import_zod19.z.string(),
   status: SessionStatusSchema,
-  model: import_zod18.z.string().optional(),
-  createdAt: import_zod18.z.number(),
-  updatedAt: import_zod18.z.number(),
-  title: import_zod18.z.string().optional(),
-  prompt: import_zod18.z.string().optional()
-});
-var SessionSummarySchema = import_zod18.z.object({
-  sessionId: import_zod18.z.string(),
+  model: import_zod19.z.string().optional(),
+  createdAt: import_zod19.z.number(),
+  updatedAt: import_zod19.z.number(),
+  title: import_zod19.z.string().optional(),
+  prompt: import_zod19.z.string().optional()
+});
+var SessionSummarySchema = import_zod19.z.object({
+  sessionId: import_zod19.z.string(),
   status: SessionStatusSchema,
-  model: import_zod18.z.string().optional(),
-  title: import_zod18.z.string().optional(),
-  createdAt: import_zod18.z.number(),
-  updatedAt: import_zod18.z.number(),
-  messageCount: import_zod18.z.number(),
-  toolCount: import_zod18.z.number()
+  model: import_zod19.z.string().optional(),
+  title: import_zod19.z.string().optional(),
+  createdAt: import_zod19.z.number(),
+  updatedAt: import_zod19.z.number(),
+  messageCount: import_zod19.z.number(),
+  toolCount: import_zod19.z.number()
 });
 
 // src/protocol/host-events.ts
@@ -1310,7 +1400,7 @@ var HostEventType = {
   SESSION_LIST: "session_list",
   SESSION_COMPLETED: "session_completed"
 };
-var HostEventTypeSchema = import_zod19.z.enum(HostEventType);
+var HostEventTypeSchema = import_zod20.z.enum(HostEventType);
 var TimelineEntryKind = {
   MESSAGE: "message",
   TOOL_CALL: "tool_call",
@@ -1318,86 +1408,86 @@ var TimelineEntryKind = {
   ERROR: "error",
   DONE: "done"
 };
-var TimelineEntryKindSchema = import_zod19.z.enum(TimelineEntryKind);
-var TimelineEntrySchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
+var TimelineEntryKindSchema = import_zod20.z.enum(TimelineEntryKind);
+var TimelineEntrySchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
   kind: TimelineEntryKindSchema,
-  timestamp: import_zod19.z.number(),
-  data: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown())
+  timestamp: import_zod20.z.number(),
+  data: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown())
 });
-var SessionStateEventSchema = import_zod19.z.object({
+var SessionStateEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.SESSION_STATE),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
+  type: import_zod20.z.literal(HostEventType.SESSION_STATE),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string(),
     status: SessionStatusSchema,
     metadata: SessionMetadataSchema.optional(),
-    timeline: import_zod19.z.array(TimelineEntrySchema).optional()
+    timeline: import_zod20.z.array(TimelineEntrySchema).optional()
   })
 });
-var TextDeltaEventSchema = import_zod19.z.object({
+var TextDeltaEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.TEXT_DELTA),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    content: import_zod19.z.string()
+  type: import_zod20.z.literal(HostEventType.TEXT_DELTA),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string(),
+    content: import_zod20.z.string()
   })
 });
-var ToolStartedEventSchema = import_zod19.z.object({
+var ToolStartedEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.TOOL_STARTED),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    tool: import_zod19.z.string(),
-    toolId: import_zod19.z.string().optional(),
-    parameters: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.unknown()).optional()
+  type: import_zod20.z.literal(HostEventType.TOOL_STARTED),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string(),
+    tool: import_zod20.z.string(),
+    toolId: import_zod20.z.string().optional(),
+    parameters: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown()).optional()
   })
 });
-var ToolCompletedEventSchema = import_zod19.z.object({
+var ToolCompletedEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.TOOL_COMPLETED),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    tool: import_zod19.z.string(),
-    toolId: import_zod19.z.string().optional(),
-    result: import_zod19.z.unknown().optional(),
-    duration: import_zod19.z.number().optional(),
-    success: import_zod19.z.boolean(),
-    error: import_zod19.z.string().optional()
+  type: import_zod20.z.literal(HostEventType.TOOL_COMPLETED),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string(),
+    tool: import_zod20.z.string(),
+    toolId: import_zod20.z.string().optional(),
+    result: import_zod20.z.unknown().optional(),
+    duration: import_zod20.z.number().optional(),
+    success: import_zod20.z.boolean(),
+    error: import_zod20.z.string().optional()
   })
 });
-var ThinkingEventSchema = import_zod19.z.object({
+var ThinkingEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.THINKING),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    content: import_zod19.z.string().optional()
+  type: import_zod20.z.literal(HostEventType.THINKING),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string(),
+    content: import_zod20.z.string().optional()
   })
 });
-var ErrorEventSchema = import_zod19.z.object({
+var ErrorEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.ERROR),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string().optional(),
+  type: import_zod20.z.literal(HostEventType.ERROR),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string().optional(),
     error: ProtocolErrorSchema
   })
 });
-var SessionListEventSchema = import_zod19.z.object({
+var SessionListEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.SESSION_LIST),
-  payload: import_zod19.z.object({
-    sessions: import_zod19.z.array(SessionSummarySchema)
+  type: import_zod20.z.literal(HostEventType.SESSION_LIST),
+  payload: import_zod20.z.object({
+    sessions: import_zod20.z.array(SessionSummarySchema)
   })
 });
-var SessionCompletedEventSchema = import_zod19.z.object({
+var SessionCompletedEventSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod19.z.literal(HostEventType.SESSION_COMPLETED),
-  payload: import_zod19.z.object({
-    sessionId: import_zod19.z.string(),
-    summary: import_zod19.z.string().optional()
+  type: import_zod20.z.literal(HostEventType.SESSION_COMPLETED),
+  payload: import_zod20.z.object({
+    sessionId: import_zod20.z.string(),
+    summary: import_zod20.z.string().optional()
   })
 });
-var HostEventSchema = import_zod19.z.discriminatedUnion("type", [
+var HostEventSchema = import_zod20.z.discriminatedUnion("type", [
   SessionStateEventSchema,
   TextDeltaEventSchema,
   ToolStartedEventSchema,
@@ -1416,7 +1506,7 @@ function createHostEvent(type, payload) {
 }
 
 // src/protocol/ui-intents.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var UIIntentType = {
   SUBMIT_PROMPT: "submit_prompt",
   STOP_SESSION: "stop_session",
@@ -1426,54 +1516,54 @@ var UIIntentType = {
   CLEAR_SESSION: "clear_session",
   WEBVIEW_READY: "webview_ready"
 };
-var UIIntentTypeSchema = import_zod20.z.enum(UIIntentType);
-var SubmitPromptIntentSchema = import_zod20.z.object({
+var UIIntentTypeSchema = import_zod21.z.enum(UIIntentType);
+var SubmitPromptIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.SUBMIT_PROMPT),
-  payload: import_zod20.z.object({
-    text: import_zod20.z.string().min(1),
+  type: import_zod21.z.literal(UIIntentType.SUBMIT_PROMPT),
+  payload: import_zod21.z.object({
+    text: import_zod21.z.string().min(1),
     context: ContextPayloadSchema.optional()
   })
 });
-var StopSessionIntentSchema = import_zod20.z.object({
+var StopSessionIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.STOP_SESSION),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod21.z.literal(UIIntentType.STOP_SESSION),
+  payload: import_zod21.z.object({
+    sessionId: import_zod21.z.string()
   })
 });
-var ResumeSessionIntentSchema = import_zod20.z.object({
+var ResumeSessionIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.RESUME_SESSION),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod21.z.literal(UIIntentType.RESUME_SESSION),
+  payload: import_zod21.z.object({
+    sessionId: import_zod21.z.string()
   })
 });
-var RequestSessionsIntentSchema = import_zod20.z.object({
+var RequestSessionsIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.REQUEST_SESSIONS),
-  payload: import_zod20.z.object({}).optional()
+  type: import_zod21.z.literal(UIIntentType.REQUEST_SESSIONS),
+  payload: import_zod21.z.object({}).optional()
 });
-var RequestSessionDetailIntentSchema = import_zod20.z.object({
+var RequestSessionDetailIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod21.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
+  payload: import_zod21.z.object({
+    sessionId: import_zod21.z.string()
   })
 });
-var ClearSessionIntentSchema = import_zod20.z.object({
+var ClearSessionIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.CLEAR_SESSION),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string()
+  type: import_zod21.z.literal(UIIntentType.CLEAR_SESSION),
+  payload: import_zod21.z.object({
+    sessionId: import_zod21.z.string()
   })
 });
-var WebviewReadyIntentSchema = import_zod20.z.object({
+var WebviewReadyIntentSchema = import_zod21.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(UIIntentType.WEBVIEW_READY),
-  payload: import_zod20.z.object({}).optional()
+  type: import_zod21.z.literal(UIIntentType.WEBVIEW_READY),
+  payload: import_zod21.z.object({}).optional()
 });
-var UIIntentSchema = import_zod20.z.discriminatedUnion("type", [
+var UIIntentSchema = import_zod21.z.discriminatedUnion("type", [
   SubmitPromptIntentSchema,
   StopSessionIntentSchema,
   ResumeSessionIntentSchema,