@locusai/shared 0.14.4 → 0.15.0

package/dist/index.js

@@ -62,9 +62,11 @@ __export(exports_src, {
   UpdateWorkspaceSchema: () => UpdateWorkspaceSchema,
   UpdateUserSchema: () => UpdateUserSchema,
   UpdateTaskSchema: () => UpdateTaskSchema,
+  UpdateSuggestionStatusSchema: () => UpdateSuggestionStatusSchema,
   UpdateSprintSchema: () => UpdateSprintSchema,
   UpdateSecurityRulesSchema: () => UpdateSecurityRulesSchema,
   UpdateOrganizationSchema: () => UpdateOrganizationSchema,
+  UpdateJobRunSchema: () => UpdateJobRunSchema,
   UpdateDocSchema: () => UpdateDocSchema,
   UpdateDocGroupSchema: () => UpdateDocGroupSchema,
   UpdateAwsInstanceSchema: () => UpdateAwsInstanceSchema,
@@ -90,6 +92,9 @@ __export(exports_src, {
   TaskDeletedPayloadSchema: () => TaskDeletedPayloadSchema,
   TaskCreatedPayloadSchema: () => TaskCreatedPayloadSchema,
   TERMINAL_STATUSES: () => TERMINAL_STATUSES,
+  SuggestionType: () => SuggestionType,
+  SuggestionStatus: () => SuggestionStatus,
+  SuggestionSchema: () => SuggestionSchema,
   SuccessResponseSchema: () => SuccessResponseSchema,
   SubmitPromptIntentSchema: () => SubmitPromptIntentSchema,
   StopSessionIntentSchema: () => StopSessionIntentSchema,
@@ -113,8 +118,10 @@ __export(exports_src, {
   SessionCompletedEventSchema: () => SessionCompletedEventSchema,
   SelectionContextSchema: () => SelectionContextSchema,
   SaveAwsCredentialsSchema: () => SaveAwsCredentialsSchema,
+  SUGGESTION_TTL_HOURS: () => SUGGESTION_TTL_HOURS,
   STALE_AGENT_TIMEOUT_MS: () => STALE_AGENT_TIMEOUT_MS,
   SESSION_TRANSITIONS: () => SESSION_TRANSITIONS,
+  RiskLevel: () => RiskLevel,
   ResumeSessionIntentSchema: () => ResumeSessionIntentSchema,
   RequestSessionsIntentSchema: () => RequestSessionsIntentSchema,
   RequestSessionDetailIntentSchema: () => RequestSessionDetailIntentSchema,
@@ -143,6 +150,13 @@ __export(exports_src, {
   MemberAddedPayloadSchema: () => MemberAddedPayloadSchema,
   LockSchema: () => LockSchema,
   JwtAuthUserSchema: () => JwtAuthUserSchema,
+  JobType: () => JobType,
+  JobStatus: () => JobStatus,
+  JobSeverity: () => JobSeverity,
+  JobScheduleSchema: () => JobScheduleSchema,
+  JobRunSchema: () => JobRunSchema,
+  JobRunResultSchema: () => JobRunResultSchema,
+  JobConfigSchema: () => JobConfigSchema,
   JWTPayloadSchema: () => JWTPayloadSchema,
   InvitationsResponseSchema: () => InvitationsResponseSchema,
   InvitationVerifyParamSchema: () => InvitationVerifyParamSchema,
@@ -178,11 +192,14 @@ __export(exports_src, {
   DocGroupResponseSchema: () => DocGroupResponseSchema,
   DocGroupIdParamSchema: () => DocGroupIdParamSchema,
   DispatchTaskSchema: () => DispatchTaskSchema,
+  DEFAULT_AUTONOMY_RULES: () => DEFAULT_AUTONOMY_RULES,
   CreateWorkspaceSchema: () => CreateWorkspaceSchema,
   CreateUserSchema: () => CreateUserSchema,
   CreateTaskSchema: () => CreateTaskSchema,
+  CreateSuggestionSchema: () => CreateSuggestionSchema,
   CreateSprintSchema: () => CreateSprintSchema,
   CreateOrganizationSchema: () => CreateOrganizationSchema,
+  CreateJobRunSchema: () => CreateJobRunSchema,
   CreateInvitationSchema: () => CreateInvitationSchema,
   CreateDocSchema: () => CreateDocSchema,
   CreateDocGroupSchema: () => CreateDocGroupSchema,
@@ -209,10 +226,12 @@ __export(exports_src, {
   CiRanPayloadSchema: () => CiRanPayloadSchema,
   ChecklistItemSchema: () => ChecklistItemSchema,
   ChecklistInitializedPayloadSchema: () => ChecklistInitializedPayloadSchema,
+  ChangeCategory: () => ChangeCategory,
   BaseEntitySchema: () => BaseEntitySchema,
   AwsRegion: () => AwsRegion,
   AwsInstanceSchema: () => AwsInstanceSchema,
   AwsCredentialsSchema: () => AwsCredentialsSchema,
+  AutonomyRuleSchema: () => AutonomyRuleSchema,
   AuthenticatedUserSchema: () => AuthenticatedUserSchema,
   AuthResponseSchema: () => AuthResponseSchema,
   AuthContextSchema: () => AuthContextSchema,
@@ -684,93 +703,160 @@ 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/aws-instance.ts
+// src/models/autonomy.ts
 var import_zod6 = require("zod");
+var RiskLevel;
+((RiskLevel2) => {
+  RiskLevel2["LOW"] = "LOW";
+  RiskLevel2["HIGH"] = "HIGH";
+})(RiskLevel ||= {});
+var ChangeCategory;
+((ChangeCategory2) => {
+  ChangeCategory2["FIX"] = "FIX";
+  ChangeCategory2["REFACTOR"] = "REFACTOR";
+  ChangeCategory2["STYLE"] = "STYLE";
+  ChangeCategory2["DEPENDENCY"] = "DEPENDENCY";
+  ChangeCategory2["FEATURE"] = "FEATURE";
+  ChangeCategory2["ARCHITECTURE"] = "ARCHITECTURE";
+  ChangeCategory2["DATABASE"] = "DATABASE";
+  ChangeCategory2["AUTH"] = "AUTH";
+  ChangeCategory2["API"] = "API";
+})(ChangeCategory ||= {});
+var AutonomyRuleSchema = import_zod6.z.object({
+  category: import_zod6.z.enum(ChangeCategory),
+  riskLevel: import_zod6.z.enum(RiskLevel),
+  autoExecute: import_zod6.z.boolean()
+});
+var DEFAULT_AUTONOMY_RULES = [
+  { category: "FIX" /* FIX */, riskLevel: "LOW" /* LOW */, autoExecute: true },
+  {
+    category: "REFACTOR" /* REFACTOR */,
+    riskLevel: "LOW" /* LOW */,
+    autoExecute: true
+  },
+  {
+    category: "STYLE" /* STYLE */,
+    riskLevel: "LOW" /* LOW */,
+    autoExecute: true
+  },
+  {
+    category: "DEPENDENCY" /* DEPENDENCY */,
+    riskLevel: "LOW" /* LOW */,
+    autoExecute: true
+  },
+  {
+    category: "FEATURE" /* FEATURE */,
+    riskLevel: "HIGH" /* HIGH */,
+    autoExecute: false
+  },
+  {
+    category: "ARCHITECTURE" /* ARCHITECTURE */,
+    riskLevel: "HIGH" /* HIGH */,
+    autoExecute: false
+  },
+  {
+    category: "DATABASE" /* DATABASE */,
+    riskLevel: "HIGH" /* HIGH */,
+    autoExecute: false
+  },
+  {
+    category: "AUTH" /* AUTH */,
+    riskLevel: "HIGH" /* HIGH */,
+    autoExecute: false
+  },
+  {
+    category: "API" /* API */,
+    riskLevel: "HIGH" /* HIGH */,
+    autoExecute: false
+  }
+];
+// src/models/aws-instance.ts
+var import_zod7 = require("zod");
 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 AwsCredentialsSchema = import_zod7.z.object({
+  accessKeyId: import_zod7.z.string().min(1),
+  secretAccessKey: import_zod7.z.string().min(1),
+  region: import_zod7.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 IntegrationSchema = import_zod7.z.object({
+  name: import_zod7.z.string(),
+  config: import_zod7.z.record(import_zod7.z.string(), import_zod7.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(),
-  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")
+  workspaceId: import_zod7.z.uuid(),
+  instanceId: import_zod7.z.string(),
+  status: import_zod7.z.enum(InstanceStatus),
+  instanceType: import_zod7.z.enum(["t3.micro", "t3.small", "t3.medium"]),
+  region: import_zod7.z.enum(AwsRegion).default("us-east-1" /* US_EAST_1 */),
+  publicIp: import_zod7.z.string().nullable().optional(),
+  launchTime: import_zod7.z.union([import_zod7.z.date(), import_zod7.z.number()]).nullable().optional(),
+  repoUrl: import_zod7.z.string().nullable().optional(),
+  integrations: import_zod7.z.array(IntegrationSchema).default([])
+});
+var CreateAwsInstanceSchema = import_zod7.z.object({
+  workspaceId: import_zod7.z.uuid(),
+  instanceType: import_zod7.z.enum(["t3.micro", "t3.small", "t3.medium"]).default("t3.micro"),
+  region: import_zod7.z.enum(AwsRegion).default("us-east-1" /* US_EAST_1 */),
+  repoUrl: import_zod7.z.string().optional(),
+  integrations: import_zod7.z.array(IntegrationSchema).optional().default([])
+});
+var UpdateAwsInstanceSchema = import_zod7.z.object({
+  status: import_zod7.z.enum(InstanceStatus).optional(),
+  instanceType: import_zod7.z.enum(["t3.micro", "t3.small", "t3.medium"]).optional(),
+  publicIp: import_zod7.z.string().nullable().optional(),
+  launchTime: import_zod7.z.union([import_zod7.z.date(), import_zod7.z.number()]).nullable().optional(),
+  repoUrl: import_zod7.z.string().nullable().optional(),
+  integrations: import_zod7.z.array(IntegrationSchema).optional()
+});
+var SaveAwsCredentialsSchema = import_zod7.z.object({
+  accessKeyId: import_zod7.z.string().min(16),
+  secretAccessKey: import_zod7.z.string().min(1),
+  region: import_zod7.z.string().default("us-east-1")
+});
+var ProvisionAwsInstanceSchema = import_zod7.z.object({
+  repoUrl: import_zod7.z.string().min(1),
+  githubToken: import_zod7.z.string().min(1),
+  instanceType: import_zod7.z.enum(["t3.micro", "t3.small", "t3.medium"]).default("t3.small"),
+  integrations: import_zod7.z.array(IntegrationSchema).optional().default([])
+});
+var InstanceActionBodySchema = import_zod7.z.object({
+  action: import_zod7.z.nativeEnum(InstanceAction)
+});
+var InstanceIdParamSchema = import_zod7.z.object({
+  workspaceId: import_zod7.z.string().uuid("Invalid Workspace ID"),
+  instanceId: import_zod7.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)"))
+var UpdateSecurityRulesSchema = import_zod7.z.object({
+  allowedIps: import_zod7.z.array(import_zod7.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()
+var import_zod8 = require("zod");
+var RecordCiSchema = import_zod8.z.object({
+  taskId: import_zod8.z.uuid(),
+  workspaceId: import_zod8.z.uuid(),
+  result: import_zod8.z.object({
+    ok: import_zod8.z.boolean(),
+    summary: import_zod8.z.string(),
+    commands: import_zod8.z.array(import_zod8.z.object({
+      cmd: import_zod8.z.string(),
+      exitCode: import_zod8.z.number(),
+      durationMs: import_zod8.z.number().optional(),
+      error: import_zod8.z.string().optional()
     })),
-    preset: import_zod7.z.string()
+    preset: import_zod8.z.string()
   })
 });
 // src/models/doc.ts
-var import_zod8 = require("zod");
-var DocGroupSchemaForDoc = import_zod8.z.object({
-  id: import_zod8.z.uuid(),
-  name: import_zod8.z.string()
+var import_zod9 = require("zod");
+var DocGroupSchemaForDoc = import_zod9.z.object({
+  id: import_zod9.z.uuid(),
+  name: import_zod9.z.string()
 });
 var DocType;
 ((DocType2) => {
@@ -781,170 +867,234 @@ var DocType;
   DocType2["API_DESIGN"] = "API_DESIGN";
 })(DocType ||= {});
 var DocSchema = BaseEntitySchema.extend({
-  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 */),
+  workspaceId: import_zod9.z.uuid(),
+  groupId: import_zod9.z.uuid().nullable().optional(),
+  title: import_zod9.z.string().min(1, "Title is required"),
+  content: import_zod9.z.string().default(""),
+  type: import_zod9.z.enum(DocType).default("GENERAL" /* GENERAL */),
   group: DocGroupSchemaForDoc.nullable().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 CreateDocSchema = import_zod9.z.object({
+  title: import_zod9.z.string().min(1, "Title is required"),
+  content: import_zod9.z.string().optional(),
+  type: import_zod9.z.enum(DocType).optional().default("GENERAL" /* GENERAL */),
+  groupId: import_zod9.z.string().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 UpdateDocSchema = import_zod9.z.object({
+  title: import_zod9.z.string().min(1).optional(),
+  content: import_zod9.z.string().optional(),
+  type: import_zod9.z.enum(DocType).optional(),
+  groupId: import_zod9.z.string().nullable().optional()
 });
-var DocResponseSchema = import_zod8.z.object({
+var DocResponseSchema = import_zod9.z.object({
   doc: DocSchema
 });
-var DocsResponseSchema = import_zod8.z.object({
-  docs: import_zod8.z.array(DocSchema)
+var DocsResponseSchema = import_zod9.z.object({
+  docs: import_zod9.z.array(DocSchema)
 });
-var DocIdParamSchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid("Invalid Doc ID")
+var DocIdParamSchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid("Invalid Doc ID")
 });
-var DocQuerySchema = import_zod8.z.object({
-  workspaceId: import_zod8.z.string().uuid("Invalid Workspace ID").optional()
+var DocQuerySchema = import_zod9.z.object({
+  workspaceId: import_zod9.z.string().uuid("Invalid Workspace ID").optional()
 });
 // src/models/doc-group.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var DocGroupSchema = BaseEntitySchema.extend({
-  workspaceId: import_zod9.z.uuid(),
-  name: import_zod9.z.string().min(1, "Name is required"),
-  order: import_zod9.z.number().default(0)
+  workspaceId: import_zod10.z.uuid(),
+  name: import_zod10.z.string().min(1, "Name is required"),
+  order: import_zod10.z.number().default(0)
 });
-var CreateDocGroupSchema = import_zod9.z.object({
-  name: import_zod9.z.string().min(1, "Name is required"),
-  order: import_zod9.z.number().optional()
+var CreateDocGroupSchema = import_zod10.z.object({
+  name: import_zod10.z.string().min(1, "Name is required"),
+  order: import_zod10.z.number().optional()
 });
-var UpdateDocGroupSchema = import_zod9.z.object({
-  name: import_zod9.z.string().min(1).optional(),
-  order: import_zod9.z.number().optional()
+var UpdateDocGroupSchema = import_zod10.z.object({
+  name: import_zod10.z.string().min(1).optional(),
+  order: import_zod10.z.number().optional()
 });
-var DocGroupResponseSchema = import_zod9.z.object({
+var DocGroupResponseSchema = import_zod10.z.object({
   group: DocGroupSchema
 });
-var DocGroupsResponseSchema = import_zod9.z.object({
-  groups: import_zod9.z.array(DocGroupSchema)
+var DocGroupsResponseSchema = import_zod10.z.object({
+  groups: import_zod10.z.array(DocGroupSchema)
 });
-var DocGroupIdParamSchema = import_zod9.z.object({
-  id: import_zod9.z.string().uuid("Invalid Group ID")
+var DocGroupIdParamSchema = import_zod10.z.object({
+  id: import_zod10.z.string().uuid("Invalid Group ID")
 });
 // src/models/invitation.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var InvitationSchema = BaseEntitySchema.extend({
-  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()
+  orgId: import_zod11.z.string().uuid("Invalid Organization ID"),
+  email: import_zod11.z.string().email("Invalid email address"),
+  role: import_zod11.z.enum(MembershipRole),
+  token: import_zod11.z.string(),
+  expiresAt: import_zod11.z.number(),
+  acceptedAt: import_zod11.z.number().nullable().optional(),
+  invitedBy: import_zod11.z.uuid()
 });
-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 CreateInvitationSchema = import_zod11.z.object({
+  orgId: import_zod11.z.string().uuid("Invalid Organization ID"),
+  email: import_zod11.z.string().email("Invalid email address"),
+  role: import_zod11.z.enum(MembershipRole).default("MEMBER" /* MEMBER */)
 });
-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 AcceptInvitationSchema = import_zod11.z.object({
+  token: import_zod11.z.string().min(1, "Invitation token is required"),
+  name: import_zod11.z.string().min(1, "Name is required").optional()
 });
-var InvitationIdParamSchema = import_zod10.z.object({
-  id: import_zod10.z.string().uuid("Invalid Invitation ID")
+var InvitationIdParamSchema = import_zod11.z.object({
+  id: import_zod11.z.string().uuid("Invalid Invitation ID")
 });
-var InvitationVerifyParamSchema = import_zod10.z.object({
-  token: import_zod10.z.string().min(1, "Token required")
+var InvitationVerifyParamSchema = import_zod11.z.object({
+  token: import_zod11.z.string().min(1, "Token required")
 });
-var InvitationQuerySchema = import_zod10.z.object({
-  orgId: import_zod10.z.string().uuid("Invalid Organization ID").optional()
+var InvitationQuerySchema = import_zod11.z.object({
+  orgId: import_zod11.z.string().uuid("Invalid Organization ID").optional()
 });
-var InvitationResponseSchema = import_zod10.z.object({
+var InvitationResponseSchema = import_zod11.z.object({
   invitation: InvitationSchema,
-  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()
+  userExists: import_zod11.z.boolean().optional()
+});
+var InvitationsResponseSchema = import_zod11.z.object({
+  invitations: import_zod11.z.array(InvitationSchema)
+});
+var AcceptInvitationResponseSchema = import_zod11.z.object({
+  membership: import_zod11.z.object({
+    id: import_zod11.z.uuid(),
+    userId: import_zod11.z.uuid(),
+    orgId: import_zod11.z.uuid(),
+    role: import_zod11.z.enum(MembershipRole),
+    createdAt: import_zod11.z.number()
   })
 });
+// src/models/job.ts
+var import_zod12 = require("zod");
+var JobType;
+((JobType2) => {
+  JobType2["LINT_SCAN"] = "LINT_SCAN";
+  JobType2["DEPENDENCY_CHECK"] = "DEPENDENCY_CHECK";
+  JobType2["TODO_CLEANUP"] = "TODO_CLEANUP";
+  JobType2["FLAKY_TEST_DETECTION"] = "FLAKY_TEST_DETECTION";
+  JobType2["CUSTOM"] = "CUSTOM";
+})(JobType ||= {});
+var JobStatus;
+((JobStatus2) => {
+  JobStatus2["IDLE"] = "IDLE";
+  JobStatus2["RUNNING"] = "RUNNING";
+  JobStatus2["COMPLETED"] = "COMPLETED";
+  JobStatus2["FAILED"] = "FAILED";
+  JobStatus2["CANCELLED"] = "CANCELLED";
+})(JobStatus ||= {});
+var JobSeverity;
+((JobSeverity2) => {
+  JobSeverity2["AUTO_EXECUTE"] = "AUTO_EXECUTE";
+  JobSeverity2["REQUIRE_APPROVAL"] = "REQUIRE_APPROVAL";
+})(JobSeverity ||= {});
+var JobScheduleSchema = import_zod12.z.object({
+  cronExpression: import_zod12.z.string(),
+  enabled: import_zod12.z.boolean(),
+  lastRunAt: import_zod12.z.string().optional(),
+  nextRunAt: import_zod12.z.string().optional()
+});
+var JobConfigSchema = import_zod12.z.object({
+  type: import_zod12.z.enum(JobType),
+  schedule: JobScheduleSchema,
+  severity: import_zod12.z.enum(JobSeverity),
+  enabled: import_zod12.z.boolean(),
+  options: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any())
+});
+var JobRunResultSchema = import_zod12.z.object({
+  summary: import_zod12.z.string(),
+  filesChanged: import_zod12.z.number(),
+  prUrl: import_zod12.z.string().optional(),
+  errors: import_zod12.z.array(import_zod12.z.string()).optional()
+});
+var JobRunSchema = import_zod12.z.object({
+  id: import_zod12.z.string(),
+  jobType: import_zod12.z.enum(JobType),
+  status: import_zod12.z.enum(JobStatus),
+  startedAt: import_zod12.z.string(),
+  completedAt: import_zod12.z.string().optional(),
+  result: JobRunResultSchema.optional(),
+  workspaceId: import_zod12.z.string()
+});
+var CreateJobRunSchema = import_zod12.z.object({
+  jobType: import_zod12.z.enum(JobType),
+  status: import_zod12.z.enum(JobStatus).optional().default("RUNNING" /* RUNNING */),
+  startedAt: import_zod12.z.string().optional(),
+  error: import_zod12.z.string().optional(),
+  result: JobRunResultSchema.optional()
+});
+var UpdateJobRunSchema = import_zod12.z.object({
+  status: import_zod12.z.enum(JobStatus).optional(),
+  result: JobRunResultSchema.optional(),
+  error: import_zod12.z.string().nullable().optional(),
+  completedAt: import_zod12.z.string().optional()
+});
 // src/models/organization.ts
-var import_zod11 = require("zod");
+var import_zod13 = require("zod");
 var OrganizationSchema = BaseEntitySchema.extend({
-  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(""))
+  name: import_zod13.z.string().min(1, "Name is required").max(100),
+  avatarUrl: import_zod13.z.string().url("Invalid avatar URL").nullable().optional().or(import_zod13.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 CreateOrganizationSchema = import_zod13.z.object({
+  name: import_zod13.z.string().min(1, "Name is required").max(100),
+  avatarUrl: import_zod13.z.string().url("Invalid avatar URL").optional().or(import_zod13.z.literal(""))
 });
 var UpdateOrganizationSchema = OrganizationSchema.partial().omit({
   id: true,
   createdAt: true,
   updatedAt: true
 });
-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 AddMemberSchema = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid("Invalid User ID"),
+  role: import_zod13.z.enum(["ADMIN", "MEMBER"]).default("MEMBER")
+});
+var MembershipWithUserSchema = import_zod13.z.object({
+  id: import_zod13.z.uuid(),
+  userId: import_zod13.z.uuid(),
+  orgId: import_zod13.z.uuid(),
+  role: import_zod13.z.string(),
+  createdAt: import_zod13.z.number(),
+  user: import_zod13.z.object({
+    id: import_zod13.z.uuid(),
+    email: import_zod13.z.string().email(),
+    name: import_zod13.z.string(),
+    avatarUrl: import_zod13.z.string().url().nullable().optional()
   })
 });
-var OrgIdParamSchema = import_zod11.z.object({
-  orgId: import_zod11.z.string().uuid("Invalid Organization ID")
+var OrgIdParamSchema = import_zod13.z.object({
+  orgId: import_zod13.z.string().uuid("Invalid Organization ID")
 });
-var MembershipIdParamSchema = import_zod11.z.object({
-  id: import_zod11.z.string().uuid("Invalid Membership ID")
+var MembershipIdParamSchema = import_zod13.z.object({
+  id: import_zod13.z.string().uuid("Invalid Membership ID")
 });
-var OrganizationResponseSchema = import_zod11.z.object({
+var OrganizationResponseSchema = import_zod13.z.object({
   organization: OrganizationSchema
 });
-var OrganizationsResponseSchema = import_zod11.z.object({
-  organizations: import_zod11.z.array(OrganizationSchema)
+var OrganizationsResponseSchema = import_zod13.z.object({
+  organizations: import_zod13.z.array(OrganizationSchema)
 });
-var MembersResponseSchema = import_zod11.z.object({
-  members: import_zod11.z.array(MembershipWithUserSchema)
+var MembersResponseSchema = import_zod13.z.object({
+  members: import_zod13.z.array(MembershipWithUserSchema)
 });
-var MembershipResponseSchema = import_zod11.z.object({
+var MembershipResponseSchema = import_zod13.z.object({
   membership: MembershipWithUserSchema
 });
 // src/models/sprint.ts
-var import_zod12 = require("zod");
+var import_zod14 = require("zod");
 var SprintSchema = BaseEntitySchema.extend({
-  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_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()
+  workspaceId: import_zod14.z.uuid().nullable().optional(),
+  name: import_zod14.z.string().min(1, "Name is required").max(100),
+  status: import_zod14.z.enum(SprintStatus),
+  startDate: import_zod14.z.union([import_zod14.z.date(), import_zod14.z.number()]).nullable().optional(),
+  endDate: import_zod14.z.union([import_zod14.z.date(), import_zod14.z.number()]).nullable().optional()
+});
+var CreateSprintSchema = import_zod14.z.object({
+  name: import_zod14.z.string().min(1, "Name is required").max(100),
+  startDate: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional(),
+  endDate: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional(),
+  taskIds: import_zod14.z.array(import_zod14.z.string()).optional()
 });
 var UpdateSprintSchema = SprintSchema.partial().omit({
   id: true,
@@ -953,60 +1103,102 @@ var UpdateSprintSchema = SprintSchema.partial().omit({
   startDate: true,
   endDate: true
 }).extend({
-  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()
+  name: import_zod14.z.string().min(1).max(100).optional(),
+  startDate: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().nullable(),
+  endDate: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().nullable()
 });
-var SprintIdParamSchema = import_zod12.z.object({
-  id: import_zod12.z.string().uuid("Invalid Sprint ID")
+var SprintIdParamSchema = import_zod14.z.object({
+  id: import_zod14.z.string().uuid("Invalid Sprint ID")
 });
-var SprintQuerySchema = import_zod12.z.object({});
-var SprintResponseSchema = import_zod12.z.object({
+var SprintQuerySchema = import_zod14.z.object({});
+var SprintResponseSchema = import_zod14.z.object({
   sprint: SprintSchema
 });
-var SprintsResponseSchema = import_zod12.z.object({
-  sprints: import_zod12.z.array(SprintSchema)
+var SprintsResponseSchema = import_zod14.z.object({
+  sprints: import_zod14.z.array(SprintSchema)
+});
+// src/models/suggestion.ts
+var import_zod15 = require("zod");
+var SuggestionStatus;
+((SuggestionStatus2) => {
+  SuggestionStatus2["NEW"] = "NEW";
+  SuggestionStatus2["NOTIFIED"] = "NOTIFIED";
+  SuggestionStatus2["ACTED_ON"] = "ACTED_ON";
+  SuggestionStatus2["SKIPPED"] = "SKIPPED";
+  SuggestionStatus2["EXPIRED"] = "EXPIRED";
+})(SuggestionStatus ||= {});
+var SuggestionType;
+((SuggestionType2) => {
+  SuggestionType2["CODE_FIX"] = "CODE_FIX";
+  SuggestionType2["DEPENDENCY_UPDATE"] = "DEPENDENCY_UPDATE";
+  SuggestionType2["NEXT_STEP"] = "NEXT_STEP";
+  SuggestionType2["REFACTOR"] = "REFACTOR";
+  SuggestionType2["TEST_FIX"] = "TEST_FIX";
+})(SuggestionType ||= {});
+var SUGGESTION_TTL_HOURS = 24;
+var SuggestionSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  type: import_zod15.z.enum(SuggestionType),
+  status: import_zod15.z.enum(SuggestionStatus),
+  title: import_zod15.z.string(),
+  description: import_zod15.z.string(),
+  jobRunId: import_zod15.z.string().optional(),
+  workspaceId: import_zod15.z.string(),
+  createdAt: import_zod15.z.string(),
+  expiresAt: import_zod15.z.string(),
+  metadata: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).optional()
+});
+var CreateSuggestionSchema = import_zod15.z.object({
+  type: import_zod15.z.enum(SuggestionType),
+  title: import_zod15.z.string().min(1, "Title is required"),
+  description: import_zod15.z.string().min(1, "Description is required"),
+  jobRunId: import_zod15.z.string().uuid().optional(),
+  metadata: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).optional(),
+  expiresAt: import_zod15.z.string().optional()
+});
+var UpdateSuggestionStatusSchema = import_zod15.z.object({
+  status: import_zod15.z.enum(SuggestionStatus)
 });
 // src/models/task.ts
-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 import_zod16 = require("zod");
+var AcceptanceItemSchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  text: import_zod16.z.string(),
+  done: import_zod16.z.boolean()
 });
 var TaskSchema = BaseEntitySchema.extend({
-  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()
+  workspaceId: import_zod16.z.uuid().nullable().optional(),
+  title: import_zod16.z.string().min(1, "Title is required").max(200),
+  description: import_zod16.z.string(),
+  status: import_zod16.z.enum(TaskStatus),
+  priority: import_zod16.z.enum(TaskPriority),
+  labels: import_zod16.z.array(import_zod16.z.string()),
+  assigneeRole: import_zod16.z.enum(AssigneeRole).nullable().optional(),
+  assignedTo: import_zod16.z.string().nullable().optional(),
+  sprintId: import_zod16.z.uuid().nullable().optional(),
+  parentId: import_zod16.z.uuid().nullable().optional(),
+  dueDate: import_zod16.z.union([import_zod16.z.string(), import_zod16.z.number()]).nullable().optional(),
+  prUrl: import_zod16.z.string().nullable().optional(),
+  acceptanceChecklist: import_zod16.z.array(AcceptanceItemSchema),
+  comments: import_zod16.z.array(CommentSchema).optional(),
+  activityLog: import_zod16.z.array(EventSchema).optional(),
+  docs: import_zod16.z.array(DocSchema),
+  order: import_zod16.z.number().optional()
+});
+var CreateTaskSchema = import_zod16.z.object({
+  title: import_zod16.z.string().min(1, "Title is required").max(200),
+  description: import_zod16.z.string().optional().default(""),
+  status: import_zod16.z.enum(TaskStatus).optional().default("BACKLOG" /* BACKLOG */),
+  priority: import_zod16.z.enum(TaskPriority).optional().default("MEDIUM" /* MEDIUM */),
+  labels: import_zod16.z.array(import_zod16.z.string()).optional().default([]),
+  assigneeRole: import_zod16.z.enum(AssigneeRole).optional(),
+  assignedTo: import_zod16.z.string().nullable().optional(),
+  dueDate: import_zod16.z.union([import_zod16.z.string(), import_zod16.z.number()]).nullable().optional(),
+  parentId: import_zod16.z.string().nullable().optional(),
+  sprintId: import_zod16.z.string().nullable().optional(),
+  acceptanceChecklist: import_zod16.z.array(AcceptanceItemSchema).optional(),
+  docIds: import_zod16.z.array(import_zod16.z.string()).optional(),
+  order: import_zod16.z.number().optional()
 });
 var UpdateTaskSchema = TaskSchema.partial().omit({
   id: true,
@@ -1018,44 +1210,44 @@ var UpdateTaskSchema = TaskSchema.partial().omit({
   activityLog: true,
   docs: true
 }).extend({
-  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()
+  title: import_zod16.z.string().min(1).max(200).optional(),
+  dueDate: import_zod16.z.union([import_zod16.z.string(), import_zod16.z.number()]).optional().nullable(),
+  prUrl: import_zod16.z.string().nullable().optional(),
+  acceptanceChecklist: import_zod16.z.array(AcceptanceItemSchema).optional(),
+  docIds: import_zod16.z.array(import_zod16.z.string()).optional()
 });
-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 AddCommentSchema = import_zod16.z.object({
+  author: import_zod16.z.string().min(1, "Author is required"),
+  text: import_zod16.z.string().min(1, "Comment text is required")
 });
-var DispatchTaskSchema = import_zod13.z.object({
-  workerId: import_zod13.z.string().optional(),
-  sprintId: import_zod13.z.uuid().optional().nullable()
+var DispatchTaskSchema = import_zod16.z.object({
+  workerId: import_zod16.z.string().optional(),
+  sprintId: import_zod16.z.uuid().optional().nullable()
 });
-var TaskIdParamSchema = import_zod13.z.object({
-  id: import_zod13.z.string().uuid("Invalid Task ID")
+var TaskIdParamSchema = import_zod16.z.object({
+  id: import_zod16.z.string().uuid("Invalid Task ID")
 });
-var TaskQuerySchema = import_zod13.z.object({});
-var TaskResponseSchema = import_zod13.z.object({
+var TaskQuerySchema = import_zod16.z.object({});
+var TaskResponseSchema = import_zod16.z.object({
   task: TaskSchema
 });
-var TasksResponseSchema = import_zod13.z.object({
-  tasks: import_zod13.z.array(TaskSchema)
+var TasksResponseSchema = import_zod16.z.object({
+  tasks: import_zod16.z.array(TaskSchema)
 });
 // src/models/workspace.ts
-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 import_zod17 = require("zod");
+var ChecklistItemSchema = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  text: import_zod17.z.string(),
+  done: import_zod17.z.boolean()
 });
 var WorkspaceSchema = BaseEntitySchema.extend({
-  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()
+  orgId: import_zod17.z.uuid(),
+  name: import_zod17.z.string().min(1, "Name is required").max(100),
+  defaultChecklist: import_zod17.z.array(ChecklistItemSchema).nullable().optional()
 });
-var CreateWorkspaceSchema = import_zod14.z.object({
-  name: import_zod14.z.string().min(1, "Name is required").max(100)
+var CreateWorkspaceSchema = import_zod17.z.object({
+  name: import_zod17.z.string().min(1, "Name is required").max(100)
 });
 var UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
   id: true,
@@ -1063,45 +1255,45 @@ var UpdateWorkspaceSchema = WorkspaceSchema.partial().omit({
   createdAt: true,
   updatedAt: true
 });
-var AddWorkspaceMemberSchema = import_zod14.z.object({
-  userId: import_zod14.z.string().uuid("Invalid User ID"),
-  role: import_zod14.z.string().optional()
+var AddWorkspaceMemberSchema = import_zod17.z.object({
+  userId: import_zod17.z.string().uuid("Invalid User ID"),
+  role: import_zod17.z.string().optional()
 });
-var WorkspaceIdParamSchema = import_zod14.z.object({
-  workspaceId: import_zod14.z.string().uuid("Invalid Workspace ID")
+var WorkspaceIdParamSchema = import_zod17.z.object({
+  workspaceId: import_zod17.z.string().uuid("Invalid Workspace 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 WorkspaceAndUserParamSchema = import_zod17.z.object({
+  workspaceId: import_zod17.z.string().uuid("Invalid Workspace ID"),
+  userId: import_zod17.z.string().uuid("Invalid User ID")
 });
-var WorkspaceResponseSchema = import_zod14.z.object({
+var WorkspaceResponseSchema = import_zod17.z.object({
   workspace: WorkspaceSchema
 });
-var WorkspacesResponseSchema = import_zod14.z.object({
-  workspaces: import_zod14.z.array(WorkspaceSchema)
+var WorkspacesResponseSchema = import_zod17.z.object({
+  workspaces: import_zod17.z.array(WorkspaceSchema)
 });
-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 WorkspaceStatsSchema = import_zod17.z.object({
+  workspaceName: import_zod17.z.string(),
+  taskCounts: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.number()),
+  memberCount: import_zod17.z.number()
 });
-var WorkspaceStatsResponseSchema = import_zod14.z.object({
+var WorkspaceStatsResponseSchema = import_zod17.z.object({
   stats: WorkspaceStatsSchema
 });
 // src/protocol/cli-stream.ts
-var import_zod17 = require("zod");
+var import_zod20 = require("zod");
 
 // src/protocol/envelope.ts
-var import_zod15 = require("zod");
+var import_zod18 = require("zod");
 var PROTOCOL_VERSION = 1;
-var ProtocolVersionSchema = import_zod15.z.literal(PROTOCOL_VERSION);
-var ProtocolEnvelopeSchema = import_zod15.z.object({
+var ProtocolVersionSchema = import_zod18.z.literal(PROTOCOL_VERSION);
+var ProtocolEnvelopeSchema = import_zod18.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod15.z.string()
+  type: import_zod18.z.string()
 });
 
 // src/protocol/errors.ts
-var import_zod16 = require("zod");
+var import_zod19 = require("zod");
 var ProtocolErrorCode = {
   CLI_NOT_FOUND: "CLI_NOT_FOUND",
   AUTH_EXPIRED: "AUTH_EXPIRED",
@@ -1112,12 +1304,12 @@ var ProtocolErrorCode = {
   SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
   UNKNOWN: "UNKNOWN"
 };
-var ProtocolErrorCodeSchema = import_zod16.z.enum(ProtocolErrorCode);
-var ProtocolErrorSchema = import_zod16.z.object({
+var ProtocolErrorCodeSchema = import_zod19.z.enum(ProtocolErrorCode);
+var ProtocolErrorSchema = import_zod19.z.object({
   code: ProtocolErrorCodeSchema,
-  message: import_zod16.z.string(),
-  details: import_zod16.z.unknown().optional(),
-  recoverable: import_zod16.z.boolean()
+  message: import_zod19.z.string(),
+  details: import_zod19.z.unknown().optional(),
+  recoverable: import_zod19.z.boolean()
 });
 
 // src/protocol/cli-stream.ts
@@ -1131,75 +1323,75 @@ var CliStreamEventType = {
   ERROR: "error",
   DONE: "done"
 };
-var CliStreamEventTypeSchema = import_zod17.z.enum(CliStreamEventType);
-var CliStreamBaseSchema = import_zod17.z.object({
+var CliStreamEventTypeSchema = import_zod20.z.enum(CliStreamEventType);
+var CliStreamBaseSchema = import_zod20.z.object({
   protocol: ProtocolVersionSchema,
-  sessionId: import_zod17.z.string(),
-  timestamp: import_zod17.z.number()
+  sessionId: import_zod20.z.string(),
+  timestamp: import_zod20.z.number()
 });
 var CliStartEventSchema = CliStreamBaseSchema.extend({
-  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()
+  type: import_zod20.z.literal(CliStreamEventType.START),
+  payload: import_zod20.z.object({
+    command: import_zod20.z.string(),
+    model: import_zod20.z.string().optional(),
+    provider: import_zod20.z.string().optional(),
+    cwd: import_zod20.z.string().optional()
   })
 });
 var CliTextDeltaEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod17.z.literal(CliStreamEventType.TEXT_DELTA),
-  payload: import_zod17.z.object({
-    content: import_zod17.z.string()
+  type: import_zod20.z.literal(CliStreamEventType.TEXT_DELTA),
+  payload: import_zod20.z.object({
+    content: import_zod20.z.string()
   })
 });
 var CliThinkingEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod17.z.literal(CliStreamEventType.THINKING),
-  payload: import_zod17.z.object({
-    content: import_zod17.z.string().optional()
+  type: import_zod20.z.literal(CliStreamEventType.THINKING),
+  payload: import_zod20.z.object({
+    content: import_zod20.z.string().optional()
   })
 });
 var CliToolStartedEventSchema = CliStreamBaseSchema.extend({
-  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()
+  type: import_zod20.z.literal(CliStreamEventType.TOOL_STARTED),
+  payload: import_zod20.z.object({
+    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 CliToolCompletedEventSchema = CliStreamBaseSchema.extend({
-  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()
+  type: import_zod20.z.literal(CliStreamEventType.TOOL_COMPLETED),
+  payload: import_zod20.z.object({
+    tool: import_zod20.z.string(),
+    toolId: import_zod20.z.string().optional(),
+    success: import_zod20.z.boolean(),
+    duration: import_zod20.z.number().optional(),
+    error: import_zod20.z.string().optional()
   })
 });
 var CliStatusEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod17.z.literal(CliStreamEventType.STATUS),
-  payload: import_zod17.z.object({
-    status: import_zod17.z.string(),
-    message: import_zod17.z.string().optional()
+  type: import_zod20.z.literal(CliStreamEventType.STATUS),
+  payload: import_zod20.z.object({
+    status: import_zod20.z.string(),
+    message: import_zod20.z.string().optional()
   })
 });
 var CliErrorEventSchema = CliStreamBaseSchema.extend({
-  type: import_zod17.z.literal(CliStreamEventType.ERROR),
-  payload: import_zod17.z.object({
+  type: import_zod20.z.literal(CliStreamEventType.ERROR),
+  payload: import_zod20.z.object({
     error: ProtocolErrorSchema
   })
 });
 var CliDoneEventSchema = CliStreamBaseSchema.extend({
-  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()
+  type: import_zod20.z.literal(CliStreamEventType.DONE),
+  payload: import_zod20.z.object({
+    exitCode: import_zod20.z.number().int(),
+    duration: import_zod20.z.number(),
+    toolsUsed: import_zod20.z.array(import_zod20.z.string()).optional(),
+    tokensUsed: import_zod20.z.number().optional(),
+    success: import_zod20.z.boolean()
   })
 });
-var CliStreamEventSchema = import_zod17.z.discriminatedUnion("type", [
+var CliStreamEventSchema = import_zod20.z.discriminatedUnion("type", [
   CliStartEventSchema,
   CliTextDeltaEventSchema,
   CliThinkingEventSchema,
@@ -1226,34 +1418,34 @@ function parseCliStreamEvent(value) {
   return { success: false, error: result.error };
 }
 // src/protocol/context.ts
-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({
+var import_zod21 = require("zod");
+var ActiveFileContextSchema = import_zod21.z.object({
+  filePath: import_zod21.z.string(),
+  languageId: import_zod21.z.string().optional()
+});
+var SelectionContextSchema = import_zod21.z.object({
+  filePath: import_zod21.z.string(),
+  languageId: import_zod21.z.string().optional(),
+  startLine: import_zod21.z.number().int().min(0),
+  startColumn: import_zod21.z.number().int().min(0),
+  endLine: import_zod21.z.number().int().min(0),
+  endColumn: import_zod21.z.number().int().min(0),
+  text: import_zod21.z.string()
+});
+var WorkspaceContextSchema = import_zod21.z.object({
+  rootPath: import_zod21.z.string(),
+  name: import_zod21.z.string().optional()
+});
+var ContextPayloadSchema = import_zod21.z.object({
   workspace: WorkspaceContextSchema.optional(),
   activeFile: ActiveFileContextSchema.optional(),
   selection: SelectionContextSchema.optional()
 });
 // src/protocol/host-events.ts
-var import_zod20 = require("zod");
+var import_zod23 = require("zod");
 
 // src/protocol/session.ts
-var import_zod19 = require("zod");
+var import_zod22 = require("zod");
 var SessionStatus = {
   IDLE: "idle",
   STARTING: "starting",
@@ -1265,7 +1457,7 @@ var SessionStatus = {
   FAILED: "failed",
   RESUMING: "resuming"
 };
-var SessionStatusSchema = import_zod19.z.enum(SessionStatus);
+var SessionStatusSchema = import_zod22.z.enum(SessionStatus);
 var SessionTransitionEvent = {
   CREATE_SESSION: "create_session",
   CLI_SPAWNED: "cli_spawned",
@@ -1276,7 +1468,7 @@ var SessionTransitionEvent = {
   RESUME: "resume",
   ERROR: "error"
 };
-var SessionTransitionEventSchema = import_zod19.z.enum(SessionTransitionEvent);
+var SessionTransitionEventSchema = import_zod22.z.enum(SessionTransitionEvent);
 var SESSION_TRANSITIONS = [
   {
     from: SessionStatus.IDLE,
@@ -1369,24 +1561,24 @@ var TERMINAL_STATUSES = new Set([
   SessionStatus.CANCELED,
   SessionStatus.FAILED
 ]);
-var SessionMetadataSchema = import_zod19.z.object({
-  sessionId: import_zod19.z.string(),
+var SessionMetadataSchema = import_zod22.z.object({
+  sessionId: import_zod22.z.string(),
   status: SessionStatusSchema,
-  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(),
+  model: import_zod22.z.string().optional(),
+  createdAt: import_zod22.z.number(),
+  updatedAt: import_zod22.z.number(),
+  title: import_zod22.z.string().optional(),
+  prompt: import_zod22.z.string().optional()
+});
+var SessionSummarySchema = import_zod22.z.object({
+  sessionId: import_zod22.z.string(),
   status: SessionStatusSchema,
-  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()
+  model: import_zod22.z.string().optional(),
+  title: import_zod22.z.string().optional(),
+  createdAt: import_zod22.z.number(),
+  updatedAt: import_zod22.z.number(),
+  messageCount: import_zod22.z.number(),
+  toolCount: import_zod22.z.number()
 });
 
 // src/protocol/host-events.ts
@@ -1400,7 +1592,7 @@ var HostEventType = {
   SESSION_LIST: "session_list",
   SESSION_COMPLETED: "session_completed"
 };
-var HostEventTypeSchema = import_zod20.z.enum(HostEventType);
+var HostEventTypeSchema = import_zod23.z.enum(HostEventType);
 var TimelineEntryKind = {
   MESSAGE: "message",
   TOOL_CALL: "tool_call",
@@ -1408,86 +1600,86 @@ var TimelineEntryKind = {
   ERROR: "error",
   DONE: "done"
 };
-var TimelineEntryKindSchema = import_zod20.z.enum(TimelineEntryKind);
-var TimelineEntrySchema = import_zod20.z.object({
-  id: import_zod20.z.string(),
+var TimelineEntryKindSchema = import_zod23.z.enum(TimelineEntryKind);
+var TimelineEntrySchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
   kind: TimelineEntryKindSchema,
-  timestamp: import_zod20.z.number(),
-  data: import_zod20.z.record(import_zod20.z.string(), import_zod20.z.unknown())
+  timestamp: import_zod23.z.number(),
+  data: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown())
 });
-var SessionStateEventSchema = import_zod20.z.object({
+var SessionStateEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(HostEventType.SESSION_STATE),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string(),
+  type: import_zod23.z.literal(HostEventType.SESSION_STATE),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string(),
     status: SessionStatusSchema,
     metadata: SessionMetadataSchema.optional(),
-    timeline: import_zod20.z.array(TimelineEntrySchema).optional()
+    timeline: import_zod23.z.array(TimelineEntrySchema).optional()
   })
 });
-var TextDeltaEventSchema = import_zod20.z.object({
+var TextDeltaEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(HostEventType.TEXT_DELTA),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string(),
-    content: import_zod20.z.string()
+  type: import_zod23.z.literal(HostEventType.TEXT_DELTA),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string(),
+    content: import_zod23.z.string()
   })
 });
-var ToolStartedEventSchema = import_zod20.z.object({
+var ToolStartedEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  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()
+  type: import_zod23.z.literal(HostEventType.TOOL_STARTED),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string(),
+    tool: import_zod23.z.string(),
+    toolId: import_zod23.z.string().optional(),
+    parameters: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional()
   })
 });
-var ToolCompletedEventSchema = import_zod20.z.object({
+var ToolCompletedEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  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()
+  type: import_zod23.z.literal(HostEventType.TOOL_COMPLETED),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string(),
+    tool: import_zod23.z.string(),
+    toolId: import_zod23.z.string().optional(),
+    result: import_zod23.z.unknown().optional(),
+    duration: import_zod23.z.number().optional(),
+    success: import_zod23.z.boolean(),
+    error: import_zod23.z.string().optional()
   })
 });
-var ThinkingEventSchema = import_zod20.z.object({
+var ThinkingEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(HostEventType.THINKING),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string(),
-    content: import_zod20.z.string().optional()
+  type: import_zod23.z.literal(HostEventType.THINKING),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string(),
+    content: import_zod23.z.string().optional()
   })
 });
-var ErrorEventSchema = import_zod20.z.object({
+var ErrorEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(HostEventType.ERROR),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string().optional(),
+  type: import_zod23.z.literal(HostEventType.ERROR),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string().optional(),
     error: ProtocolErrorSchema
   })
 });
-var SessionListEventSchema = import_zod20.z.object({
+var SessionListEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(HostEventType.SESSION_LIST),
-  payload: import_zod20.z.object({
-    sessions: import_zod20.z.array(SessionSummarySchema)
+  type: import_zod23.z.literal(HostEventType.SESSION_LIST),
+  payload: import_zod23.z.object({
+    sessions: import_zod23.z.array(SessionSummarySchema)
   })
 });
-var SessionCompletedEventSchema = import_zod20.z.object({
+var SessionCompletedEventSchema = import_zod23.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod20.z.literal(HostEventType.SESSION_COMPLETED),
-  payload: import_zod20.z.object({
-    sessionId: import_zod20.z.string(),
-    summary: import_zod20.z.string().optional()
+  type: import_zod23.z.literal(HostEventType.SESSION_COMPLETED),
+  payload: import_zod23.z.object({
+    sessionId: import_zod23.z.string(),
+    summary: import_zod23.z.string().optional()
   })
 });
-var HostEventSchema = import_zod20.z.discriminatedUnion("type", [
+var HostEventSchema = import_zod23.z.discriminatedUnion("type", [
   SessionStateEventSchema,
   TextDeltaEventSchema,
   ToolStartedEventSchema,
@@ -1506,7 +1698,7 @@ function createHostEvent(type, payload) {
 }
 
 // src/protocol/ui-intents.ts
-var import_zod21 = require("zod");
+var import_zod24 = require("zod");
 var UIIntentType = {
   SUBMIT_PROMPT: "submit_prompt",
   STOP_SESSION: "stop_session",
@@ -1516,54 +1708,54 @@ var UIIntentType = {
   CLEAR_SESSION: "clear_session",
   WEBVIEW_READY: "webview_ready"
 };
-var UIIntentTypeSchema = import_zod21.z.enum(UIIntentType);
-var SubmitPromptIntentSchema = import_zod21.z.object({
+var UIIntentTypeSchema = import_zod24.z.enum(UIIntentType);
+var SubmitPromptIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.SUBMIT_PROMPT),
-  payload: import_zod21.z.object({
-    text: import_zod21.z.string().min(1),
+  type: import_zod24.z.literal(UIIntentType.SUBMIT_PROMPT),
+  payload: import_zod24.z.object({
+    text: import_zod24.z.string().min(1),
     context: ContextPayloadSchema.optional()
   })
 });
-var StopSessionIntentSchema = import_zod21.z.object({
+var StopSessionIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.STOP_SESSION),
-  payload: import_zod21.z.object({
-    sessionId: import_zod21.z.string()
+  type: import_zod24.z.literal(UIIntentType.STOP_SESSION),
+  payload: import_zod24.z.object({
+    sessionId: import_zod24.z.string()
   })
 });
-var ResumeSessionIntentSchema = import_zod21.z.object({
+var ResumeSessionIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.RESUME_SESSION),
-  payload: import_zod21.z.object({
-    sessionId: import_zod21.z.string()
+  type: import_zod24.z.literal(UIIntentType.RESUME_SESSION),
+  payload: import_zod24.z.object({
+    sessionId: import_zod24.z.string()
   })
 });
-var RequestSessionsIntentSchema = import_zod21.z.object({
+var RequestSessionsIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.REQUEST_SESSIONS),
-  payload: import_zod21.z.object({}).optional()
+  type: import_zod24.z.literal(UIIntentType.REQUEST_SESSIONS),
+  payload: import_zod24.z.object({}).optional()
 });
-var RequestSessionDetailIntentSchema = import_zod21.z.object({
+var RequestSessionDetailIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
-  payload: import_zod21.z.object({
-    sessionId: import_zod21.z.string()
+  type: import_zod24.z.literal(UIIntentType.REQUEST_SESSION_DETAIL),
+  payload: import_zod24.z.object({
+    sessionId: import_zod24.z.string()
   })
 });
-var ClearSessionIntentSchema = import_zod21.z.object({
+var ClearSessionIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.CLEAR_SESSION),
-  payload: import_zod21.z.object({
-    sessionId: import_zod21.z.string()
+  type: import_zod24.z.literal(UIIntentType.CLEAR_SESSION),
+  payload: import_zod24.z.object({
+    sessionId: import_zod24.z.string()
   })
 });
-var WebviewReadyIntentSchema = import_zod21.z.object({
+var WebviewReadyIntentSchema = import_zod24.z.object({
   protocol: ProtocolVersionSchema,
-  type: import_zod21.z.literal(UIIntentType.WEBVIEW_READY),
-  payload: import_zod21.z.object({}).optional()
+  type: import_zod24.z.literal(UIIntentType.WEBVIEW_READY),
+  payload: import_zod24.z.object({}).optional()
 });
-var UIIntentSchema = import_zod21.z.discriminatedUnion("type", [
+var UIIntentSchema = import_zod24.z.discriminatedUnion("type", [
   SubmitPromptIntentSchema,
   StopSessionIntentSchema,
   ResumeSessionIntentSchema,