@rudderhq/cli 0.1.0-canary.63 → 0.1.0-canary.65

package/dist/index.js

@@ -402,6 +402,13 @@ var init_observability = __esm({
   }
 });
 
+// ../packages/shared/src/types/workspace-backup.ts
+var init_workspace_backup = __esm({
+  "../packages/shared/src/types/workspace-backup.ts"() {
+    "use strict";
+  }
+});
+
 // ../packages/shared/src/validators/instance.ts
 import { z } from "zod";
 var instanceLocaleSchema, instanceGeneralSettingsSchema, patchInstanceGeneralSettingsSchema, instanceNotificationSettingsSchema, patchInstanceNotificationSettingsSchema, instanceLangfuseSettingsSchema, patchInstanceLangfuseSettingsSchema, operatorProfileSettingsSchema, patchOperatorProfileSettingsSchema, instancePathPickerSelectionTypeSchema, instancePathPickerRequestSchema, instancePathPickerResultSchema;
@@ -544,13 +551,13 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
     });
     return;
   }
-  fallbackModels.forEach((fallback, index65) => {
+  fallbackModels.forEach((fallback, index66) => {
     if (typeof fallback === "string") {
       if (fallback.trim().length === 0) {
         ctx.addIssue({
           code: z4.ZodIssueCode.custom,
           message: "modelFallbacks string entries must be non-empty",
-          path: [...pathPrefix, "modelFallbacks", index65]
+          path: [...pathPrefix, "modelFallbacks", index66]
         });
       }
       return;
@@ -559,7 +566,7 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
       ctx.addIssue({
         code: z4.ZodIssueCode.custom,
         message: "modelFallbacks entries must be strings or runtime/model objects",
-        path: [...pathPrefix, "modelFallbacks", index65]
+        path: [...pathPrefix, "modelFallbacks", index66]
       });
       return;
     }
@@ -567,27 +574,27 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
       ctx.addIssue({
         code: z4.ZodIssueCode.custom,
         message: "modelFallbacks entries must include agentRuntimeType",
-        path: [...pathPrefix, "modelFallbacks", index65, "agentRuntimeType"]
+        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
       });
     } else if (!agentRuntimeTypes.has(fallback.agentRuntimeType)) {
       ctx.addIssue({
         code: z4.ZodIssueCode.custom,
         message: "modelFallbacks entries must include a valid agentRuntimeType",
-        path: [...pathPrefix, "modelFallbacks", index65, "agentRuntimeType"]
+        path: [...pathPrefix, "modelFallbacks", index66, "agentRuntimeType"]
       });
     }
     if (typeof fallback.model !== "string" || fallback.model.trim().length === 0) {
       ctx.addIssue({
         code: z4.ZodIssueCode.custom,
         message: "modelFallbacks entries must include model",
-        path: [...pathPrefix, "modelFallbacks", index65, "model"]
+        path: [...pathPrefix, "modelFallbacks", index66, "model"]
       });
     }
     if (fallback.config !== void 0 && !isRecord(fallback.config)) {
       ctx.addIssue({
         code: z4.ZodIssueCode.custom,
         message: "modelFallbacks entry config must be an object",
-        path: [...pathPrefix, "modelFallbacks", index65, "config"]
+        path: [...pathPrefix, "modelFallbacks", index66, "config"]
       });
     } else if (isRecord(fallback.config) && fallback.config.env !== void 0) {
       const parsed = envConfigSchema.safeParse(fallback.config.env);
@@ -595,7 +602,7 @@ function validateModelFallbacksConfig(value, ctx, pathPrefix) {
         ctx.addIssue({
           code: z4.ZodIssueCode.custom,
           message: "modelFallbacks entry config.env must be a map of valid env bindings",
-          path: [...pathPrefix, "modelFallbacks", index65, "config", "env"]
+          path: [...pathPrefix, "modelFallbacks", index66, "config", "env"]
         });
       }
     }
@@ -1609,161 +1616,177 @@ var init_execution_workspace = __esm({
   }
 });
 
-// ../packages/shared/src/validators/goal.ts
+// ../packages/shared/src/validators/workspace-backup.ts
 import { z as z16 } from "zod";
+var workspaceBackupTriggerSourceSchema, createWorkspaceBackupSchema, restoreWorkspaceBackupSchema;
+var init_workspace_backup2 = __esm({
+  "../packages/shared/src/validators/workspace-backup.ts"() {
+    "use strict";
+    workspaceBackupTriggerSourceSchema = z16.enum(["manual", "scheduled", "pre_restore"]);
+    createWorkspaceBackupSchema = z16.object({
+      triggerSource: workspaceBackupTriggerSourceSchema.optional().default("manual")
+    }).strict();
+    restoreWorkspaceBackupSchema = z16.object({
+      confirm: z16.literal(true)
+    }).strict();
+  }
+});
+
+// ../packages/shared/src/validators/goal.ts
+import { z as z17 } from "zod";
 var createGoalSchema, updateGoalSchema;
 var init_goal = __esm({
   "../packages/shared/src/validators/goal.ts"() {
     "use strict";
     init_constants();
-    createGoalSchema = z16.object({
-      title: z16.string().min(1),
-      description: z16.string().optional().nullable(),
-      level: z16.enum(GOAL_LEVELS).optional().default("task"),
-      status: z16.enum(GOAL_STATUSES).optional().default("planned"),
-      parentId: z16.string().uuid().optional().nullable(),
-      ownerAgentId: z16.string().uuid().optional().nullable()
+    createGoalSchema = z17.object({
+      title: z17.string().min(1),
+      description: z17.string().optional().nullable(),
+      level: z17.enum(GOAL_LEVELS).optional().default("task"),
+      status: z17.enum(GOAL_STATUSES).optional().default("planned"),
+      parentId: z17.string().uuid().optional().nullable(),
+      ownerAgentId: z17.string().uuid().optional().nullable()
     });
     updateGoalSchema = createGoalSchema.partial();
   }
 });
 
 // ../packages/shared/src/validators/approval.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var createApprovalSchema, resolveApprovalSchema, requestApprovalRevisionSchema, resubmitApprovalSchema, addApprovalCommentSchema;
 var init_approval = __esm({
   "../packages/shared/src/validators/approval.ts"() {
     "use strict";
     init_constants();
-    createApprovalSchema = z17.object({
-      type: z17.enum(APPROVAL_TYPES),
-      requestedByAgentId: z17.string().uuid().optional().nullable(),
-      payload: z17.record(z17.unknown()),
-      issueIds: z17.array(z17.string().uuid()).optional()
+    createApprovalSchema = z18.object({
+      type: z18.enum(APPROVAL_TYPES),
+      requestedByAgentId: z18.string().uuid().optional().nullable(),
+      payload: z18.record(z18.unknown()),
+      issueIds: z18.array(z18.string().uuid()).optional()
     });
-    resolveApprovalSchema = z17.object({
-      decisionNote: z17.string().optional().nullable(),
-      decidedByUserId: z17.string().optional().default("board")
+    resolveApprovalSchema = z18.object({
+      decisionNote: z18.string().optional().nullable(),
+      decidedByUserId: z18.string().optional().default("board")
     });
-    requestApprovalRevisionSchema = z17.object({
-      decisionNote: z17.string().optional().nullable(),
-      decidedByUserId: z17.string().optional().default("board")
+    requestApprovalRevisionSchema = z18.object({
+      decisionNote: z18.string().optional().nullable(),
+      decidedByUserId: z18.string().optional().default("board")
     });
-    resubmitApprovalSchema = z17.object({
-      payload: z17.record(z17.unknown()).optional()
+    resubmitApprovalSchema = z18.object({
+      payload: z18.record(z18.unknown()).optional()
     });
-    addApprovalCommentSchema = z17.object({
-      body: z17.string().min(1)
+    addApprovalCommentSchema = z18.object({
+      body: z18.string().min(1)
     });
   }
 });
 
 // ../packages/shared/src/validators/automation.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var createAutomationSchema, updateAutomationSchema, baseTriggerSchema, createAutomationTriggerSchema, updateAutomationTriggerSchema, runAutomationSchema, rotateAutomationTriggerSecretSchema;
 var init_automation = __esm({
   "../packages/shared/src/validators/automation.ts"() {
     "use strict";
     init_constants();
-    createAutomationSchema = z18.object({
-      projectId: z18.string().uuid(),
-      goalId: z18.string().uuid().optional().nullable(),
-      parentIssueId: z18.string().uuid().optional().nullable(),
-      title: z18.string().trim().min(1).max(200),
-      description: z18.string().optional().nullable(),
-      assigneeAgentId: z18.string().uuid(),
-      priority: z18.enum(ISSUE_PRIORITIES).optional().default("medium"),
-      status: z18.enum(AUTOMATION_STATUSES).optional().default("active"),
-      concurrencyPolicy: z18.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
-      catchUpPolicy: z18.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed")
+    createAutomationSchema = z19.object({
+      projectId: z19.string().uuid(),
+      goalId: z19.string().uuid().optional().nullable(),
+      parentIssueId: z19.string().uuid().optional().nullable(),
+      title: z19.string().trim().min(1).max(200),
+      description: z19.string().optional().nullable(),
+      assigneeAgentId: z19.string().uuid(),
+      priority: z19.enum(ISSUE_PRIORITIES).optional().default("medium"),
+      status: z19.enum(AUTOMATION_STATUSES).optional().default("active"),
+      concurrencyPolicy: z19.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
+      catchUpPolicy: z19.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed")
     });
     updateAutomationSchema = createAutomationSchema.partial();
-    baseTriggerSchema = z18.object({
-      label: z18.string().trim().max(120).optional().nullable(),
-      enabled: z18.boolean().optional().default(true)
+    baseTriggerSchema = z19.object({
+      label: z19.string().trim().max(120).optional().nullable(),
+      enabled: z19.boolean().optional().default(true)
     });
-    createAutomationTriggerSchema = z18.discriminatedUnion("kind", [
+    createAutomationTriggerSchema = z19.discriminatedUnion("kind", [
       baseTriggerSchema.extend({
-        kind: z18.literal("schedule"),
-        cronExpression: z18.string().trim().min(1),
-        timezone: z18.string().trim().min(1).default("UTC")
+        kind: z19.literal("schedule"),
+        cronExpression: z19.string().trim().min(1),
+        timezone: z19.string().trim().min(1).default("UTC")
       }),
       baseTriggerSchema.extend({
-        kind: z18.literal("webhook"),
-        signingMode: z18.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().default("bearer"),
-        replayWindowSec: z18.number().int().min(30).max(86400).optional().default(300)
+        kind: z19.literal("webhook"),
+        signingMode: z19.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().default("bearer"),
+        replayWindowSec: z19.number().int().min(30).max(86400).optional().default(300)
       }),
       baseTriggerSchema.extend({
-        kind: z18.literal("api")
+        kind: z19.literal("api")
       })
     ]);
-    updateAutomationTriggerSchema = z18.object({
-      label: z18.string().trim().max(120).optional().nullable(),
-      enabled: z18.boolean().optional(),
-      cronExpression: z18.string().trim().min(1).optional().nullable(),
-      timezone: z18.string().trim().min(1).optional().nullable(),
-      signingMode: z18.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().nullable(),
-      replayWindowSec: z18.number().int().min(30).max(86400).optional().nullable()
+    updateAutomationTriggerSchema = z19.object({
+      label: z19.string().trim().max(120).optional().nullable(),
+      enabled: z19.boolean().optional(),
+      cronExpression: z19.string().trim().min(1).optional().nullable(),
+      timezone: z19.string().trim().min(1).optional().nullable(),
+      signingMode: z19.enum(AUTOMATION_TRIGGER_SIGNING_MODES).optional().nullable(),
+      replayWindowSec: z19.number().int().min(30).max(86400).optional().nullable()
     });
-    runAutomationSchema = z18.object({
-      triggerId: z18.string().uuid().optional().nullable(),
-      payload: z18.record(z18.unknown()).optional().nullable(),
-      idempotencyKey: z18.string().trim().max(255).optional().nullable(),
-      source: z18.enum(["manual", "api"]).optional().default("manual")
+    runAutomationSchema = z19.object({
+      triggerId: z19.string().uuid().optional().nullable(),
+      payload: z19.record(z19.unknown()).optional().nullable(),
+      idempotencyKey: z19.string().trim().max(255).optional().nullable(),
+      source: z19.enum(["manual", "api"]).optional().default("manual")
     });
-    rotateAutomationTriggerSecretSchema = z18.object({});
+    rotateAutomationTriggerSecretSchema = z19.object({});
   }
 });
 
 // ../packages/shared/src/validators/calendar.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var nullableUuid, createCalendarSourceSchema, updateCalendarSourceSchema, calendarEventBaseSchema, createCalendarEventSchema, updateCalendarEventSchema, calendarEventListQuerySchema, googleCalendarSyncSchema, updateGoogleCalendarOAuthConfigSchema;
 var init_calendar = __esm({
   "../packages/shared/src/validators/calendar.ts"() {
     "use strict";
     init_constants();
-    nullableUuid = z19.string().uuid().optional().nullable();
-    createCalendarSourceSchema = z19.object({
-      type: z19.enum(CALENDAR_SOURCE_TYPES).optional().default("rudder_local"),
-      name: z19.string().trim().min(1).max(160),
-      ownerType: z19.enum(CALENDAR_OWNER_TYPES).optional().default("user"),
-      ownerUserId: z19.string().trim().min(1).optional().nullable(),
+    nullableUuid = z20.string().uuid().optional().nullable();
+    createCalendarSourceSchema = z20.object({
+      type: z20.enum(CALENDAR_SOURCE_TYPES).optional().default("rudder_local"),
+      name: z20.string().trim().min(1).max(160),
+      ownerType: z20.enum(CALENDAR_OWNER_TYPES).optional().default("user"),
+      ownerUserId: z20.string().trim().min(1).optional().nullable(),
       ownerAgentId: nullableUuid,
-      externalProvider: z19.string().trim().min(1).max(80).optional().nullable(),
-      externalCalendarId: z19.string().trim().min(1).max(512).optional().nullable(),
-      visibilityDefault: z19.enum(CALENDAR_VISIBILITIES).optional().default("full"),
-      status: z19.enum(CALENDAR_SOURCE_STATUSES).optional().default("active"),
-      syncCursorJson: z19.record(z19.unknown()).optional().nullable()
+      externalProvider: z20.string().trim().min(1).max(80).optional().nullable(),
+      externalCalendarId: z20.string().trim().min(1).max(512).optional().nullable(),
+      visibilityDefault: z20.enum(CALENDAR_VISIBILITIES).optional().default("full"),
+      status: z20.enum(CALENDAR_SOURCE_STATUSES).optional().default("active"),
+      syncCursorJson: z20.record(z20.unknown()).optional().nullable()
     });
     updateCalendarSourceSchema = createCalendarSourceSchema.partial().extend({
-      lastSyncedAt: z19.coerce.date().optional().nullable()
+      lastSyncedAt: z20.coerce.date().optional().nullable()
     });
-    calendarEventBaseSchema = z19.object({
+    calendarEventBaseSchema = z20.object({
       sourceId: nullableUuid,
-      eventKind: z19.enum(CALENDAR_EVENT_KINDS),
-      eventStatus: z19.enum(CALENDAR_EVENT_STATUSES).optional().default("planned"),
-      ownerType: z19.enum(CALENDAR_OWNER_TYPES),
-      ownerUserId: z19.string().trim().min(1).optional().nullable(),
+      eventKind: z20.enum(CALENDAR_EVENT_KINDS),
+      eventStatus: z20.enum(CALENDAR_EVENT_STATUSES).optional().default("planned"),
+      ownerType: z20.enum(CALENDAR_OWNER_TYPES),
+      ownerUserId: z20.string().trim().min(1).optional().nullable(),
       ownerAgentId: nullableUuid,
-      title: z19.string().trim().min(1).max(240),
-      description: z19.string().optional().nullable(),
-      startAt: z19.coerce.date(),
-      endAt: z19.coerce.date(),
-      timezone: z19.string().trim().min(1).max(80).optional().default("UTC"),
-      allDay: z19.boolean().optional().default(false),
-      visibility: z19.enum(CALENDAR_VISIBILITIES).optional().default("full"),
+      title: z20.string().trim().min(1).max(240),
+      description: z20.string().optional().nullable(),
+      startAt: z20.coerce.date(),
+      endAt: z20.coerce.date(),
+      timezone: z20.string().trim().min(1).max(80).optional().default("UTC"),
+      allDay: z20.boolean().optional().default(false),
+      visibility: z20.enum(CALENDAR_VISIBILITIES).optional().default("full"),
       issueId: nullableUuid,
       projectId: nullableUuid,
       goalId: nullableUuid,
       approvalId: nullableUuid,
       heartbeatRunId: nullableUuid,
       activityId: nullableUuid,
-      sourceMode: z19.enum(CALENDAR_SOURCE_MODES).optional().default("manual"),
-      externalProvider: z19.string().trim().min(1).max(80).optional().nullable(),
-      externalCalendarId: z19.string().trim().min(1).max(512).optional().nullable(),
-      externalEventId: z19.string().trim().min(1).max(512).optional().nullable(),
-      externalEtag: z19.string().trim().min(1).max(512).optional().nullable(),
-      externalUpdatedAt: z19.coerce.date().optional().nullable()
+      sourceMode: z20.enum(CALENDAR_SOURCE_MODES).optional().default("manual"),
+      externalProvider: z20.string().trim().min(1).max(80).optional().nullable(),
+      externalCalendarId: z20.string().trim().min(1).max(512).optional().nullable(),
+      externalEventId: z20.string().trim().min(1).max(512).optional().nullable(),
+      externalEtag: z20.string().trim().min(1).max(512).optional().nullable(),
+      externalUpdatedAt: z20.coerce.date().optional().nullable()
     });
     createCalendarEventSchema = calendarEventBaseSchema.refine(
       (value) => value.endAt.getTime() > value.startAt.getTime(),
@@ -1773,24 +1796,24 @@ var init_calendar = __esm({
       (value) => value.startAt === void 0 || value.endAt === void 0 || value.endAt.getTime() > value.startAt.getTime(),
       { path: ["endAt"], message: "End time must be after start time" }
     );
-    calendarEventListQuerySchema = z19.object({
-      start: z19.coerce.date(),
-      end: z19.coerce.date(),
-      agentIds: z19.string().optional(),
-      sourceIds: z19.string().optional(),
-      eventKinds: z19.string().optional(),
-      statuses: z19.string().optional()
+    calendarEventListQuerySchema = z20.object({
+      start: z20.coerce.date(),
+      end: z20.coerce.date(),
+      agentIds: z20.string().optional(),
+      sourceIds: z20.string().optional(),
+      eventKinds: z20.string().optional(),
+      statuses: z20.string().optional()
     }).refine(
       (value) => value.end.getTime() > value.start.getTime(),
       { path: ["end"], message: "End time must be after start time" }
     );
-    googleCalendarSyncSchema = z19.object({
-      sourceId: z19.string().uuid().optional().nullable()
+    googleCalendarSyncSchema = z20.object({
+      sourceId: z20.string().uuid().optional().nullable()
     });
-    updateGoogleCalendarOAuthConfigSchema = z19.object({
-      clientId: z19.string().trim().min(1).max(512).optional(),
-      clientSecret: z19.string().trim().min(1).max(2048).optional(),
-      clear: z19.boolean().optional().default(false)
+    updateGoogleCalendarOAuthConfigSchema = z20.object({
+      clientId: z20.string().trim().min(1).max(512).optional(),
+      clientSecret: z20.string().trim().min(1).max(2048).optional(),
+      clear: z20.boolean().optional().default(false)
     }).refine(
       (value) => value.clear || value.clientId !== void 0 || value.clientSecret !== void 0,
       { message: "Provide credentials or clear the stored Google Calendar OAuth configuration" }
@@ -1799,70 +1822,70 @@ var init_calendar = __esm({
 });
 
 // ../packages/shared/src/validators/cost.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var createCostEventSchema, updateBudgetSchema;
 var init_cost = __esm({
   "../packages/shared/src/validators/cost.ts"() {
     "use strict";
     init_constants();
-    createCostEventSchema = z20.object({
-      agentId: z20.string().uuid(),
-      issueId: z20.string().uuid().optional().nullable(),
-      projectId: z20.string().uuid().optional().nullable(),
-      goalId: z20.string().uuid().optional().nullable(),
-      heartbeatRunId: z20.string().uuid().optional().nullable(),
-      billingCode: z20.string().optional().nullable(),
-      provider: z20.string().min(1),
-      biller: z20.string().min(1).optional(),
-      billingType: z20.enum(BILLING_TYPES).optional().default("unknown"),
-      model: z20.string().min(1),
-      inputTokens: z20.number().int().nonnegative().optional().default(0),
-      cachedInputTokens: z20.number().int().nonnegative().optional().default(0),
-      outputTokens: z20.number().int().nonnegative().optional().default(0),
-      costCents: z20.number().int().nonnegative(),
-      occurredAt: z20.string().datetime()
+    createCostEventSchema = z21.object({
+      agentId: z21.string().uuid(),
+      issueId: z21.string().uuid().optional().nullable(),
+      projectId: z21.string().uuid().optional().nullable(),
+      goalId: z21.string().uuid().optional().nullable(),
+      heartbeatRunId: z21.string().uuid().optional().nullable(),
+      billingCode: z21.string().optional().nullable(),
+      provider: z21.string().min(1),
+      biller: z21.string().min(1).optional(),
+      billingType: z21.enum(BILLING_TYPES).optional().default("unknown"),
+      model: z21.string().min(1),
+      inputTokens: z21.number().int().nonnegative().optional().default(0),
+      cachedInputTokens: z21.number().int().nonnegative().optional().default(0),
+      outputTokens: z21.number().int().nonnegative().optional().default(0),
+      costCents: z21.number().int().nonnegative(),
+      occurredAt: z21.string().datetime()
     }).transform((value) => ({
       ...value,
       biller: value.biller ?? value.provider
     }));
-    updateBudgetSchema = z20.object({
-      budgetMonthlyCents: z20.number().int().nonnegative()
+    updateBudgetSchema = z21.object({
+      budgetMonthlyCents: z21.number().int().nonnegative()
     });
   }
 });
 
 // ../packages/shared/src/validators/finance.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 var createFinanceEventSchema;
 var init_finance = __esm({
   "../packages/shared/src/validators/finance.ts"() {
     "use strict";
     init_constants();
-    createFinanceEventSchema = z21.object({
-      agentId: z21.string().uuid().optional().nullable(),
-      issueId: z21.string().uuid().optional().nullable(),
-      projectId: z21.string().uuid().optional().nullable(),
-      goalId: z21.string().uuid().optional().nullable(),
-      heartbeatRunId: z21.string().uuid().optional().nullable(),
-      costEventId: z21.string().uuid().optional().nullable(),
-      billingCode: z21.string().optional().nullable(),
-      description: z21.string().max(500).optional().nullable(),
-      eventKind: z21.enum(FINANCE_EVENT_KINDS),
-      direction: z21.enum(FINANCE_DIRECTIONS).optional().default("debit"),
-      biller: z21.string().min(1),
-      provider: z21.string().min(1).optional().nullable(),
-      executionAgentRuntimeType: z21.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
-      pricingTier: z21.string().min(1).optional().nullable(),
-      region: z21.string().min(1).optional().nullable(),
-      model: z21.string().min(1).optional().nullable(),
-      quantity: z21.number().int().nonnegative().optional().nullable(),
-      unit: z21.enum(FINANCE_UNITS).optional().nullable(),
-      amountCents: z21.number().int().nonnegative(),
-      currency: z21.string().length(3).optional().default("USD"),
-      estimated: z21.boolean().optional().default(false),
-      externalInvoiceId: z21.string().optional().nullable(),
-      metadataJson: z21.record(z21.string(), z21.unknown()).optional().nullable(),
-      occurredAt: z21.string().datetime()
+    createFinanceEventSchema = z22.object({
+      agentId: z22.string().uuid().optional().nullable(),
+      issueId: z22.string().uuid().optional().nullable(),
+      projectId: z22.string().uuid().optional().nullable(),
+      goalId: z22.string().uuid().optional().nullable(),
+      heartbeatRunId: z22.string().uuid().optional().nullable(),
+      costEventId: z22.string().uuid().optional().nullable(),
+      billingCode: z22.string().optional().nullable(),
+      description: z22.string().max(500).optional().nullable(),
+      eventKind: z22.enum(FINANCE_EVENT_KINDS),
+      direction: z22.enum(FINANCE_DIRECTIONS).optional().default("debit"),
+      biller: z22.string().min(1),
+      provider: z22.string().min(1).optional().nullable(),
+      executionAgentRuntimeType: z22.enum(AGENT_RUNTIME_TYPES).optional().nullable(),
+      pricingTier: z22.string().min(1).optional().nullable(),
+      region: z22.string().min(1).optional().nullable(),
+      model: z22.string().min(1).optional().nullable(),
+      quantity: z22.number().int().nonnegative().optional().nullable(),
+      unit: z22.enum(FINANCE_UNITS).optional().nullable(),
+      amountCents: z22.number().int().nonnegative(),
+      currency: z22.string().length(3).optional().default("USD"),
+      estimated: z22.boolean().optional().default(false),
+      externalInvoiceId: z22.string().optional().nullable(),
+      metadataJson: z22.record(z22.string(), z22.unknown()).optional().nullable(),
+      occurredAt: z22.string().datetime()
     }).transform((value) => ({
       ...value,
       currency: value.currency.toUpperCase()
@@ -1871,81 +1894,81 @@ var init_finance = __esm({
 });
 
 // ../packages/shared/src/validators/asset.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var createAssetImageMetadataSchema;
 var init_asset = __esm({
   "../packages/shared/src/validators/asset.ts"() {
     "use strict";
-    createAssetImageMetadataSchema = z22.object({
-      namespace: z22.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9/_-]+$/).optional()
+    createAssetImageMetadataSchema = z23.object({
+      namespace: z23.string().trim().min(1).max(120).regex(/^[a-zA-Z0-9/_-]+$/).optional()
     });
   }
 });
 
 // ../packages/shared/src/validators/access.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var createCompanyInviteSchema, createOpenClawInvitePromptSchema, acceptInviteSchema, listJoinRequestsQuerySchema, claimJoinRequestApiKeySchema, boardCliAuthAccessLevelSchema, createCliAuthChallengeSchema, resolveCliAuthChallengeSchema, updateMemberPermissionsSchema, updateUserCompanyAccessSchema;
 var init_access = __esm({
   "../packages/shared/src/validators/access.ts"() {
     "use strict";
     init_constants();
-    createCompanyInviteSchema = z23.object({
-      allowedJoinTypes: z23.enum(INVITE_JOIN_TYPES).default("both"),
-      defaultsPayload: z23.record(z23.string(), z23.unknown()).optional().nullable(),
-      agentMessage: z23.string().max(4e3).optional().nullable()
+    createCompanyInviteSchema = z24.object({
+      allowedJoinTypes: z24.enum(INVITE_JOIN_TYPES).default("both"),
+      defaultsPayload: z24.record(z24.string(), z24.unknown()).optional().nullable(),
+      agentMessage: z24.string().max(4e3).optional().nullable()
     });
-    createOpenClawInvitePromptSchema = z23.object({
-      agentMessage: z23.string().max(4e3).optional().nullable()
+    createOpenClawInvitePromptSchema = z24.object({
+      agentMessage: z24.string().max(4e3).optional().nullable()
     });
-    acceptInviteSchema = z23.object({
-      requestType: z23.enum(JOIN_REQUEST_TYPES),
-      agentName: z23.string().min(1).max(120).optional(),
-      agentRuntimeType: z23.enum(AGENT_RUNTIME_TYPES).optional(),
-      capabilities: z23.string().max(4e3).optional().nullable(),
-      agentDefaultsPayload: z23.record(z23.string(), z23.unknown()).optional().nullable(),
+    acceptInviteSchema = z24.object({
+      requestType: z24.enum(JOIN_REQUEST_TYPES),
+      agentName: z24.string().min(1).max(120).optional(),
+      agentRuntimeType: z24.enum(AGENT_RUNTIME_TYPES).optional(),
+      capabilities: z24.string().max(4e3).optional().nullable(),
+      agentDefaultsPayload: z24.record(z24.string(), z24.unknown()).optional().nullable(),
       // OpenClaw join compatibility fields accepted at top level.
-      responsesWebhookUrl: z23.string().max(4e3).optional().nullable(),
-      responsesWebhookMethod: z23.string().max(32).optional().nullable(),
-      responsesWebhookHeaders: z23.record(z23.string(), z23.unknown()).optional().nullable(),
-      rudderApiUrl: z23.string().max(4e3).optional().nullable(),
-      webhookAuthHeader: z23.string().max(4e3).optional().nullable()
+      responsesWebhookUrl: z24.string().max(4e3).optional().nullable(),
+      responsesWebhookMethod: z24.string().max(32).optional().nullable(),
+      responsesWebhookHeaders: z24.record(z24.string(), z24.unknown()).optional().nullable(),
+      rudderApiUrl: z24.string().max(4e3).optional().nullable(),
+      webhookAuthHeader: z24.string().max(4e3).optional().nullable()
     });
-    listJoinRequestsQuerySchema = z23.object({
-      status: z23.enum(JOIN_REQUEST_STATUSES).optional(),
-      requestType: z23.enum(JOIN_REQUEST_TYPES).optional()
+    listJoinRequestsQuerySchema = z24.object({
+      status: z24.enum(JOIN_REQUEST_STATUSES).optional(),
+      requestType: z24.enum(JOIN_REQUEST_TYPES).optional()
     });
-    claimJoinRequestApiKeySchema = z23.object({
-      claimSecret: z23.string().min(16).max(256)
+    claimJoinRequestApiKeySchema = z24.object({
+      claimSecret: z24.string().min(16).max(256)
     });
-    boardCliAuthAccessLevelSchema = z23.enum([
+    boardCliAuthAccessLevelSchema = z24.enum([
       "board",
       "instance_admin_required"
     ]);
-    createCliAuthChallengeSchema = z23.object({
-      command: z23.string().min(1).max(240),
-      clientName: z23.string().max(120).optional().nullable(),
+    createCliAuthChallengeSchema = z24.object({
+      command: z24.string().min(1).max(240),
+      clientName: z24.string().max(120).optional().nullable(),
       requestedAccess: boardCliAuthAccessLevelSchema.default("board"),
-      requestedCompanyId: z23.string().uuid().optional().nullable()
+      requestedCompanyId: z24.string().uuid().optional().nullable()
     });
-    resolveCliAuthChallengeSchema = z23.object({
-      token: z23.string().min(16).max(256)
+    resolveCliAuthChallengeSchema = z24.object({
+      token: z24.string().min(16).max(256)
     });
-    updateMemberPermissionsSchema = z23.object({
-      grants: z23.array(
-        z23.object({
-          permissionKey: z23.enum(PERMISSION_KEYS),
-          scope: z23.record(z23.string(), z23.unknown()).optional().nullable()
+    updateMemberPermissionsSchema = z24.object({
+      grants: z24.array(
+        z24.object({
+          permissionKey: z24.enum(PERMISSION_KEYS),
+          scope: z24.record(z24.string(), z24.unknown()).optional().nullable()
         })
       )
     });
-    updateUserCompanyAccessSchema = z23.object({
-      orgIds: z23.array(z23.string().uuid()).default([])
+    updateUserCompanyAccessSchema = z24.object({
+      orgIds: z24.array(z24.string().uuid()).default([])
     });
   }
 });
 
 // ../packages/shared/src/validators/plugin.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 function isValidCronExpression(expression) {
   const trimmed = expression.trim();
   if (!trimmed) return false;
@@ -1958,7 +1981,7 @@ var init_plugin = __esm({
   "../packages/shared/src/validators/plugin.ts"() {
     "use strict";
     init_constants();
-    jsonSchemaSchema = z24.record(z24.unknown()).refine(
+    jsonSchemaSchema = z25.record(z25.unknown()).refine(
       (val) => {
         if (Object.keys(val).length === 0) return true;
         return typeof val.type === "string" || val.$ref !== void 0 || val.oneOf !== void 0 || val.anyOf !== void 0 || val.allOf !== void 0;
@@ -1966,76 +1989,76 @@ var init_plugin = __esm({
       { message: "Must be a valid JSON Schema object (requires at least a 'type', '$ref', or composition keyword)" }
     );
     CRON_FIELD_PATTERN = /^(\*(?:\/[0-9]+)?|[0-9]+(?:-[0-9]+)?(?:\/[0-9]+)?)(?:,(\*(?:\/[0-9]+)?|[0-9]+(?:-[0-9]+)?(?:\/[0-9]+)?))*$/;
-    pluginJobDeclarationSchema = z24.object({
-      jobKey: z24.string().min(1),
-      displayName: z24.string().min(1),
-      description: z24.string().optional(),
-      schedule: z24.string().refine(
+    pluginJobDeclarationSchema = z25.object({
+      jobKey: z25.string().min(1),
+      displayName: z25.string().min(1),
+      description: z25.string().optional(),
+      schedule: z25.string().refine(
         (val) => isValidCronExpression(val),
         { message: "schedule must be a valid 5-field cron expression (e.g. '*/15 * * * *')" }
       ).optional()
     });
-    pluginWebhookDeclarationSchema = z24.object({
-      endpointKey: z24.string().min(1),
-      displayName: z24.string().min(1),
-      description: z24.string().optional()
+    pluginWebhookDeclarationSchema = z25.object({
+      endpointKey: z25.string().min(1),
+      displayName: z25.string().min(1),
+      description: z25.string().optional()
     });
-    pluginToolDeclarationSchema = z24.object({
-      name: z24.string().min(1),
-      displayName: z24.string().min(1),
-      description: z24.string().min(1),
+    pluginToolDeclarationSchema = z25.object({
+      name: z25.string().min(1),
+      displayName: z25.string().min(1),
+      description: z25.string().min(1),
       parametersSchema: jsonSchemaSchema
     });
-    pluginUiSlotDeclarationSchema = z24.object({
-      type: z24.enum(PLUGIN_UI_SLOT_TYPES),
-      id: z24.string().min(1),
-      displayName: z24.string().min(1),
-      exportName: z24.string().min(1),
-      entityTypes: z24.array(z24.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
-      routePath: z24.string().regex(/^[a-z0-9][a-z0-9-]*$/, {
+    pluginUiSlotDeclarationSchema = z25.object({
+      type: z25.enum(PLUGIN_UI_SLOT_TYPES),
+      id: z25.string().min(1),
+      displayName: z25.string().min(1),
+      exportName: z25.string().min(1),
+      entityTypes: z25.array(z25.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
+      routePath: z25.string().regex(/^[a-z0-9][a-z0-9-]*$/, {
         message: "routePath must be a lowercase single-segment slug (letters, numbers, hyphens)"
       }).optional(),
-      order: z24.number().int().optional()
+      order: z25.number().int().optional()
     }).superRefine((value, ctx) => {
       const entityScopedTypes = ["detailTab", "taskDetailView", "contextMenuItem", "commentAnnotation", "commentContextMenuItem", "projectSidebarItem"];
       if (entityScopedTypes.includes(value.type) && (!value.entityTypes || value.entityTypes.length === 0)) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: `${value.type} slots require at least one entityType`,
           path: ["entityTypes"]
         });
       }
       if (value.type === "projectSidebarItem" && value.entityTypes && !value.entityTypes.includes("project")) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: 'projectSidebarItem slots require entityTypes to include "project"',
           path: ["entityTypes"]
         });
       }
       if (value.type === "commentAnnotation" && value.entityTypes && !value.entityTypes.includes("comment")) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: 'commentAnnotation slots require entityTypes to include "comment"',
           path: ["entityTypes"]
         });
       }
       if (value.type === "commentContextMenuItem" && value.entityTypes && !value.entityTypes.includes("comment")) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: 'commentContextMenuItem slots require entityTypes to include "comment"',
           path: ["entityTypes"]
         });
       }
       if (value.routePath && value.type !== "page") {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "routePath is only supported for page slots",
           path: ["routePath"]
         });
       }
       if (value.routePath && PLUGIN_RESERVED_COMPANY_ROUTE_SEGMENTS.includes(value.routePath)) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: `routePath "${value.routePath}" is reserved by the host`,
           path: ["routePath"]
         });
@@ -2056,29 +2079,29 @@ var init_plugin = __esm({
       external: [],
       iframe: ["compact", "default", "wide", "full"]
     };
-    pluginLauncherActionDeclarationSchema = z24.object({
-      type: z24.enum(PLUGIN_LAUNCHER_ACTIONS),
-      target: z24.string().min(1),
-      params: z24.record(z24.unknown()).optional()
+    pluginLauncherActionDeclarationSchema = z25.object({
+      type: z25.enum(PLUGIN_LAUNCHER_ACTIONS),
+      target: z25.string().min(1),
+      params: z25.record(z25.unknown()).optional()
     }).superRefine((value, ctx) => {
       if (value.type === "performAction" && value.target.includes("/")) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "performAction launchers must target an action key, not a route or URL",
           path: ["target"]
         });
       }
       if (value.type === "navigate" && /^https?:\/\//.test(value.target)) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "navigate launchers must target a host route, not an absolute URL",
           path: ["target"]
         });
       }
     });
-    pluginLauncherRenderDeclarationSchema = z24.object({
-      environment: z24.enum(PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS),
-      bounds: z24.enum(PLUGIN_LAUNCHER_BOUNDS).optional()
+    pluginLauncherRenderDeclarationSchema = z25.object({
+      environment: z25.enum(PLUGIN_LAUNCHER_RENDER_ENVIRONMENTS),
+      bounds: z25.enum(PLUGIN_LAUNCHER_BOUNDS).optional()
     }).superRefine((value, ctx) => {
       if (!value.bounds) {
         return;
@@ -2086,122 +2109,122 @@ var init_plugin = __esm({
       const supportedBounds = launcherBoundsByEnvironment[value.environment];
       if (!supportedBounds.includes(value.bounds)) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: `bounds "${value.bounds}" is not supported for render environment "${value.environment}"`,
           path: ["bounds"]
         });
       }
     });
-    pluginLauncherDeclarationSchema = z24.object({
-      id: z24.string().min(1),
-      displayName: z24.string().min(1),
-      description: z24.string().optional(),
-      placementZone: z24.enum(PLUGIN_LAUNCHER_PLACEMENT_ZONES),
-      exportName: z24.string().min(1).optional(),
-      entityTypes: z24.array(z24.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
-      order: z24.number().int().optional(),
+    pluginLauncherDeclarationSchema = z25.object({
+      id: z25.string().min(1),
+      displayName: z25.string().min(1),
+      description: z25.string().optional(),
+      placementZone: z25.enum(PLUGIN_LAUNCHER_PLACEMENT_ZONES),
+      exportName: z25.string().min(1).optional(),
+      entityTypes: z25.array(z25.enum(PLUGIN_UI_SLOT_ENTITY_TYPES)).optional(),
+      order: z25.number().int().optional(),
       action: pluginLauncherActionDeclarationSchema,
       render: pluginLauncherRenderDeclarationSchema.optional()
     }).superRefine((value, ctx) => {
       if (entityScopedLauncherPlacementZones.some((zone) => zone === value.placementZone) && (!value.entityTypes || value.entityTypes.length === 0)) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: `${value.placementZone} launchers require at least one entityType`,
           path: ["entityTypes"]
         });
       }
       if (value.placementZone === "projectSidebarItem" && value.entityTypes && !value.entityTypes.includes("project")) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: 'projectSidebarItem launchers require entityTypes to include "project"',
           path: ["entityTypes"]
         });
       }
       if (value.action.type === "performAction" && value.render) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "performAction launchers cannot declare render hints",
           path: ["render"]
         });
       }
       if (["openModal", "openDrawer", "openPopover"].includes(value.action.type) && !value.render) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: `${value.action.type} launchers require render metadata`,
           path: ["render"]
         });
       }
       if (value.action.type === "openModal" && value.render?.environment === "hostInline") {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "openModal launchers cannot use the hostInline render environment",
           path: ["render", "environment"]
         });
       }
       if (value.action.type === "openDrawer" && value.render && !["hostOverlay", "iframe"].includes(value.render.environment)) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "openDrawer launchers must use hostOverlay or iframe render environments",
           path: ["render", "environment"]
         });
       }
       if (value.action.type === "openPopover" && value.render?.environment === "hostRoute") {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "openPopover launchers cannot use the hostRoute render environment",
           path: ["render", "environment"]
         });
       }
     });
-    pluginManifestV1Schema = z24.object({
-      id: z24.string().min(1).regex(
+    pluginManifestV1Schema = z25.object({
+      id: z25.string().min(1).regex(
         /^[a-z0-9][a-z0-9._-]*$/,
         "Plugin id must start with a lowercase alphanumeric and contain only lowercase letters, digits, dots, hyphens, or underscores"
       ),
-      apiVersion: z24.literal(1),
-      version: z24.string().min(1).regex(
+      apiVersion: z25.literal(1),
+      version: z25.string().min(1).regex(
         /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/,
         "Version must follow semver (e.g. 1.0.0 or 1.0.0-beta.1)"
       ),
-      displayName: z24.string().min(1).max(100),
-      description: z24.string().min(1).max(500),
-      author: z24.string().min(1).max(200),
-      categories: z24.array(z24.enum(PLUGIN_CATEGORIES)).min(1),
-      minimumHostVersion: z24.string().regex(
+      displayName: z25.string().min(1).max(100),
+      description: z25.string().min(1).max(500),
+      author: z25.string().min(1).max(200),
+      categories: z25.array(z25.enum(PLUGIN_CATEGORIES)).min(1),
+      minimumHostVersion: z25.string().regex(
         /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/,
         "minimumHostVersion must follow semver (e.g. 1.0.0)"
       ).optional(),
-      minimumPaperclipVersion: z24.string().regex(
+      minimumPaperclipVersion: z25.string().regex(
         /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/,
         "minimumPaperclipVersion must follow semver (e.g. 1.0.0)"
       ).optional(),
-      capabilities: z24.array(z24.enum(PLUGIN_CAPABILITIES)).min(1),
-      entrypoints: z24.object({
-        worker: z24.string().min(1),
-        ui: z24.string().min(1).optional()
+      capabilities: z25.array(z25.enum(PLUGIN_CAPABILITIES)).min(1),
+      entrypoints: z25.object({
+        worker: z25.string().min(1),
+        ui: z25.string().min(1).optional()
       }),
       instanceConfigSchema: jsonSchemaSchema.optional(),
-      jobs: z24.array(pluginJobDeclarationSchema).optional(),
-      webhooks: z24.array(pluginWebhookDeclarationSchema).optional(),
-      tools: z24.array(pluginToolDeclarationSchema).optional(),
-      launchers: z24.array(pluginLauncherDeclarationSchema).optional(),
-      ui: z24.object({
-        slots: z24.array(pluginUiSlotDeclarationSchema).min(1).optional(),
-        launchers: z24.array(pluginLauncherDeclarationSchema).optional()
+      jobs: z25.array(pluginJobDeclarationSchema).optional(),
+      webhooks: z25.array(pluginWebhookDeclarationSchema).optional(),
+      tools: z25.array(pluginToolDeclarationSchema).optional(),
+      launchers: z25.array(pluginLauncherDeclarationSchema).optional(),
+      ui: z25.object({
+        slots: z25.array(pluginUiSlotDeclarationSchema).min(1).optional(),
+        launchers: z25.array(pluginLauncherDeclarationSchema).optional()
       }).optional()
     }).superRefine((manifest, ctx) => {
       const hasUiSlots = (manifest.ui?.slots?.length ?? 0) > 0;
       const hasUiLaunchers = (manifest.ui?.launchers?.length ?? 0) > 0;
       if ((hasUiSlots || hasUiLaunchers) && !manifest.entrypoints.ui) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "entrypoints.ui is required when ui.slots or ui.launchers are declared",
           path: ["entrypoints", "ui"]
         });
       }
       if (manifest.minimumHostVersion && manifest.minimumPaperclipVersion && manifest.minimumHostVersion !== manifest.minimumPaperclipVersion) {
         ctx.addIssue({
-          code: z24.ZodIssueCode.custom,
+          code: z25.ZodIssueCode.custom,
           message: "minimumHostVersion and minimumPaperclipVersion must match when both are declared",
           path: ["minimumHostVersion"]
         });
@@ -2209,7 +2232,7 @@ var init_plugin = __esm({
       if (manifest.tools && manifest.tools.length > 0) {
         if (!manifest.capabilities.includes("agent.tools.register")) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: "Capability 'agent.tools.register' is required when tools are declared",
             path: ["capabilities"]
           });
@@ -2218,7 +2241,7 @@ var init_plugin = __esm({
       if (manifest.jobs && manifest.jobs.length > 0) {
         if (!manifest.capabilities.includes("jobs.schedule")) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: "Capability 'jobs.schedule' is required when jobs are declared",
             path: ["capabilities"]
           });
@@ -2227,7 +2250,7 @@ var init_plugin = __esm({
       if (manifest.webhooks && manifest.webhooks.length > 0) {
         if (!manifest.capabilities.includes("webhooks.receive")) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: "Capability 'webhooks.receive' is required when webhooks are declared",
             path: ["capabilities"]
           });
@@ -2238,7 +2261,7 @@ var init_plugin = __esm({
         const duplicates = jobKeys.filter((key, i) => jobKeys.indexOf(key) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: `Duplicate job keys: ${[...new Set(duplicates)].join(", ")}`,
             path: ["jobs"]
           });
@@ -2249,7 +2272,7 @@ var init_plugin = __esm({
         const duplicates = endpointKeys.filter((key, i) => endpointKeys.indexOf(key) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: `Duplicate webhook endpoint keys: ${[...new Set(duplicates)].join(", ")}`,
             path: ["webhooks"]
           });
@@ -2260,7 +2283,7 @@ var init_plugin = __esm({
         const duplicates = toolNames.filter((name, i) => toolNames.indexOf(name) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: `Duplicate tool names: ${[...new Set(duplicates)].join(", ")}`,
             path: ["tools"]
           });
@@ -2272,7 +2295,7 @@ var init_plugin = __esm({
           const duplicates = slotIds.filter((id, i) => slotIds.indexOf(id) !== i);
           if (duplicates.length > 0) {
             ctx.addIssue({
-              code: z24.ZodIssueCode.custom,
+              code: z25.ZodIssueCode.custom,
               message: `Duplicate UI slot ids: ${[...new Set(duplicates)].join(", ")}`,
               path: ["ui", "slots"]
             });
@@ -2288,50 +2311,50 @@ var init_plugin = __esm({
         const duplicates = launcherIds.filter((id, i) => launcherIds.indexOf(id) !== i);
         if (duplicates.length > 0) {
           ctx.addIssue({
-            code: z24.ZodIssueCode.custom,
+            code: z25.ZodIssueCode.custom,
             message: `Duplicate launcher ids: ${[...new Set(duplicates)].join(", ")}`,
             path: manifest.ui?.launchers ? ["ui", "launchers"] : ["launchers"]
           });
         }
       }
     });
-    installPluginSchema = z24.object({
-      packageName: z24.string().min(1),
-      version: z24.string().min(1).optional(),
+    installPluginSchema = z25.object({
+      packageName: z25.string().min(1),
+      version: z25.string().min(1).optional(),
       /** Set by loader for local-path installs so the worker can be resolved. */
-      packagePath: z24.string().min(1).optional()
+      packagePath: z25.string().min(1).optional()
     });
-    upsertPluginConfigSchema = z24.object({
-      configJson: z24.record(z24.unknown())
+    upsertPluginConfigSchema = z25.object({
+      configJson: z25.record(z25.unknown())
     });
-    patchPluginConfigSchema = z24.object({
-      configJson: z24.record(z24.unknown())
+    patchPluginConfigSchema = z25.object({
+      configJson: z25.record(z25.unknown())
     });
-    updatePluginStatusSchema = z24.object({
-      status: z24.enum(PLUGIN_STATUSES),
-      lastError: z24.string().nullable().optional()
+    updatePluginStatusSchema = z25.object({
+      status: z25.enum(PLUGIN_STATUSES),
+      lastError: z25.string().nullable().optional()
     });
-    uninstallPluginSchema = z24.object({
-      removeData: z24.boolean().optional().default(false)
+    uninstallPluginSchema = z25.object({
+      removeData: z25.boolean().optional().default(false)
     });
-    pluginStateScopeKeySchema = z24.object({
-      scopeKind: z24.enum(PLUGIN_STATE_SCOPE_KINDS),
-      scopeId: z24.string().min(1).optional(),
-      namespace: z24.string().min(1).optional(),
-      stateKey: z24.string().min(1)
+    pluginStateScopeKeySchema = z25.object({
+      scopeKind: z25.enum(PLUGIN_STATE_SCOPE_KINDS),
+      scopeId: z25.string().min(1).optional(),
+      namespace: z25.string().min(1).optional(),
+      stateKey: z25.string().min(1)
     });
-    setPluginStateSchema = z24.object({
-      scopeKind: z24.enum(PLUGIN_STATE_SCOPE_KINDS),
-      scopeId: z24.string().min(1).optional(),
-      namespace: z24.string().min(1).optional(),
-      stateKey: z24.string().min(1),
+    setPluginStateSchema = z25.object({
+      scopeKind: z25.enum(PLUGIN_STATE_SCOPE_KINDS),
+      scopeId: z25.string().min(1).optional(),
+      namespace: z25.string().min(1).optional(),
+      stateKey: z25.string().min(1),
       /** JSON-serializable value to store. */
-      value: z24.unknown()
+      value: z25.unknown()
     });
-    listPluginStateSchema = z24.object({
-      scopeKind: z24.enum(PLUGIN_STATE_SCOPE_KINDS).optional(),
-      scopeId: z24.string().min(1).optional(),
-      namespace: z24.string().min(1).optional()
+    listPluginStateSchema = z25.object({
+      scopeKind: z25.enum(PLUGIN_STATE_SCOPE_KINDS).optional(),
+      scopeId: z25.string().min(1).optional(),
+      namespace: z25.string().min(1).optional()
     });
   }
 });
@@ -2353,6 +2376,7 @@ var init_validators = __esm({
     init_issue();
     init_work_product();
     init_execution_workspace();
+    init_workspace_backup2();
     init_goal();
     init_approval();
     init_secret();
@@ -2454,32 +2478,32 @@ var init_project_mentions = __esm({
 });
 
 // ../packages/shared/src/config-schema.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var configMetaSchema, llmConfigSchema, databaseBackupConfigSchema, databaseConfigSchema, loggingConfigSchema, serverConfigSchema, authConfigSchema, storageLocalDiskConfigSchema, storageS3ConfigSchema, storageConfigSchema, secretsLocalEncryptedConfigSchema, secretsConfigSchema, langfuseConfigSchema, rudderConfigSchema;
 var init_config_schema = __esm({
   "../packages/shared/src/config-schema.ts"() {
     "use strict";
     init_constants();
-    configMetaSchema = z25.object({
-      version: z25.literal(1),
-      updatedAt: z25.string(),
-      source: z25.enum(["onboard", "configure", "doctor"])
+    configMetaSchema = z26.object({
+      version: z26.literal(1),
+      updatedAt: z26.string(),
+      source: z26.enum(["onboard", "configure", "doctor"])
     });
-    llmConfigSchema = z25.object({
-      provider: z25.enum(["claude", "openai"]),
-      apiKey: z25.string().optional()
+    llmConfigSchema = z26.object({
+      provider: z26.enum(["claude", "openai"]),
+      apiKey: z26.string().optional()
     });
-    databaseBackupConfigSchema = z25.object({
-      enabled: z25.boolean().default(true),
-      intervalMinutes: z25.number().int().min(1).max(7 * 24 * 60).default(60),
-      retentionDays: z25.number().int().min(1).max(3650).default(30),
-      dir: z25.string().default("~/.rudder/instances/default/data/backups")
+    databaseBackupConfigSchema = z26.object({
+      enabled: z26.boolean().default(true),
+      intervalMinutes: z26.number().int().min(1).max(7 * 24 * 60).default(60),
+      retentionDays: z26.number().int().min(1).max(3650).default(30),
+      dir: z26.string().default("~/.rudder/instances/default/data/backups")
     });
-    databaseConfigSchema = z25.object({
-      mode: z25.enum(["embedded-postgres", "postgres"]).default("embedded-postgres"),
-      connectionString: z25.string().optional(),
-      embeddedPostgresDataDir: z25.string().default("~/.rudder/instances/default/db"),
-      embeddedPostgresPort: z25.number().int().min(1).max(65535).default(54329),
+    databaseConfigSchema = z26.object({
+      mode: z26.enum(["embedded-postgres", "postgres"]).default("embedded-postgres"),
+      connectionString: z26.string().optional(),
+      embeddedPostgresDataDir: z26.string().default("~/.rudder/instances/default/db"),
+      embeddedPostgresPort: z26.number().int().min(1).max(65535).default(54329),
       backup: databaseBackupConfigSchema.default({
         enabled: true,
         intervalMinutes: 60,
@@ -2487,35 +2511,35 @@ var init_config_schema = __esm({
         dir: "~/.rudder/instances/default/data/backups"
       })
     });
-    loggingConfigSchema = z25.object({
-      mode: z25.enum(["file", "cloud"]),
-      logDir: z25.string().default("~/.rudder/instances/default/logs")
+    loggingConfigSchema = z26.object({
+      mode: z26.enum(["file", "cloud"]),
+      logDir: z26.string().default("~/.rudder/instances/default/logs")
     });
-    serverConfigSchema = z25.object({
-      deploymentMode: z25.enum(DEPLOYMENT_MODES).default("local_trusted"),
-      exposure: z25.enum(DEPLOYMENT_EXPOSURES).default("private"),
-      host: z25.string().default("127.0.0.1"),
-      port: z25.number().int().min(1).max(65535).default(3100),
-      allowedHostnames: z25.array(z25.string().min(1)).default([]),
-      serveUi: z25.boolean().default(true)
+    serverConfigSchema = z26.object({
+      deploymentMode: z26.enum(DEPLOYMENT_MODES).default("local_trusted"),
+      exposure: z26.enum(DEPLOYMENT_EXPOSURES).default("private"),
+      host: z26.string().default("127.0.0.1"),
+      port: z26.number().int().min(1).max(65535).default(3100),
+      allowedHostnames: z26.array(z26.string().min(1)).default([]),
+      serveUi: z26.boolean().default(true)
     });
-    authConfigSchema = z25.object({
-      baseUrlMode: z25.enum(AUTH_BASE_URL_MODES).default("auto"),
-      publicBaseUrl: z25.string().url().optional(),
-      disableSignUp: z25.boolean().default(false)
+    authConfigSchema = z26.object({
+      baseUrlMode: z26.enum(AUTH_BASE_URL_MODES).default("auto"),
+      publicBaseUrl: z26.string().url().optional(),
+      disableSignUp: z26.boolean().default(false)
     });
-    storageLocalDiskConfigSchema = z25.object({
-      baseDir: z25.string().default("~/.rudder/instances/default/data/storage")
+    storageLocalDiskConfigSchema = z26.object({
+      baseDir: z26.string().default("~/.rudder/instances/default/data/storage")
     });
-    storageS3ConfigSchema = z25.object({
-      bucket: z25.string().min(1).default("rudder"),
-      region: z25.string().min(1).default("us-east-1"),
-      endpoint: z25.string().optional(),
-      prefix: z25.string().default(""),
-      forcePathStyle: z25.boolean().default(false)
+    storageS3ConfigSchema = z26.object({
+      bucket: z26.string().min(1).default("rudder"),
+      region: z26.string().min(1).default("us-east-1"),
+      endpoint: z26.string().optional(),
+      prefix: z26.string().default(""),
+      forcePathStyle: z26.boolean().default(false)
     });
-    storageConfigSchema = z25.object({
-      provider: z25.enum(STORAGE_PROVIDERS).default("local_disk"),
+    storageConfigSchema = z26.object({
+      provider: z26.enum(STORAGE_PROVIDERS).default("local_disk"),
       localDisk: storageLocalDiskConfigSchema.default({
         baseDir: "~/.rudder/instances/default/data/storage"
       }),
@@ -2526,24 +2550,24 @@ var init_config_schema = __esm({
         forcePathStyle: false
       })
     });
-    secretsLocalEncryptedConfigSchema = z25.object({
-      keyFilePath: z25.string().default("~/.rudder/instances/default/secrets/master.key")
+    secretsLocalEncryptedConfigSchema = z26.object({
+      keyFilePath: z26.string().default("~/.rudder/instances/default/secrets/master.key")
     });
-    secretsConfigSchema = z25.object({
-      provider: z25.enum(SECRET_PROVIDERS).default("local_encrypted"),
-      strictMode: z25.boolean().default(false),
+    secretsConfigSchema = z26.object({
+      provider: z26.enum(SECRET_PROVIDERS).default("local_encrypted"),
+      strictMode: z26.boolean().default(false),
       localEncrypted: secretsLocalEncryptedConfigSchema.default({
         keyFilePath: "~/.rudder/instances/default/secrets/master.key"
       })
     });
-    langfuseConfigSchema = z25.object({
-      enabled: z25.boolean().default(false),
-      baseUrl: z25.string().url().default("http://localhost:3000"),
-      publicKey: z25.string().optional(),
-      secretKey: z25.string().optional(),
-      environment: z25.string().optional()
+    langfuseConfigSchema = z26.object({
+      enabled: z26.boolean().default(false),
+      baseUrl: z26.string().url().default("http://localhost:3000"),
+      publicKey: z26.string().optional(),
+      secretKey: z26.string().optional(),
+      environment: z26.string().optional()
     });
-    rudderConfigSchema = z25.object({
+    rudderConfigSchema = z26.object({
       $meta: configMetaSchema,
       llm: llmConfigSchema.optional(),
       database: databaseConfigSchema,
@@ -2577,7 +2601,7 @@ var init_config_schema = __esm({
       if (value.server.deploymentMode === "local_trusted") {
         if (value.server.exposure !== "private") {
           ctx.addIssue({
-            code: z25.ZodIssueCode.custom,
+            code: z26.ZodIssueCode.custom,
             message: "server.exposure must be private when deploymentMode is local_trusted",
             path: ["server", "exposure"]
           });
@@ -2586,21 +2610,21 @@ var init_config_schema = __esm({
       }
       if (value.auth.baseUrlMode === "explicit" && !value.auth.publicBaseUrl) {
         ctx.addIssue({
-          code: z25.ZodIssueCode.custom,
+          code: z26.ZodIssueCode.custom,
           message: "auth.publicBaseUrl is required when auth.baseUrlMode is explicit",
           path: ["auth", "publicBaseUrl"]
         });
       }
       if (value.server.exposure === "public" && value.auth.baseUrlMode !== "explicit") {
         ctx.addIssue({
-          code: z25.ZodIssueCode.custom,
+          code: z26.ZodIssueCode.custom,
           message: "auth.baseUrlMode must be explicit when deploymentMode=authenticated and exposure=public",
           path: ["auth", "baseUrlMode"]
         });
       }
       if (value.server.exposure === "public" && !value.auth.publicBaseUrl) {
         ctx.addIssue({
-          code: z25.ZodIssueCode.custom,
+          code: z26.ZodIssueCode.custom,
           message: "auth.publicBaseUrl is required when deploymentMode=authenticated and exposure=public",
           path: ["auth", "publicBaseUrl"]
         });
@@ -2615,6 +2639,7 @@ var init_src = __esm({
     "use strict";
     init_constants();
     init_observability();
+    init_workspace_backup();
     init_validators();
     init_validators();
     init_api();
@@ -4929,8 +4954,9 @@ var init_workspace_operations = __esm({
   }
 });
 
-// ../packages/db/src/schema/workspace_runtime_services.ts
+// ../packages/db/src/schema/workspace_backups.ts
 import {
+  bigint as bigint4,
   index as index28,
   integer as integer11,
   jsonb as jsonb19,
@@ -4939,6 +4965,57 @@ import {
   timestamp as timestamp33,
   uuid as uuid31
 } from "drizzle-orm/pg-core";
+var workspaceBackups;
+var init_workspace_backups = __esm({
+  "../packages/db/src/schema/workspace_backups.ts"() {
+    "use strict";
+    init_organizations();
+    init_auth();
+    workspaceBackups = pgTable33(
+      "workspace_backups",
+      {
+        id: uuid31("id").primaryKey().defaultRandom(),
+        orgId: uuid31("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        status: text37("status").notNull().default("running"),
+        triggerSource: text37("trigger_source").notNull().default("manual"),
+        artifactProvider: text37("artifact_provider").notNull().default("local_file"),
+        artifactRef: text37("artifact_ref").notNull(),
+        archiveSha256: text37("archive_sha256"),
+        treeSha256: text37("tree_sha256"),
+        fileCount: integer11("file_count").notNull().default(0),
+        byteSize: bigint4("byte_size", { mode: "number" }).notNull().default(0),
+        compressedSize: bigint4("compressed_size", { mode: "number" }).notNull().default(0),
+        manifest: jsonb19("manifest").$type(),
+        warnings: jsonb19("warnings").$type(),
+        error: text37("error"),
+        startedAt: timestamp33("started_at", { withTimezone: true }),
+        finishedAt: timestamp33("finished_at", { withTimezone: true }),
+        expiresAt: timestamp33("expires_at", { withTimezone: true }),
+        restoredFromBackupId: uuid31("restored_from_backup_id").references(() => workspaceBackups.id, {
+          onDelete: "set null"
+        }),
+        createdByUserId: text37("created_by_user_id").references(() => authUsers.id, { onDelete: "set null" }),
+        createdAt: timestamp33("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp33("updated_at", { withTimezone: true }).notNull().defaultNow()
+      },
+      (table) => ({
+        orgCreatedIdx: index28("workspace_backups_org_created_idx").on(table.orgId, table.createdAt),
+        orgStatusIdx: index28("workspace_backups_org_status_idx").on(table.orgId, table.status)
+      })
+    );
+  }
+});
+
+// ../packages/db/src/schema/workspace_runtime_services.ts
+import {
+  index as index29,
+  integer as integer12,
+  jsonb as jsonb20,
+  pgTable as pgTable34,
+  text as text38,
+  timestamp as timestamp34,
+  uuid as uuid32
+} from "drizzle-orm/pg-core";
 var workspaceRuntimeServices;
 var init_workspace_runtime_services = __esm({
   "../packages/db/src/schema/workspace_runtime_services.ts"() {
@@ -4950,55 +5027,55 @@ var init_workspace_runtime_services = __esm({
     init_issues();
     init_agents();
     init_heartbeat_runs();
-    workspaceRuntimeServices = pgTable33(
+    workspaceRuntimeServices = pgTable34(
       "workspace_runtime_services",
       {
-        id: uuid31("id").primaryKey(),
-        orgId: uuid31("org_id").notNull().references(() => organizations.id),
-        projectId: uuid31("project_id").references(() => projects.id, { onDelete: "set null" }),
-        projectWorkspaceId: uuid31("project_workspace_id").references(() => projectWorkspaces.id, { onDelete: "set null" }),
-        executionWorkspaceId: uuid31("execution_workspace_id").references(() => executionWorkspaces.id, { onDelete: "set null" }),
-        issueId: uuid31("issue_id").references(() => issues.id, { onDelete: "set null" }),
-        scopeType: text37("scope_type").notNull(),
-        scopeId: text37("scope_id"),
-        serviceName: text37("service_name").notNull(),
-        status: text37("status").notNull(),
-        lifecycle: text37("lifecycle").notNull(),
-        reuseKey: text37("reuse_key"),
-        command: text37("command"),
-        cwd: text37("cwd"),
-        port: integer11("port"),
-        url: text37("url"),
-        provider: text37("provider").notNull(),
-        providerRef: text37("provider_ref"),
-        ownerAgentId: uuid31("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        startedByRunId: uuid31("started_by_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
-        lastUsedAt: timestamp33("last_used_at", { withTimezone: true }).notNull().defaultNow(),
-        startedAt: timestamp33("started_at", { withTimezone: true }).notNull().defaultNow(),
-        stoppedAt: timestamp33("stopped_at", { withTimezone: true }),
-        stopPolicy: jsonb19("stop_policy").$type(),
-        healthStatus: text37("health_status").notNull().default("unknown"),
-        createdAt: timestamp33("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp33("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid32("id").primaryKey(),
+        orgId: uuid32("org_id").notNull().references(() => organizations.id),
+        projectId: uuid32("project_id").references(() => projects.id, { onDelete: "set null" }),
+        projectWorkspaceId: uuid32("project_workspace_id").references(() => projectWorkspaces.id, { onDelete: "set null" }),
+        executionWorkspaceId: uuid32("execution_workspace_id").references(() => executionWorkspaces.id, { onDelete: "set null" }),
+        issueId: uuid32("issue_id").references(() => issues.id, { onDelete: "set null" }),
+        scopeType: text38("scope_type").notNull(),
+        scopeId: text38("scope_id"),
+        serviceName: text38("service_name").notNull(),
+        status: text38("status").notNull(),
+        lifecycle: text38("lifecycle").notNull(),
+        reuseKey: text38("reuse_key"),
+        command: text38("command"),
+        cwd: text38("cwd"),
+        port: integer12("port"),
+        url: text38("url"),
+        provider: text38("provider").notNull(),
+        providerRef: text38("provider_ref"),
+        ownerAgentId: uuid32("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        startedByRunId: uuid32("started_by_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+        lastUsedAt: timestamp34("last_used_at", { withTimezone: true }).notNull().defaultNow(),
+        startedAt: timestamp34("started_at", { withTimezone: true }).notNull().defaultNow(),
+        stoppedAt: timestamp34("stopped_at", { withTimezone: true }),
+        stopPolicy: jsonb20("stop_policy").$type(),
+        healthStatus: text38("health_status").notNull().default("unknown"),
+        createdAt: timestamp34("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp34("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyWorkspaceStatusIdx: index28("workspace_runtime_services_company_workspace_status_idx").on(
+        companyWorkspaceStatusIdx: index29("workspace_runtime_services_company_workspace_status_idx").on(
           table.orgId,
           table.projectWorkspaceId,
           table.status
         ),
-        companyExecutionWorkspaceStatusIdx: index28("workspace_runtime_services_company_execution_workspace_status_idx").on(
+        companyExecutionWorkspaceStatusIdx: index29("workspace_runtime_services_company_execution_workspace_status_idx").on(
           table.orgId,
           table.executionWorkspaceId,
           table.status
         ),
-        companyProjectStatusIdx: index28("workspace_runtime_services_company_project_status_idx").on(
+        companyProjectStatusIdx: index29("workspace_runtime_services_company_project_status_idx").on(
           table.orgId,
           table.projectId,
           table.status
         ),
-        runIdx: index28("workspace_runtime_services_run_idx").on(table.startedByRunId),
-        companyUpdatedIdx: index28("workspace_runtime_services_company_updated_idx").on(
+        runIdx: index29("workspace_runtime_services_run_idx").on(table.startedByRunId),
+        companyUpdatedIdx: index29("workspace_runtime_services_company_updated_idx").on(
           table.orgId,
           table.updatedAt
         )
@@ -5008,7 +5085,7 @@ var init_workspace_runtime_services = __esm({
 });
 
 // ../packages/db/src/schema/project_goals.ts
-import { pgTable as pgTable34, uuid as uuid32, timestamp as timestamp34, index as index29, primaryKey } from "drizzle-orm/pg-core";
+import { pgTable as pgTable35, uuid as uuid33, timestamp as timestamp35, index as index30, primaryKey } from "drizzle-orm/pg-core";
 var projectGoals;
 var init_project_goals = __esm({
   "../packages/db/src/schema/project_goals.ts"() {
@@ -5016,45 +5093,45 @@ var init_project_goals = __esm({
     init_organizations();
     init_projects();
     init_goals();
-    projectGoals = pgTable34(
+    projectGoals = pgTable35(
       "project_goals",
       {
-        projectId: uuid32("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-        goalId: uuid32("goal_id").notNull().references(() => goals.id, { onDelete: "cascade" }),
-        orgId: uuid32("org_id").notNull().references(() => organizations.id),
-        createdAt: timestamp34("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp34("updated_at", { withTimezone: true }).notNull().defaultNow()
+        projectId: uuid33("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+        goalId: uuid33("goal_id").notNull().references(() => goals.id, { onDelete: "cascade" }),
+        orgId: uuid33("org_id").notNull().references(() => organizations.id),
+        createdAt: timestamp35("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp35("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         pk: primaryKey({ columns: [table.projectId, table.goalId] }),
-        projectIdx: index29("project_goals_project_idx").on(table.projectId),
-        goalIdx: index29("project_goals_goal_idx").on(table.goalId),
-        orgIdx: index29("project_goals_company_idx").on(table.orgId)
+        projectIdx: index30("project_goals_project_idx").on(table.projectId),
+        goalIdx: index30("project_goals_goal_idx").on(table.goalId),
+        orgIdx: index30("project_goals_company_idx").on(table.orgId)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/issue_follows.ts
-import { index as index30, pgTable as pgTable35, timestamp as timestamp35, uniqueIndex as uniqueIndex20, uuid as uuid33, text as text38 } from "drizzle-orm/pg-core";
+import { index as index31, pgTable as pgTable36, timestamp as timestamp36, uniqueIndex as uniqueIndex20, uuid as uuid34, text as text39 } from "drizzle-orm/pg-core";
 var issueFollows;
 var init_issue_follows = __esm({
   "../packages/db/src/schema/issue_follows.ts"() {
     "use strict";
     init_organizations();
     init_issues();
-    issueFollows = pgTable35(
+    issueFollows = pgTable36(
       "issue_follows",
       {
-        id: uuid33("id").primaryKey().defaultRandom(),
-        orgId: uuid33("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        issueId: uuid33("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
-        userId: text38("user_id").notNull(),
-        createdAt: timestamp35("created_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid34("id").primaryKey().defaultRandom(),
+        orgId: uuid34("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        issueId: uuid34("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+        userId: text39("user_id").notNull(),
+        createdAt: timestamp36("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgIssueIdx: index30("issue_follows_org_issue_idx").on(table.orgId, table.issueId),
-        orgUserIdx: index30("issue_follows_org_user_idx").on(table.orgId, table.userId),
+        orgIssueIdx: index31("issue_follows_org_issue_idx").on(table.orgId, table.issueId),
+        orgUserIdx: index31("issue_follows_org_user_idx").on(table.orgId, table.userId),
         orgIssueUserUnique: uniqueIndex20("issue_follows_org_issue_user_idx").on(
           table.orgId,
           table.issueId,
@@ -5066,7 +5143,7 @@ var init_issue_follows = __esm({
 });
 
 // ../packages/db/src/schema/chat_conversations.ts
-import { boolean as boolean7, index as index31, pgTable as pgTable36, text as text39, timestamp as timestamp36, uuid as uuid34 } from "drizzle-orm/pg-core";
+import { boolean as boolean7, index as index32, pgTable as pgTable37, text as text40, timestamp as timestamp37, uuid as uuid35 } from "drizzle-orm/pg-core";
 var chatConversations;
 var init_chat_conversations = __esm({
   "../packages/db/src/schema/chat_conversations.ts"() {
@@ -5074,64 +5151,64 @@ var init_chat_conversations = __esm({
     init_agents();
     init_organizations();
     init_issues();
-    chatConversations = pgTable36(
+    chatConversations = pgTable37(
       "chat_conversations",
       {
-        id: uuid34("id").primaryKey().defaultRandom(),
-        orgId: uuid34("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        status: text39("status").notNull().default("active"),
-        title: text39("title").notNull().default("New chat"),
-        summary: text39("summary"),
-        preferredAgentId: uuid34("preferred_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        routedAgentId: uuid34("routed_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        primaryIssueId: uuid34("primary_issue_id").references(() => issues.id, { onDelete: "set null" }),
-        issueCreationMode: text39("issue_creation_mode").notNull().default("manual_approval"),
+        id: uuid35("id").primaryKey().defaultRandom(),
+        orgId: uuid35("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        status: text40("status").notNull().default("active"),
+        title: text40("title").notNull().default("New chat"),
+        summary: text40("summary"),
+        preferredAgentId: uuid35("preferred_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        routedAgentId: uuid35("routed_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        primaryIssueId: uuid35("primary_issue_id").references(() => issues.id, { onDelete: "set null" }),
+        issueCreationMode: text40("issue_creation_mode").notNull().default("manual_approval"),
         planMode: boolean7("plan_mode").notNull().default(false),
-        createdByUserId: text39("created_by_user_id"),
-        lastMessageAt: timestamp36("last_message_at", { withTimezone: true }),
-        resolvedAt: timestamp36("resolved_at", { withTimezone: true }),
-        createdAt: timestamp36("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp36("updated_at", { withTimezone: true }).notNull().defaultNow()
+        createdByUserId: text40("created_by_user_id"),
+        lastMessageAt: timestamp37("last_message_at", { withTimezone: true }),
+        resolvedAt: timestamp37("resolved_at", { withTimezone: true }),
+        createdAt: timestamp37("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp37("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgUpdatedIdx: index31("chat_conversations_org_updated_idx").on(table.orgId, table.updatedAt),
-        orgStatusUpdatedIdx: index31("chat_conversations_org_status_updated_idx").on(
+        orgUpdatedIdx: index32("chat_conversations_org_updated_idx").on(table.orgId, table.updatedAt),
+        orgStatusUpdatedIdx: index32("chat_conversations_org_status_updated_idx").on(
           table.orgId,
           table.status,
           table.updatedAt
         ),
-        primaryIssueIdx: index31("chat_conversations_primary_issue_idx").on(table.primaryIssueId)
+        primaryIssueIdx: index32("chat_conversations_primary_issue_idx").on(table.primaryIssueId)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/chat_conversation_user_states.ts
-import { index as index32, pgTable as pgTable37, text as text40, timestamp as timestamp37, uniqueIndex as uniqueIndex21, uuid as uuid35 } from "drizzle-orm/pg-core";
+import { index as index33, pgTable as pgTable38, text as text41, timestamp as timestamp38, uniqueIndex as uniqueIndex21, uuid as uuid36 } from "drizzle-orm/pg-core";
 var chatConversationUserStates;
 var init_chat_conversation_user_states = __esm({
   "../packages/db/src/schema/chat_conversation_user_states.ts"() {
     "use strict";
     init_chat_conversations();
     init_organizations();
-    chatConversationUserStates = pgTable37(
+    chatConversationUserStates = pgTable38(
       "chat_conversation_user_states",
       {
-        id: uuid35("id").primaryKey().defaultRandom(),
-        orgId: uuid35("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        conversationId: uuid35("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
-        userId: text40("user_id").notNull(),
-        lastReadAt: timestamp37("last_read_at", { withTimezone: true }).notNull().defaultNow(),
-        pinnedAt: timestamp37("pinned_at", { withTimezone: true }),
-        createdAt: timestamp37("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp37("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid36("id").primaryKey().defaultRandom(),
+        orgId: uuid36("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        conversationId: uuid36("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
+        userId: text41("user_id").notNull(),
+        lastReadAt: timestamp38("last_read_at", { withTimezone: true }).notNull().defaultNow(),
+        pinnedAt: timestamp38("pinned_at", { withTimezone: true }),
+        createdAt: timestamp38("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp38("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgConversationIdx: index32("chat_conversation_user_states_org_conversation_idx").on(
+        orgConversationIdx: index33("chat_conversation_user_states_org_conversation_idx").on(
           table.orgId,
           table.conversationId
         ),
-        orgUserIdx: index32("chat_conversation_user_states_org_user_idx").on(table.orgId, table.userId),
+        orgUserIdx: index33("chat_conversation_user_states_org_user_idx").on(table.orgId, table.userId),
         orgConversationUserUnique: uniqueIndex21("chat_conversation_user_states_org_conversation_user_idx").on(
           table.orgId,
           table.conversationId,
@@ -5143,7 +5220,7 @@ var init_chat_conversation_user_states = __esm({
 });
 
 // ../packages/db/src/schema/chat_messages.ts
-import { index as index33, integer as integer12, jsonb as jsonb20, pgTable as pgTable38, text as text41, timestamp as timestamp38, uuid as uuid36 } from "drizzle-orm/pg-core";
+import { index as index34, integer as integer13, jsonb as jsonb21, pgTable as pgTable39, text as text42, timestamp as timestamp39, uuid as uuid37 } from "drizzle-orm/pg-core";
 var chatMessages;
 var init_chat_messages = __esm({
   "../packages/db/src/schema/chat_messages.ts"() {
@@ -5152,69 +5229,69 @@ var init_chat_messages = __esm({
     init_approvals();
     init_chat_conversations();
     init_organizations();
-    chatMessages = pgTable38(
+    chatMessages = pgTable39(
       "chat_messages",
       {
-        id: uuid36("id").primaryKey().defaultRandom(),
-        orgId: uuid36("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        conversationId: uuid36("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
-        role: text41("role").notNull(),
-        kind: text41("kind").notNull().default("message"),
-        status: text41("status").notNull().default("completed"),
-        body: text41("body").notNull(),
-        structuredPayload: jsonb20("structured_payload").$type(),
-        approvalId: uuid36("approval_id").references(() => approvals.id, { onDelete: "set null" }),
-        replyingAgentId: uuid36("replying_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        id: uuid37("id").primaryKey().defaultRandom(),
+        orgId: uuid37("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        conversationId: uuid37("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
+        role: text42("role").notNull(),
+        kind: text42("kind").notNull().default("message"),
+        status: text42("status").notNull().default("completed"),
+        body: text42("body").notNull(),
+        structuredPayload: jsonb21("structured_payload").$type(),
+        approvalId: uuid37("approval_id").references(() => approvals.id, { onDelete: "set null" }),
+        replyingAgentId: uuid37("replying_agent_id").references(() => agents.id, { onDelete: "set null" }),
         /** User+assistant pairs that share a logical "turn" (for edit/regenerate variants). */
-        chatTurnId: uuid36("chat_turn_id"),
-        turnVariant: integer12("turn_variant").notNull().default(0),
-        supersededAt: timestamp38("superseded_at", { withTimezone: true }),
-        createdAt: timestamp38("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp38("updated_at", { withTimezone: true }).notNull().defaultNow()
+        chatTurnId: uuid37("chat_turn_id"),
+        turnVariant: integer13("turn_variant").notNull().default(0),
+        supersededAt: timestamp39("superseded_at", { withTimezone: true }),
+        createdAt: timestamp39("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp39("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        conversationCreatedIdx: index33("chat_messages_conversation_created_idx").on(
+        conversationCreatedIdx: index34("chat_messages_conversation_created_idx").on(
           table.conversationId,
           table.createdAt
         ),
-        orgConversationCreatedIdx: index33("chat_messages_org_conversation_created_idx").on(
+        orgConversationCreatedIdx: index34("chat_messages_org_conversation_created_idx").on(
           table.orgId,
           table.conversationId,
           table.createdAt
         ),
-        approvalIdx: index33("chat_messages_approval_idx").on(table.approvalId)
+        approvalIdx: index34("chat_messages_approval_idx").on(table.approvalId)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/chat_context_links.ts
-import { index as index34, jsonb as jsonb21, pgTable as pgTable39, text as text42, timestamp as timestamp39, uniqueIndex as uniqueIndex22, uuid as uuid37 } from "drizzle-orm/pg-core";
+import { index as index35, jsonb as jsonb22, pgTable as pgTable40, text as text43, timestamp as timestamp40, uniqueIndex as uniqueIndex22, uuid as uuid38 } from "drizzle-orm/pg-core";
 var chatContextLinks;
 var init_chat_context_links = __esm({
   "../packages/db/src/schema/chat_context_links.ts"() {
     "use strict";
     init_chat_conversations();
     init_organizations();
-    chatContextLinks = pgTable39(
+    chatContextLinks = pgTable40(
       "chat_context_links",
       {
-        id: uuid37("id").primaryKey().defaultRandom(),
-        orgId: uuid37("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        conversationId: uuid37("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
-        entityType: text42("entity_type").notNull(),
-        entityId: text42("entity_id").notNull(),
-        metadata: jsonb21("metadata").$type(),
-        createdAt: timestamp39("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp39("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid38("id").primaryKey().defaultRandom(),
+        orgId: uuid38("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        conversationId: uuid38("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
+        entityType: text43("entity_type").notNull(),
+        entityId: text43("entity_id").notNull(),
+        metadata: jsonb22("metadata").$type(),
+        createdAt: timestamp40("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp40("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        conversationEntityIdx: index34("chat_context_links_conversation_entity_idx").on(
+        conversationEntityIdx: index35("chat_context_links_conversation_entity_idx").on(
           table.conversationId,
           table.entityType,
           table.entityId
         ),
-        companyEntityIdx: index34("chat_context_links_company_entity_idx").on(
+        companyEntityIdx: index35("chat_context_links_company_entity_idx").on(
           table.orgId,
           table.entityType,
           table.entityId
@@ -5230,7 +5307,7 @@ var init_chat_context_links = __esm({
 });
 
 // ../packages/db/src/schema/chat_attachments.ts
-import { index as index35, pgTable as pgTable40, timestamp as timestamp40, uniqueIndex as uniqueIndex23, uuid as uuid38 } from "drizzle-orm/pg-core";
+import { index as index36, pgTable as pgTable41, timestamp as timestamp41, uniqueIndex as uniqueIndex23, uuid as uuid39 } from "drizzle-orm/pg-core";
 var chatAttachments;
 var init_chat_attachments = __esm({
   "../packages/db/src/schema/chat_attachments.ts"() {
@@ -5239,23 +5316,23 @@ var init_chat_attachments = __esm({
     init_chat_conversations();
     init_chat_messages();
     init_organizations();
-    chatAttachments = pgTable40(
+    chatAttachments = pgTable41(
       "chat_attachments",
       {
-        id: uuid38("id").primaryKey().defaultRandom(),
-        orgId: uuid38("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        conversationId: uuid38("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
-        messageId: uuid38("message_id").notNull().references(() => chatMessages.id, { onDelete: "cascade" }),
-        assetId: uuid38("asset_id").notNull().references(() => assets.id, { onDelete: "cascade" }),
-        createdAt: timestamp40("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp40("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid39("id").primaryKey().defaultRandom(),
+        orgId: uuid39("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        conversationId: uuid39("conversation_id").notNull().references(() => chatConversations.id, { onDelete: "cascade" }),
+        messageId: uuid39("message_id").notNull().references(() => chatMessages.id, { onDelete: "cascade" }),
+        assetId: uuid39("asset_id").notNull().references(() => assets.id, { onDelete: "cascade" }),
+        createdAt: timestamp41("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp41("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        conversationMessageIdx: index35("chat_attachments_conversation_message_idx").on(
+        conversationMessageIdx: index36("chat_attachments_conversation_message_idx").on(
           table.conversationId,
           table.messageId
         ),
-        companyConversationIdx: index35("chat_attachments_company_conversation_idx").on(
+        companyConversationIdx: index36("chat_attachments_company_conversation_idx").on(
           table.orgId,
           table.conversationId
         ),
@@ -5266,35 +5343,35 @@ var init_chat_attachments = __esm({
 });
 
 // ../packages/db/src/schema/calendar_sources.ts
-import { index as index36, jsonb as jsonb22, pgTable as pgTable41, text as text43, timestamp as timestamp41, uuid as uuid39 } from "drizzle-orm/pg-core";
+import { index as index37, jsonb as jsonb23, pgTable as pgTable42, text as text44, timestamp as timestamp42, uuid as uuid40 } from "drizzle-orm/pg-core";
 var calendarSources;
 var init_calendar_sources = __esm({
   "../packages/db/src/schema/calendar_sources.ts"() {
     "use strict";
     init_organizations();
     init_agents();
-    calendarSources = pgTable41(
+    calendarSources = pgTable42(
       "calendar_sources",
       {
-        id: uuid39("id").primaryKey().defaultRandom(),
-        orgId: uuid39("org_id").notNull().references(() => organizations.id),
-        type: text43("type").notNull().default("rudder_local"),
-        name: text43("name").notNull(),
-        ownerType: text43("owner_type").notNull().default("user"),
-        ownerUserId: text43("owner_user_id"),
-        ownerAgentId: uuid39("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        externalProvider: text43("external_provider"),
-        externalCalendarId: text43("external_calendar_id"),
-        visibilityDefault: text43("visibility_default").notNull().default("full"),
-        status: text43("status").notNull().default("active"),
-        lastSyncedAt: timestamp41("last_synced_at", { withTimezone: true }),
-        syncCursorJson: jsonb22("sync_cursor_json").$type(),
-        createdAt: timestamp41("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp41("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid40("id").primaryKey().defaultRandom(),
+        orgId: uuid40("org_id").notNull().references(() => organizations.id),
+        type: text44("type").notNull().default("rudder_local"),
+        name: text44("name").notNull(),
+        ownerType: text44("owner_type").notNull().default("user"),
+        ownerUserId: text44("owner_user_id"),
+        ownerAgentId: uuid40("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        externalProvider: text44("external_provider"),
+        externalCalendarId: text44("external_calendar_id"),
+        visibilityDefault: text44("visibility_default").notNull().default("full"),
+        status: text44("status").notNull().default("active"),
+        lastSyncedAt: timestamp42("last_synced_at", { withTimezone: true }),
+        syncCursorJson: jsonb23("sync_cursor_json").$type(),
+        createdAt: timestamp42("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp42("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgTypeIdx: index36("calendar_sources_org_type_idx").on(table.orgId, table.type),
-        externalIdx: index36("calendar_sources_external_idx").on(
+        orgTypeIdx: index37("calendar_sources_org_type_idx").on(table.orgId, table.type),
+        externalIdx: index37("calendar_sources_external_idx").on(
           table.orgId,
           table.externalProvider,
           table.externalCalendarId
@@ -5305,7 +5382,7 @@ var init_calendar_sources = __esm({
 });
 
 // ../packages/db/src/schema/activity_log.ts
-import { pgTable as pgTable42, uuid as uuid40, text as text44, timestamp as timestamp42, jsonb as jsonb23, index as index37 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable43, uuid as uuid41, text as text45, timestamp as timestamp43, jsonb as jsonb24, index as index38 } from "drizzle-orm/pg-core";
 var activityLog;
 var init_activity_log = __esm({
   "../packages/db/src/schema/activity_log.ts"() {
@@ -5313,32 +5390,32 @@ var init_activity_log = __esm({
     init_organizations();
     init_agents();
     init_heartbeat_runs();
-    activityLog = pgTable42(
+    activityLog = pgTable43(
       "activity_log",
       {
-        id: uuid40("id").primaryKey().defaultRandom(),
-        orgId: uuid40("org_id").notNull().references(() => organizations.id),
-        actorType: text44("actor_type").notNull().default("system"),
-        actorId: text44("actor_id").notNull(),
-        action: text44("action").notNull(),
-        entityType: text44("entity_type").notNull(),
-        entityId: text44("entity_id").notNull(),
-        agentId: uuid40("agent_id").references(() => agents.id),
-        runId: uuid40("run_id").references(() => heartbeatRuns.id),
-        details: jsonb23("details").$type(),
-        createdAt: timestamp42("created_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid41("id").primaryKey().defaultRandom(),
+        orgId: uuid41("org_id").notNull().references(() => organizations.id),
+        actorType: text45("actor_type").notNull().default("system"),
+        actorId: text45("actor_id").notNull(),
+        action: text45("action").notNull(),
+        entityType: text45("entity_type").notNull(),
+        entityId: text45("entity_id").notNull(),
+        agentId: uuid41("agent_id").references(() => agents.id),
+        runId: uuid41("run_id").references(() => heartbeatRuns.id),
+        details: jsonb24("details").$type(),
+        createdAt: timestamp43("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyCreatedIdx: index37("activity_log_company_created_idx").on(table.orgId, table.createdAt),
-        runIdIdx: index37("activity_log_run_id_idx").on(table.runId),
-        entityIdx: index37("activity_log_entity_type_id_idx").on(table.entityType, table.entityId)
+        companyCreatedIdx: index38("activity_log_company_created_idx").on(table.orgId, table.createdAt),
+        runIdIdx: index38("activity_log_run_id_idx").on(table.runId),
+        entityIdx: index38("activity_log_entity_type_id_idx").on(table.entityType, table.entityId)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/calendar_events.ts
-import { index as index38, pgTable as pgTable43, text as text45, timestamp as timestamp43, uuid as uuid41, boolean as boolean8 } from "drizzle-orm/pg-core";
+import { index as index39, pgTable as pgTable44, text as text46, timestamp as timestamp44, uuid as uuid42, boolean as boolean8 } from "drizzle-orm/pg-core";
 var calendarEvents;
 var init_calendar_events = __esm({
   "../packages/db/src/schema/calendar_events.ts"() {
@@ -5352,55 +5429,55 @@ var init_calendar_events = __esm({
     init_approvals();
     init_heartbeat_runs();
     init_activity_log();
-    calendarEvents = pgTable43(
+    calendarEvents = pgTable44(
       "calendar_events",
       {
-        id: uuid41("id").primaryKey().defaultRandom(),
-        orgId: uuid41("org_id").notNull().references(() => organizations.id),
-        sourceId: uuid41("source_id").references(() => calendarSources.id, { onDelete: "set null" }),
-        eventKind: text45("event_kind").notNull(),
-        eventStatus: text45("event_status").notNull(),
-        ownerType: text45("owner_type").notNull(),
-        ownerUserId: text45("owner_user_id"),
-        ownerAgentId: uuid41("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        title: text45("title").notNull(),
-        description: text45("description"),
-        startAt: timestamp43("start_at", { withTimezone: true }).notNull(),
-        endAt: timestamp43("end_at", { withTimezone: true }).notNull(),
-        timezone: text45("timezone").notNull().default("UTC"),
+        id: uuid42("id").primaryKey().defaultRandom(),
+        orgId: uuid42("org_id").notNull().references(() => organizations.id),
+        sourceId: uuid42("source_id").references(() => calendarSources.id, { onDelete: "set null" }),
+        eventKind: text46("event_kind").notNull(),
+        eventStatus: text46("event_status").notNull(),
+        ownerType: text46("owner_type").notNull(),
+        ownerUserId: text46("owner_user_id"),
+        ownerAgentId: uuid42("owner_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        title: text46("title").notNull(),
+        description: text46("description"),
+        startAt: timestamp44("start_at", { withTimezone: true }).notNull(),
+        endAt: timestamp44("end_at", { withTimezone: true }).notNull(),
+        timezone: text46("timezone").notNull().default("UTC"),
         allDay: boolean8("all_day").notNull().default(false),
-        visibility: text45("visibility").notNull().default("full"),
-        issueId: uuid41("issue_id").references(() => issues.id, { onDelete: "set null" }),
-        projectId: uuid41("project_id").references(() => projects.id, { onDelete: "set null" }),
-        goalId: uuid41("goal_id").references(() => goals.id, { onDelete: "set null" }),
-        approvalId: uuid41("approval_id").references(() => approvals.id, { onDelete: "set null" }),
-        heartbeatRunId: uuid41("heartbeat_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
-        activityId: uuid41("activity_id").references(() => activityLog.id, { onDelete: "set null" }),
-        sourceMode: text45("source_mode").notNull().default("manual"),
-        externalProvider: text45("external_provider"),
-        externalCalendarId: text45("external_calendar_id"),
-        externalEventId: text45("external_event_id"),
-        externalEtag: text45("external_etag"),
-        externalUpdatedAt: timestamp43("external_updated_at", { withTimezone: true }),
-        createdByUserId: text45("created_by_user_id"),
-        updatedByUserId: text45("updated_by_user_id"),
-        createdAt: timestamp43("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp43("updated_at", { withTimezone: true }).notNull().defaultNow(),
-        deletedAt: timestamp43("deleted_at", { withTimezone: true })
+        visibility: text46("visibility").notNull().default("full"),
+        issueId: uuid42("issue_id").references(() => issues.id, { onDelete: "set null" }),
+        projectId: uuid42("project_id").references(() => projects.id, { onDelete: "set null" }),
+        goalId: uuid42("goal_id").references(() => goals.id, { onDelete: "set null" }),
+        approvalId: uuid42("approval_id").references(() => approvals.id, { onDelete: "set null" }),
+        heartbeatRunId: uuid42("heartbeat_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+        activityId: uuid42("activity_id").references(() => activityLog.id, { onDelete: "set null" }),
+        sourceMode: text46("source_mode").notNull().default("manual"),
+        externalProvider: text46("external_provider"),
+        externalCalendarId: text46("external_calendar_id"),
+        externalEventId: text46("external_event_id"),
+        externalEtag: text46("external_etag"),
+        externalUpdatedAt: timestamp44("external_updated_at", { withTimezone: true }),
+        createdByUserId: text46("created_by_user_id"),
+        updatedByUserId: text46("updated_by_user_id"),
+        createdAt: timestamp44("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp44("updated_at", { withTimezone: true }).notNull().defaultNow(),
+        deletedAt: timestamp44("deleted_at", { withTimezone: true })
       },
       (table) => ({
-        orgRangeIdx: index38("calendar_events_org_range_idx").on(table.orgId, table.startAt, table.endAt),
-        orgAgentRangeIdx: index38("calendar_events_org_agent_range_idx").on(
+        orgRangeIdx: index39("calendar_events_org_range_idx").on(table.orgId, table.startAt, table.endAt),
+        orgAgentRangeIdx: index39("calendar_events_org_agent_range_idx").on(
           table.orgId,
           table.ownerAgentId,
           table.startAt
         ),
-        orgSourceRangeIdx: index38("calendar_events_org_source_range_idx").on(
+        orgSourceRangeIdx: index39("calendar_events_org_source_range_idx").on(
           table.orgId,
           table.sourceId,
           table.startAt
         ),
-        externalIdx: index38("calendar_events_external_idx").on(
+        externalIdx: index39("calendar_events_external_idx").on(
           table.orgId,
           table.externalProvider,
           table.externalCalendarId,
@@ -5412,31 +5489,31 @@ var init_calendar_events = __esm({
 });
 
 // ../packages/db/src/schema/organization_secrets.ts
-import { pgTable as pgTable44, uuid as uuid42, text as text46, timestamp as timestamp44, integer as integer13, index as index39, uniqueIndex as uniqueIndex24 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable45, uuid as uuid43, text as text47, timestamp as timestamp45, integer as integer14, index as index40, uniqueIndex as uniqueIndex24 } from "drizzle-orm/pg-core";
 var organizationSecrets;
 var init_organization_secrets = __esm({
   "../packages/db/src/schema/organization_secrets.ts"() {
     "use strict";
     init_organizations();
     init_agents();
-    organizationSecrets = pgTable44(
+    organizationSecrets = pgTable45(
       "organization_secrets",
       {
-        id: uuid42("id").primaryKey().defaultRandom(),
-        orgId: uuid42("org_id").notNull().references(() => organizations.id),
-        name: text46("name").notNull(),
-        provider: text46("provider").notNull().default("local_encrypted"),
-        externalRef: text46("external_ref"),
-        latestVersion: integer13("latest_version").notNull().default(1),
-        description: text46("description"),
-        createdByAgentId: uuid42("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        createdByUserId: text46("created_by_user_id"),
-        createdAt: timestamp44("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp44("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid43("id").primaryKey().defaultRandom(),
+        orgId: uuid43("org_id").notNull().references(() => organizations.id),
+        name: text47("name").notNull(),
+        provider: text47("provider").notNull().default("local_encrypted"),
+        externalRef: text47("external_ref"),
+        latestVersion: integer14("latest_version").notNull().default(1),
+        description: text47("description"),
+        createdByAgentId: uuid43("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        createdByUserId: text47("created_by_user_id"),
+        createdAt: timestamp45("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp45("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        organizationIdx: index39("organization_secrets_org_idx").on(table.orgId),
-        organizationProviderIdx: index39("organization_secrets_org_provider_idx").on(table.orgId, table.provider),
+        organizationIdx: index40("organization_secrets_org_idx").on(table.orgId),
+        organizationProviderIdx: index40("organization_secrets_org_provider_idx").on(table.orgId, table.provider),
         organizationNameUq: uniqueIndex24("organization_secrets_org_name_uq").on(table.orgId, table.name)
       })
     );
@@ -5446,14 +5523,14 @@ var init_organization_secrets = __esm({
 // ../packages/db/src/schema/automations.ts
 import {
   boolean as boolean9,
-  index as index40,
-  integer as integer14,
-  jsonb as jsonb24,
-  pgTable as pgTable45,
-  text as text47,
-  timestamp as timestamp45,
+  index as index41,
+  integer as integer15,
+  jsonb as jsonb25,
+  pgTable as pgTable46,
+  text as text48,
+  timestamp as timestamp46,
   uniqueIndex as uniqueIndex25,
-  uuid as uuid43
+  uuid as uuid44
 } from "drizzle-orm/pg-core";
 var automations, automationTriggers, automationRuns;
 var init_automations = __esm({
@@ -5465,94 +5542,94 @@ var init_automations = __esm({
     init_issues();
     init_projects();
     init_goals();
-    automations = pgTable45(
+    automations = pgTable46(
       "automations",
       {
-        id: uuid43("id").primaryKey().defaultRandom(),
-        orgId: uuid43("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        projectId: uuid43("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
-        goalId: uuid43("goal_id").references(() => goals.id, { onDelete: "set null" }),
-        parentIssueId: uuid43("parent_issue_id").references(() => issues.id, { onDelete: "set null" }),
-        title: text47("title").notNull(),
-        description: text47("description"),
-        assigneeAgentId: uuid43("assignee_agent_id").notNull().references(() => agents.id),
-        priority: text47("priority").notNull().default("medium"),
-        status: text47("status").notNull().default("active"),
-        concurrencyPolicy: text47("concurrency_policy").notNull().default("coalesce_if_active"),
-        catchUpPolicy: text47("catch_up_policy").notNull().default("skip_missed"),
-        createdByAgentId: uuid43("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        createdByUserId: text47("created_by_user_id"),
-        updatedByAgentId: uuid43("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        updatedByUserId: text47("updated_by_user_id"),
-        lastTriggeredAt: timestamp45("last_triggered_at", { withTimezone: true }),
-        lastEnqueuedAt: timestamp45("last_enqueued_at", { withTimezone: true }),
-        createdAt: timestamp45("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp45("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid44("id").primaryKey().defaultRandom(),
+        orgId: uuid44("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        projectId: uuid44("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+        goalId: uuid44("goal_id").references(() => goals.id, { onDelete: "set null" }),
+        parentIssueId: uuid44("parent_issue_id").references(() => issues.id, { onDelete: "set null" }),
+        title: text48("title").notNull(),
+        description: text48("description"),
+        assigneeAgentId: uuid44("assignee_agent_id").notNull().references(() => agents.id),
+        priority: text48("priority").notNull().default("medium"),
+        status: text48("status").notNull().default("active"),
+        concurrencyPolicy: text48("concurrency_policy").notNull().default("coalesce_if_active"),
+        catchUpPolicy: text48("catch_up_policy").notNull().default("skip_missed"),
+        createdByAgentId: uuid44("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        createdByUserId: text48("created_by_user_id"),
+        updatedByAgentId: uuid44("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        updatedByUserId: text48("updated_by_user_id"),
+        lastTriggeredAt: timestamp46("last_triggered_at", { withTimezone: true }),
+        lastEnqueuedAt: timestamp46("last_enqueued_at", { withTimezone: true }),
+        createdAt: timestamp46("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp46("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyStatusIdx: index40("automations_company_status_idx").on(table.orgId, table.status),
-        companyAssigneeIdx: index40("automations_company_assignee_idx").on(table.orgId, table.assigneeAgentId),
-        companyProjectIdx: index40("automations_company_project_idx").on(table.orgId, table.projectId)
+        companyStatusIdx: index41("automations_company_status_idx").on(table.orgId, table.status),
+        companyAssigneeIdx: index41("automations_company_assignee_idx").on(table.orgId, table.assigneeAgentId),
+        companyProjectIdx: index41("automations_company_project_idx").on(table.orgId, table.projectId)
       })
     );
-    automationTriggers = pgTable45(
+    automationTriggers = pgTable46(
       "automation_triggers",
       {
-        id: uuid43("id").primaryKey().defaultRandom(),
-        orgId: uuid43("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        automationId: uuid43("automation_id").notNull().references(() => automations.id, { onDelete: "cascade" }),
-        kind: text47("kind").notNull(),
-        label: text47("label"),
+        id: uuid44("id").primaryKey().defaultRandom(),
+        orgId: uuid44("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        automationId: uuid44("automation_id").notNull().references(() => automations.id, { onDelete: "cascade" }),
+        kind: text48("kind").notNull(),
+        label: text48("label"),
         enabled: boolean9("enabled").notNull().default(true),
-        cronExpression: text47("cron_expression"),
-        timezone: text47("timezone"),
-        nextRunAt: timestamp45("next_run_at", { withTimezone: true }),
-        lastFiredAt: timestamp45("last_fired_at", { withTimezone: true }),
-        publicId: text47("public_id"),
-        secretId: uuid43("secret_id").references(() => organizationSecrets.id, { onDelete: "set null" }),
-        signingMode: text47("signing_mode"),
-        replayWindowSec: integer14("replay_window_sec"),
-        lastRotatedAt: timestamp45("last_rotated_at", { withTimezone: true }),
-        lastResult: text47("last_result"),
-        createdByAgentId: uuid43("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        createdByUserId: text47("created_by_user_id"),
-        updatedByAgentId: uuid43("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        updatedByUserId: text47("updated_by_user_id"),
-        createdAt: timestamp45("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp45("updated_at", { withTimezone: true }).notNull().defaultNow()
+        cronExpression: text48("cron_expression"),
+        timezone: text48("timezone"),
+        nextRunAt: timestamp46("next_run_at", { withTimezone: true }),
+        lastFiredAt: timestamp46("last_fired_at", { withTimezone: true }),
+        publicId: text48("public_id"),
+        secretId: uuid44("secret_id").references(() => organizationSecrets.id, { onDelete: "set null" }),
+        signingMode: text48("signing_mode"),
+        replayWindowSec: integer15("replay_window_sec"),
+        lastRotatedAt: timestamp46("last_rotated_at", { withTimezone: true }),
+        lastResult: text48("last_result"),
+        createdByAgentId: uuid44("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        createdByUserId: text48("created_by_user_id"),
+        updatedByAgentId: uuid44("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        updatedByUserId: text48("updated_by_user_id"),
+        createdAt: timestamp46("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp46("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyAutomationIdx: index40("automation_triggers_company_automation_idx").on(table.orgId, table.automationId),
-        companyKindIdx: index40("automation_triggers_company_kind_idx").on(table.orgId, table.kind),
-        nextRunIdx: index40("automation_triggers_next_run_idx").on(table.nextRunAt),
-        publicIdIdx: index40("automation_triggers_public_id_idx").on(table.publicId),
+        companyAutomationIdx: index41("automation_triggers_company_automation_idx").on(table.orgId, table.automationId),
+        companyKindIdx: index41("automation_triggers_company_kind_idx").on(table.orgId, table.kind),
+        nextRunIdx: index41("automation_triggers_next_run_idx").on(table.nextRunAt),
+        publicIdIdx: index41("automation_triggers_public_id_idx").on(table.publicId),
         publicIdUq: uniqueIndex25("automation_triggers_public_id_uq").on(table.publicId)
       })
     );
-    automationRuns = pgTable45(
+    automationRuns = pgTable46(
       "automation_runs",
       {
-        id: uuid43("id").primaryKey().defaultRandom(),
-        orgId: uuid43("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        automationId: uuid43("automation_id").notNull().references(() => automations.id, { onDelete: "cascade" }),
-        triggerId: uuid43("trigger_id").references(() => automationTriggers.id, { onDelete: "set null" }),
-        source: text47("source").notNull(),
-        status: text47("status").notNull().default("received"),
-        triggeredAt: timestamp45("triggered_at", { withTimezone: true }).notNull().defaultNow(),
-        idempotencyKey: text47("idempotency_key"),
-        triggerPayload: jsonb24("trigger_payload").$type(),
-        linkedIssueId: uuid43("linked_issue_id").references(() => issues.id, { onDelete: "set null" }),
-        coalescedIntoRunId: uuid43("coalesced_into_run_id"),
-        failureReason: text47("failure_reason"),
-        completedAt: timestamp45("completed_at", { withTimezone: true }),
-        createdAt: timestamp45("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp45("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid44("id").primaryKey().defaultRandom(),
+        orgId: uuid44("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        automationId: uuid44("automation_id").notNull().references(() => automations.id, { onDelete: "cascade" }),
+        triggerId: uuid44("trigger_id").references(() => automationTriggers.id, { onDelete: "set null" }),
+        source: text48("source").notNull(),
+        status: text48("status").notNull().default("received"),
+        triggeredAt: timestamp46("triggered_at", { withTimezone: true }).notNull().defaultNow(),
+        idempotencyKey: text48("idempotency_key"),
+        triggerPayload: jsonb25("trigger_payload").$type(),
+        linkedIssueId: uuid44("linked_issue_id").references(() => issues.id, { onDelete: "set null" }),
+        coalescedIntoRunId: uuid44("coalesced_into_run_id"),
+        failureReason: text48("failure_reason"),
+        completedAt: timestamp46("completed_at", { withTimezone: true }),
+        createdAt: timestamp46("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp46("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyAutomationIdx: index40("automation_runs_company_automation_idx").on(table.orgId, table.automationId, table.createdAt),
-        triggerIdx: index40("automation_runs_trigger_idx").on(table.triggerId, table.createdAt),
-        linkedIssueIdx: index40("automation_runs_linked_issue_idx").on(table.linkedIssueId),
-        idempotencyIdx: index40("automation_runs_trigger_idempotency_idx").on(table.triggerId, table.idempotencyKey)
+        companyAutomationIdx: index41("automation_runs_company_automation_idx").on(table.orgId, table.automationId, table.createdAt),
+        triggerIdx: index41("automation_runs_trigger_idx").on(table.triggerId, table.createdAt),
+        linkedIssueIdx: index41("automation_runs_linked_issue_idx").on(table.linkedIssueId),
+        idempotencyIdx: index41("automation_runs_trigger_idempotency_idx").on(table.triggerId, table.idempotencyKey)
       })
     );
   }
@@ -5561,12 +5638,12 @@ var init_automations = __esm({
 // ../packages/db/src/schema/issue_work_products.ts
 import {
   boolean as boolean10,
-  index as index41,
-  jsonb as jsonb25,
-  pgTable as pgTable46,
-  text as text48,
-  timestamp as timestamp46,
-  uuid as uuid44
+  index as index42,
+  jsonb as jsonb26,
+  pgTable as pgTable47,
+  text as text49,
+  timestamp as timestamp47,
+  uuid as uuid45
 } from "drizzle-orm/pg-core";
 var issueWorkProducts;
 var init_issue_work_products = __esm({
@@ -5578,47 +5655,47 @@ var init_issue_work_products = __esm({
     init_issues();
     init_projects();
     init_workspace_runtime_services();
-    issueWorkProducts = pgTable46(
+    issueWorkProducts = pgTable47(
       "issue_work_products",
       {
-        id: uuid44("id").primaryKey().defaultRandom(),
-        orgId: uuid44("org_id").notNull().references(() => organizations.id),
-        projectId: uuid44("project_id").references(() => projects.id, { onDelete: "set null" }),
-        issueId: uuid44("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
-        executionWorkspaceId: uuid44("execution_workspace_id").references(() => executionWorkspaces.id, { onDelete: "set null" }),
-        runtimeServiceId: uuid44("runtime_service_id").references(() => workspaceRuntimeServices.id, { onDelete: "set null" }),
-        type: text48("type").notNull(),
-        provider: text48("provider").notNull(),
-        externalId: text48("external_id"),
-        title: text48("title").notNull(),
-        url: text48("url"),
-        status: text48("status").notNull(),
-        reviewState: text48("review_state").notNull().default("none"),
+        id: uuid45("id").primaryKey().defaultRandom(),
+        orgId: uuid45("org_id").notNull().references(() => organizations.id),
+        projectId: uuid45("project_id").references(() => projects.id, { onDelete: "set null" }),
+        issueId: uuid45("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+        executionWorkspaceId: uuid45("execution_workspace_id").references(() => executionWorkspaces.id, { onDelete: "set null" }),
+        runtimeServiceId: uuid45("runtime_service_id").references(() => workspaceRuntimeServices.id, { onDelete: "set null" }),
+        type: text49("type").notNull(),
+        provider: text49("provider").notNull(),
+        externalId: text49("external_id"),
+        title: text49("title").notNull(),
+        url: text49("url"),
+        status: text49("status").notNull(),
+        reviewState: text49("review_state").notNull().default("none"),
         isPrimary: boolean10("is_primary").notNull().default(false),
-        healthStatus: text48("health_status").notNull().default("unknown"),
-        summary: text48("summary"),
-        metadata: jsonb25("metadata").$type(),
-        createdByRunId: uuid44("created_by_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
-        createdAt: timestamp46("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp46("updated_at", { withTimezone: true }).notNull().defaultNow()
+        healthStatus: text49("health_status").notNull().default("unknown"),
+        summary: text49("summary"),
+        metadata: jsonb26("metadata").$type(),
+        createdByRunId: uuid45("created_by_run_id").references(() => heartbeatRuns.id, { onDelete: "set null" }),
+        createdAt: timestamp47("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp47("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyIssueTypeIdx: index41("issue_work_products_company_issue_type_idx").on(
+        companyIssueTypeIdx: index42("issue_work_products_company_issue_type_idx").on(
           table.orgId,
           table.issueId,
           table.type
         ),
-        companyExecutionWorkspaceTypeIdx: index41("issue_work_products_company_execution_workspace_type_idx").on(
+        companyExecutionWorkspaceTypeIdx: index42("issue_work_products_company_execution_workspace_type_idx").on(
           table.orgId,
           table.executionWorkspaceId,
           table.type
         ),
-        companyProviderExternalIdIdx: index41("issue_work_products_company_provider_external_id_idx").on(
+        companyProviderExternalIdIdx: index42("issue_work_products_company_provider_external_id_idx").on(
           table.orgId,
           table.provider,
           table.externalId
         ),
-        companyUpdatedIdx: index41("issue_work_products_company_updated_idx").on(
+        companyUpdatedIdx: index42("issue_work_products_company_updated_idx").on(
           table.orgId,
           table.updatedAt
         )
@@ -5628,24 +5705,24 @@ var init_issue_work_products = __esm({
 });
 
 // ../packages/db/src/schema/labels.ts
-import { pgTable as pgTable47, uuid as uuid45, text as text49, timestamp as timestamp47, index as index42, uniqueIndex as uniqueIndex26 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable48, uuid as uuid46, text as text50, timestamp as timestamp48, index as index43, uniqueIndex as uniqueIndex26 } from "drizzle-orm/pg-core";
 var labels;
 var init_labels = __esm({
   "../packages/db/src/schema/labels.ts"() {
     "use strict";
     init_organizations();
-    labels = pgTable47(
+    labels = pgTable48(
       "labels",
       {
-        id: uuid45("id").primaryKey().defaultRandom(),
-        orgId: uuid45("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        name: text49("name").notNull(),
-        color: text49("color").notNull(),
-        createdAt: timestamp47("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp47("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid46("id").primaryKey().defaultRandom(),
+        orgId: uuid46("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        name: text50("name").notNull(),
+        color: text50("color").notNull(),
+        createdAt: timestamp48("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp48("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgIdx: index42("labels_company_idx").on(table.orgId),
+        orgIdx: index43("labels_company_idx").on(table.orgId),
         orgNameIdx: uniqueIndex26("labels_company_name_idx").on(table.orgId, table.name)
       })
     );
@@ -5653,7 +5730,7 @@ var init_labels = __esm({
 });
 
 // ../packages/db/src/schema/issue_labels.ts
-import { pgTable as pgTable48, uuid as uuid46, timestamp as timestamp48, index as index43, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable49, uuid as uuid47, timestamp as timestamp49, index as index44, primaryKey as primaryKey2 } from "drizzle-orm/pg-core";
 var issueLabels;
 var init_issue_labels = __esm({
   "../packages/db/src/schema/issue_labels.ts"() {
@@ -5661,26 +5738,26 @@ var init_issue_labels = __esm({
     init_organizations();
     init_issues();
     init_labels();
-    issueLabels = pgTable48(
+    issueLabels = pgTable49(
       "issue_labels",
       {
-        issueId: uuid46("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
-        labelId: uuid46("label_id").notNull().references(() => labels.id, { onDelete: "cascade" }),
-        orgId: uuid46("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        createdAt: timestamp48("created_at", { withTimezone: true }).notNull().defaultNow()
+        issueId: uuid47("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+        labelId: uuid47("label_id").notNull().references(() => labels.id, { onDelete: "cascade" }),
+        orgId: uuid47("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        createdAt: timestamp49("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         pk: primaryKey2({ columns: [table.issueId, table.labelId], name: "issue_labels_pk" }),
-        issueIdx: index43("issue_labels_issue_idx").on(table.issueId),
-        labelIdx: index43("issue_labels_label_idx").on(table.labelId),
-        orgIdx: index43("issue_labels_company_idx").on(table.orgId)
+        issueIdx: index44("issue_labels_issue_idx").on(table.issueId),
+        labelIdx: index44("issue_labels_label_idx").on(table.labelId),
+        orgIdx: index44("issue_labels_company_idx").on(table.orgId)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/issue_approvals.ts
-import { pgTable as pgTable49, uuid as uuid47, text as text50, timestamp as timestamp49, index as index44, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable50, uuid as uuid48, text as text51, timestamp as timestamp50, index as index45, primaryKey as primaryKey3 } from "drizzle-orm/pg-core";
 var issueApprovals;
 var init_issue_approvals = __esm({
   "../packages/db/src/schema/issue_approvals.ts"() {
@@ -5689,28 +5766,28 @@ var init_issue_approvals = __esm({
     init_issues();
     init_approvals();
     init_agents();
-    issueApprovals = pgTable49(
+    issueApprovals = pgTable50(
       "issue_approvals",
       {
-        orgId: uuid47("org_id").notNull().references(() => organizations.id),
-        issueId: uuid47("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
-        approvalId: uuid47("approval_id").notNull().references(() => approvals.id, { onDelete: "cascade" }),
-        linkedByAgentId: uuid47("linked_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        linkedByUserId: text50("linked_by_user_id"),
-        createdAt: timestamp49("created_at", { withTimezone: true }).notNull().defaultNow()
+        orgId: uuid48("org_id").notNull().references(() => organizations.id),
+        issueId: uuid48("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+        approvalId: uuid48("approval_id").notNull().references(() => approvals.id, { onDelete: "cascade" }),
+        linkedByAgentId: uuid48("linked_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        linkedByUserId: text51("linked_by_user_id"),
+        createdAt: timestamp50("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         pk: primaryKey3({ columns: [table.issueId, table.approvalId], name: "issue_approvals_pk" }),
-        issueIdx: index44("issue_approvals_issue_idx").on(table.issueId),
-        approvalIdx: index44("issue_approvals_approval_idx").on(table.approvalId),
-        orgIdx: index44("issue_approvals_company_idx").on(table.orgId)
+        issueIdx: index45("issue_approvals_issue_idx").on(table.issueId),
+        approvalIdx: index45("issue_approvals_approval_idx").on(table.approvalId),
+        orgIdx: index45("issue_approvals_company_idx").on(table.orgId)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/issue_comments.ts
-import { pgTable as pgTable50, uuid as uuid48, text as text51, timestamp as timestamp50, index as index45 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable51, uuid as uuid49, text as text52, timestamp as timestamp51, index as index46 } from "drizzle-orm/pg-core";
 var issueComments;
 var init_issue_comments = __esm({
   "../packages/db/src/schema/issue_comments.ts"() {
@@ -5718,27 +5795,27 @@ var init_issue_comments = __esm({
     init_organizations();
     init_issues();
     init_agents();
-    issueComments = pgTable50(
+    issueComments = pgTable51(
       "issue_comments",
       {
-        id: uuid48("id").primaryKey().defaultRandom(),
-        orgId: uuid48("org_id").notNull().references(() => organizations.id),
-        issueId: uuid48("issue_id").notNull().references(() => issues.id),
-        authorAgentId: uuid48("author_agent_id").references(() => agents.id),
-        authorUserId: text51("author_user_id"),
-        body: text51("body").notNull(),
-        createdAt: timestamp50("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp50("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid49("id").primaryKey().defaultRandom(),
+        orgId: uuid49("org_id").notNull().references(() => organizations.id),
+        issueId: uuid49("issue_id").notNull().references(() => issues.id),
+        authorAgentId: uuid49("author_agent_id").references(() => agents.id),
+        authorUserId: text52("author_user_id"),
+        body: text52("body").notNull(),
+        createdAt: timestamp51("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp51("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        issueIdx: index45("issue_comments_issue_idx").on(table.issueId),
-        orgIdx: index45("issue_comments_company_idx").on(table.orgId),
-        orgIssueCreatedAtIdx: index45("issue_comments_company_issue_created_at_idx").on(
+        issueIdx: index46("issue_comments_issue_idx").on(table.issueId),
+        orgIdx: index46("issue_comments_company_idx").on(table.orgId),
+        orgIssueCreatedAtIdx: index46("issue_comments_company_issue_created_at_idx").on(
           table.orgId,
           table.issueId,
           table.createdAt
         ),
-        orgAuthorIssueCreatedAtIdx: index45("issue_comments_company_author_issue_created_at_idx").on(
+        orgAuthorIssueCreatedAtIdx: index46("issue_comments_company_author_issue_created_at_idx").on(
           table.orgId,
           table.authorUserId,
           table.issueId,
@@ -5750,27 +5827,27 @@ var init_issue_comments = __esm({
 });
 
 // ../packages/db/src/schema/issue_read_states.ts
-import { pgTable as pgTable51, uuid as uuid49, text as text52, timestamp as timestamp51, index as index46, uniqueIndex as uniqueIndex27 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable52, uuid as uuid50, text as text53, timestamp as timestamp52, index as index47, uniqueIndex as uniqueIndex27 } from "drizzle-orm/pg-core";
 var issueReadStates;
 var init_issue_read_states = __esm({
   "../packages/db/src/schema/issue_read_states.ts"() {
     "use strict";
     init_organizations();
     init_issues();
-    issueReadStates = pgTable51(
+    issueReadStates = pgTable52(
       "issue_read_states",
       {
-        id: uuid49("id").primaryKey().defaultRandom(),
-        orgId: uuid49("org_id").notNull().references(() => organizations.id),
-        issueId: uuid49("issue_id").notNull().references(() => issues.id),
-        userId: text52("user_id").notNull(),
-        lastReadAt: timestamp51("last_read_at", { withTimezone: true }).notNull().defaultNow(),
-        createdAt: timestamp51("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp51("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid50("id").primaryKey().defaultRandom(),
+        orgId: uuid50("org_id").notNull().references(() => organizations.id),
+        issueId: uuid50("issue_id").notNull().references(() => issues.id),
+        userId: text53("user_id").notNull(),
+        lastReadAt: timestamp52("last_read_at", { withTimezone: true }).notNull().defaultNow(),
+        createdAt: timestamp52("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp52("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyIssueIdx: index46("issue_read_states_company_issue_idx").on(table.orgId, table.issueId),
-        companyUserIdx: index46("issue_read_states_company_user_idx").on(table.orgId, table.userId),
+        companyIssueIdx: index47("issue_read_states_company_issue_idx").on(table.orgId, table.issueId),
+        companyUserIdx: index47("issue_read_states_company_user_idx").on(table.orgId, table.userId),
         companyIssueUserUnique: uniqueIndex27("issue_read_states_company_issue_user_idx").on(
           table.orgId,
           table.issueId,
@@ -5782,26 +5859,26 @@ var init_issue_read_states = __esm({
 });
 
 // ../packages/db/src/schema/messenger_thread_user_states.ts
-import { index as index47, pgTable as pgTable52, text as text53, timestamp as timestamp52, uniqueIndex as uniqueIndex28, uuid as uuid50 } from "drizzle-orm/pg-core";
+import { index as index48, pgTable as pgTable53, text as text54, timestamp as timestamp53, uniqueIndex as uniqueIndex28, uuid as uuid51 } from "drizzle-orm/pg-core";
 var messengerThreadUserStates;
 var init_messenger_thread_user_states = __esm({
   "../packages/db/src/schema/messenger_thread_user_states.ts"() {
     "use strict";
     init_organizations();
-    messengerThreadUserStates = pgTable52(
+    messengerThreadUserStates = pgTable53(
       "messenger_thread_user_states",
       {
-        id: uuid50("id").primaryKey().defaultRandom(),
-        orgId: uuid50("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        userId: text53("user_id").notNull(),
-        threadKey: text53("thread_key").notNull(),
-        lastReadAt: timestamp52("last_read_at", { withTimezone: true }).notNull().defaultNow(),
-        createdAt: timestamp52("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp52("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid51("id").primaryKey().defaultRandom(),
+        orgId: uuid51("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        userId: text54("user_id").notNull(),
+        threadKey: text54("thread_key").notNull(),
+        lastReadAt: timestamp53("last_read_at", { withTimezone: true }).notNull().defaultNow(),
+        createdAt: timestamp53("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp53("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgUserIdx: index47("messenger_thread_user_states_org_user_idx").on(table.orgId, table.userId),
-        orgThreadIdx: index47("messenger_thread_user_states_org_thread_idx").on(table.orgId, table.threadKey),
+        orgUserIdx: index48("messenger_thread_user_states_org_user_idx").on(table.orgId, table.userId),
+        orgThreadIdx: index48("messenger_thread_user_states_org_thread_idx").on(table.orgId, table.threadKey),
         orgThreadUserUnique: uniqueIndex28("messenger_thread_user_states_org_thread_user_idx").on(
           table.orgId,
           table.threadKey,
@@ -5813,7 +5890,7 @@ var init_messenger_thread_user_states = __esm({
 });
 
 // ../packages/db/src/schema/issue_attachments.ts
-import { pgTable as pgTable53, uuid as uuid51, timestamp as timestamp53, index as index48, uniqueIndex as uniqueIndex29, text as text54 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable54, uuid as uuid52, timestamp as timestamp54, index as index49, uniqueIndex as uniqueIndex29, text as text55 } from "drizzle-orm/pg-core";
 var issueAttachments;
 var init_issue_attachments = __esm({
   "../packages/db/src/schema/issue_attachments.ts"() {
@@ -5822,22 +5899,22 @@ var init_issue_attachments = __esm({
     init_issues();
     init_assets();
     init_issue_comments();
-    issueAttachments = pgTable53(
+    issueAttachments = pgTable54(
       "issue_attachments",
       {
-        id: uuid51("id").primaryKey().defaultRandom(),
-        orgId: uuid51("org_id").notNull().references(() => organizations.id),
-        issueId: uuid51("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
-        assetId: uuid51("asset_id").notNull().references(() => assets.id, { onDelete: "cascade" }),
-        issueCommentId: uuid51("issue_comment_id").references(() => issueComments.id, { onDelete: "set null" }),
-        usage: text54("usage").notNull().default("issue"),
-        createdAt: timestamp53("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp53("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid52("id").primaryKey().defaultRandom(),
+        orgId: uuid52("org_id").notNull().references(() => organizations.id),
+        issueId: uuid52("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+        assetId: uuid52("asset_id").notNull().references(() => assets.id, { onDelete: "cascade" }),
+        issueCommentId: uuid52("issue_comment_id").references(() => issueComments.id, { onDelete: "set null" }),
+        usage: text55("usage").notNull().default("issue"),
+        createdAt: timestamp54("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp54("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyIssueIdx: index48("issue_attachments_company_issue_idx").on(table.orgId, table.issueId),
-        issueCommentIdx: index48("issue_attachments_issue_comment_idx").on(table.issueCommentId),
-        usageIdx: index48("issue_attachments_usage_idx").on(table.usage),
+        companyIssueIdx: index49("issue_attachments_company_issue_idx").on(table.orgId, table.issueId),
+        issueCommentIdx: index49("issue_attachments_issue_comment_idx").on(table.issueCommentId),
+        usageIdx: index49("issue_attachments_usage_idx").on(table.usage),
         assetUq: uniqueIndex29("issue_attachments_asset_uq").on(table.assetId)
       })
     );
@@ -5845,40 +5922,40 @@ var init_issue_attachments = __esm({
 });
 
 // ../packages/db/src/schema/documents.ts
-import { pgTable as pgTable54, uuid as uuid52, text as text55, integer as integer15, timestamp as timestamp54, index as index49 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable55, uuid as uuid53, text as text56, integer as integer16, timestamp as timestamp55, index as index50 } from "drizzle-orm/pg-core";
 var documents;
 var init_documents = __esm({
   "../packages/db/src/schema/documents.ts"() {
     "use strict";
     init_organizations();
     init_agents();
-    documents = pgTable54(
+    documents = pgTable55(
       "documents",
       {
-        id: uuid52("id").primaryKey().defaultRandom(),
-        orgId: uuid52("org_id").notNull().references(() => organizations.id),
-        title: text55("title"),
-        format: text55("format").notNull().default("markdown"),
-        latestBody: text55("latest_body").notNull(),
-        latestRevisionId: uuid52("latest_revision_id"),
-        latestRevisionNumber: integer15("latest_revision_number").notNull().default(1),
-        createdByAgentId: uuid52("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        createdByUserId: text55("created_by_user_id"),
-        updatedByAgentId: uuid52("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        updatedByUserId: text55("updated_by_user_id"),
-        createdAt: timestamp54("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp54("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid53("id").primaryKey().defaultRandom(),
+        orgId: uuid53("org_id").notNull().references(() => organizations.id),
+        title: text56("title"),
+        format: text56("format").notNull().default("markdown"),
+        latestBody: text56("latest_body").notNull(),
+        latestRevisionId: uuid53("latest_revision_id"),
+        latestRevisionNumber: integer16("latest_revision_number").notNull().default(1),
+        createdByAgentId: uuid53("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        createdByUserId: text56("created_by_user_id"),
+        updatedByAgentId: uuid53("updated_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        updatedByUserId: text56("updated_by_user_id"),
+        createdAt: timestamp55("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp55("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyUpdatedIdx: index49("documents_company_updated_idx").on(table.orgId, table.updatedAt),
-        companyCreatedIdx: index49("documents_company_created_idx").on(table.orgId, table.createdAt)
+        companyUpdatedIdx: index50("documents_company_updated_idx").on(table.orgId, table.updatedAt),
+        companyCreatedIdx: index50("documents_company_created_idx").on(table.orgId, table.createdAt)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/document_revisions.ts
-import { pgTable as pgTable55, uuid as uuid53, text as text56, integer as integer16, timestamp as timestamp55, index as index50, uniqueIndex as uniqueIndex30 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable56, uuid as uuid54, text as text57, integer as integer17, timestamp as timestamp56, index as index51, uniqueIndex as uniqueIndex30 } from "drizzle-orm/pg-core";
 var documentRevisions;
 var init_document_revisions = __esm({
   "../packages/db/src/schema/document_revisions.ts"() {
@@ -5886,25 +5963,25 @@ var init_document_revisions = __esm({
     init_organizations();
     init_agents();
     init_documents();
-    documentRevisions = pgTable55(
+    documentRevisions = pgTable56(
       "document_revisions",
       {
-        id: uuid53("id").primaryKey().defaultRandom(),
-        orgId: uuid53("org_id").notNull().references(() => organizations.id),
-        documentId: uuid53("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
-        revisionNumber: integer16("revision_number").notNull(),
-        body: text56("body").notNull(),
-        changeSummary: text56("change_summary"),
-        createdByAgentId: uuid53("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        createdByUserId: text56("created_by_user_id"),
-        createdAt: timestamp55("created_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid54("id").primaryKey().defaultRandom(),
+        orgId: uuid54("org_id").notNull().references(() => organizations.id),
+        documentId: uuid54("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+        revisionNumber: integer17("revision_number").notNull(),
+        body: text57("body").notNull(),
+        changeSummary: text57("change_summary"),
+        createdByAgentId: uuid54("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        createdByUserId: text57("created_by_user_id"),
+        createdAt: timestamp56("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         documentRevisionUq: uniqueIndex30("document_revisions_document_revision_uq").on(
           table.documentId,
           table.revisionNumber
         ),
-        companyDocumentCreatedIdx: index50("document_revisions_company_document_created_idx").on(
+        companyDocumentCreatedIdx: index51("document_revisions_company_document_created_idx").on(
           table.orgId,
           table.documentId,
           table.createdAt
@@ -5915,7 +5992,7 @@ var init_document_revisions = __esm({
 });
 
 // ../packages/db/src/schema/issue_documents.ts
-import { pgTable as pgTable56, uuid as uuid54, text as text57, timestamp as timestamp56, index as index51, uniqueIndex as uniqueIndex31 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable57, uuid as uuid55, text as text58, timestamp as timestamp57, index as index52, uniqueIndex as uniqueIndex31 } from "drizzle-orm/pg-core";
 var issueDocuments;
 var init_issue_documents = __esm({
   "../packages/db/src/schema/issue_documents.ts"() {
@@ -5923,16 +6000,16 @@ var init_issue_documents = __esm({
     init_organizations();
     init_issues();
     init_documents();
-    issueDocuments = pgTable56(
+    issueDocuments = pgTable57(
       "issue_documents",
       {
-        id: uuid54("id").primaryKey().defaultRandom(),
-        orgId: uuid54("org_id").notNull().references(() => organizations.id),
-        issueId: uuid54("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
-        documentId: uuid54("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
-        key: text57("key").notNull(),
-        createdAt: timestamp56("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp56("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid55("id").primaryKey().defaultRandom(),
+        orgId: uuid55("org_id").notNull().references(() => organizations.id),
+        issueId: uuid55("issue_id").notNull().references(() => issues.id, { onDelete: "cascade" }),
+        documentId: uuid55("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+        key: text58("key").notNull(),
+        createdAt: timestamp57("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp57("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         companyIssueKeyUq: uniqueIndex31("issue_documents_company_issue_key_uq").on(
@@ -5941,7 +6018,7 @@ var init_issue_documents = __esm({
           table.key
         ),
         documentUq: uniqueIndex31("issue_documents_document_uq").on(table.documentId),
-        companyIssueUpdatedIdx: index51("issue_documents_company_issue_updated_idx").on(
+        companyIssueUpdatedIdx: index52("issue_documents_company_issue_updated_idx").on(
           table.orgId,
           table.issueId,
           table.updatedAt
@@ -5952,7 +6029,7 @@ var init_issue_documents = __esm({
 });
 
 // ../packages/db/src/schema/heartbeat_run_events.ts
-import { pgTable as pgTable57, uuid as uuid55, text as text58, timestamp as timestamp57, integer as integer17, jsonb as jsonb26, index as index52, bigserial } from "drizzle-orm/pg-core";
+import { pgTable as pgTable58, uuid as uuid56, text as text59, timestamp as timestamp58, integer as integer18, jsonb as jsonb27, index as index53, bigserial } from "drizzle-orm/pg-core";
 var heartbeatRunEvents;
 var init_heartbeat_run_events = __esm({
   "../packages/db/src/schema/heartbeat_run_events.ts"() {
@@ -5960,33 +6037,33 @@ var init_heartbeat_run_events = __esm({
     init_organizations();
     init_agents();
     init_heartbeat_runs();
-    heartbeatRunEvents = pgTable57(
+    heartbeatRunEvents = pgTable58(
       "heartbeat_run_events",
       {
         id: bigserial("id", { mode: "number" }).primaryKey(),
-        orgId: uuid55("org_id").notNull().references(() => organizations.id),
-        runId: uuid55("run_id").notNull().references(() => heartbeatRuns.id),
-        agentId: uuid55("agent_id").notNull().references(() => agents.id),
-        seq: integer17("seq").notNull(),
-        eventType: text58("event_type").notNull(),
-        stream: text58("stream"),
-        level: text58("level"),
-        color: text58("color"),
-        message: text58("message"),
-        payload: jsonb26("payload").$type(),
-        createdAt: timestamp57("created_at", { withTimezone: true }).notNull().defaultNow()
+        orgId: uuid56("org_id").notNull().references(() => organizations.id),
+        runId: uuid56("run_id").notNull().references(() => heartbeatRuns.id),
+        agentId: uuid56("agent_id").notNull().references(() => agents.id),
+        seq: integer18("seq").notNull(),
+        eventType: text59("event_type").notNull(),
+        stream: text59("stream"),
+        level: text59("level"),
+        color: text59("color"),
+        message: text59("message"),
+        payload: jsonb27("payload").$type(),
+        createdAt: timestamp58("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        runSeqIdx: index52("heartbeat_run_events_run_seq_idx").on(table.runId, table.seq),
-        companyRunIdx: index52("heartbeat_run_events_company_run_idx").on(table.orgId, table.runId),
-        companyCreatedIdx: index52("heartbeat_run_events_company_created_idx").on(table.orgId, table.createdAt)
+        runSeqIdx: index53("heartbeat_run_events_run_seq_idx").on(table.runId, table.seq),
+        companyRunIdx: index53("heartbeat_run_events_company_run_idx").on(table.orgId, table.runId),
+        companyCreatedIdx: index53("heartbeat_run_events_company_created_idx").on(table.orgId, table.createdAt)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/cost_events.ts
-import { pgTable as pgTable58, uuid as uuid56, text as text59, timestamp as timestamp58, integer as integer18, index as index53 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable59, uuid as uuid57, text as text60, timestamp as timestamp59, integer as integer19, index as index54 } from "drizzle-orm/pg-core";
 var costEvents;
 var init_cost_events = __esm({
   "../packages/db/src/schema/cost_events.ts"() {
@@ -5997,46 +6074,46 @@ var init_cost_events = __esm({
     init_projects();
     init_goals();
     init_heartbeat_runs();
-    costEvents = pgTable58(
+    costEvents = pgTable59(
       "cost_events",
       {
-        id: uuid56("id").primaryKey().defaultRandom(),
-        orgId: uuid56("org_id").notNull().references(() => organizations.id),
-        agentId: uuid56("agent_id").notNull().references(() => agents.id),
-        issueId: uuid56("issue_id").references(() => issues.id),
-        projectId: uuid56("project_id").references(() => projects.id),
-        goalId: uuid56("goal_id").references(() => goals.id),
-        heartbeatRunId: uuid56("heartbeat_run_id").references(() => heartbeatRuns.id),
-        billingCode: text59("billing_code"),
-        provider: text59("provider").notNull(),
-        biller: text59("biller").notNull().default("unknown"),
-        billingType: text59("billing_type").notNull().default("unknown"),
-        model: text59("model").notNull(),
-        inputTokens: integer18("input_tokens").notNull().default(0),
-        cachedInputTokens: integer18("cached_input_tokens").notNull().default(0),
-        outputTokens: integer18("output_tokens").notNull().default(0),
-        costCents: integer18("cost_cents").notNull(),
-        occurredAt: timestamp58("occurred_at", { withTimezone: true }).notNull(),
-        createdAt: timestamp58("created_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid57("id").primaryKey().defaultRandom(),
+        orgId: uuid57("org_id").notNull().references(() => organizations.id),
+        agentId: uuid57("agent_id").notNull().references(() => agents.id),
+        issueId: uuid57("issue_id").references(() => issues.id),
+        projectId: uuid57("project_id").references(() => projects.id),
+        goalId: uuid57("goal_id").references(() => goals.id),
+        heartbeatRunId: uuid57("heartbeat_run_id").references(() => heartbeatRuns.id),
+        billingCode: text60("billing_code"),
+        provider: text60("provider").notNull(),
+        biller: text60("biller").notNull().default("unknown"),
+        billingType: text60("billing_type").notNull().default("unknown"),
+        model: text60("model").notNull(),
+        inputTokens: integer19("input_tokens").notNull().default(0),
+        cachedInputTokens: integer19("cached_input_tokens").notNull().default(0),
+        outputTokens: integer19("output_tokens").notNull().default(0),
+        costCents: integer19("cost_cents").notNull(),
+        occurredAt: timestamp59("occurred_at", { withTimezone: true }).notNull(),
+        createdAt: timestamp59("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyOccurredIdx: index53("cost_events_company_occurred_idx").on(table.orgId, table.occurredAt),
-        companyAgentOccurredIdx: index53("cost_events_company_agent_occurred_idx").on(
+        companyOccurredIdx: index54("cost_events_company_occurred_idx").on(table.orgId, table.occurredAt),
+        companyAgentOccurredIdx: index54("cost_events_company_agent_occurred_idx").on(
           table.orgId,
           table.agentId,
           table.occurredAt
         ),
-        companyProviderOccurredIdx: index53("cost_events_company_provider_occurred_idx").on(
+        companyProviderOccurredIdx: index54("cost_events_company_provider_occurred_idx").on(
           table.orgId,
           table.provider,
           table.occurredAt
         ),
-        companyBillerOccurredIdx: index53("cost_events_company_biller_occurred_idx").on(
+        companyBillerOccurredIdx: index54("cost_events_company_biller_occurred_idx").on(
           table.orgId,
           table.biller,
           table.occurredAt
         ),
-        companyHeartbeatRunIdx: index53("cost_events_company_heartbeat_run_idx").on(
+        companyHeartbeatRunIdx: index54("cost_events_company_heartbeat_run_idx").on(
           table.orgId,
           table.heartbeatRunId
         )
@@ -6046,7 +6123,7 @@ var init_cost_events = __esm({
 });
 
 // ../packages/db/src/schema/finance_events.ts
-import { pgTable as pgTable59, uuid as uuid57, text as text60, timestamp as timestamp59, integer as integer19, index as index54, boolean as boolean11, jsonb as jsonb27 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable60, uuid as uuid58, text as text61, timestamp as timestamp60, integer as integer20, index as index55, boolean as boolean11, jsonb as jsonb28 } from "drizzle-orm/pg-core";
 var financeEvents;
 var init_finance_events = __esm({
   "../packages/db/src/schema/finance_events.ts"() {
@@ -6058,59 +6135,59 @@ var init_finance_events = __esm({
     init_goals();
     init_heartbeat_runs();
     init_cost_events();
-    financeEvents = pgTable59(
+    financeEvents = pgTable60(
       "finance_events",
       {
-        id: uuid57("id").primaryKey().defaultRandom(),
-        orgId: uuid57("org_id").notNull().references(() => organizations.id),
-        agentId: uuid57("agent_id").references(() => agents.id),
-        issueId: uuid57("issue_id").references(() => issues.id),
-        projectId: uuid57("project_id").references(() => projects.id),
-        goalId: uuid57("goal_id").references(() => goals.id),
-        heartbeatRunId: uuid57("heartbeat_run_id").references(() => heartbeatRuns.id),
-        costEventId: uuid57("cost_event_id").references(() => costEvents.id),
-        billingCode: text60("billing_code"),
-        description: text60("description"),
-        eventKind: text60("event_kind").notNull(),
-        direction: text60("direction").notNull().default("debit"),
-        biller: text60("biller").notNull(),
-        provider: text60("provider"),
-        executionAgentRuntimeType: text60("execution_agent_runtime_type"),
-        pricingTier: text60("pricing_tier"),
-        region: text60("region"),
-        model: text60("model"),
-        quantity: integer19("quantity"),
-        unit: text60("unit"),
-        amountCents: integer19("amount_cents").notNull(),
-        currency: text60("currency").notNull().default("USD"),
+        id: uuid58("id").primaryKey().defaultRandom(),
+        orgId: uuid58("org_id").notNull().references(() => organizations.id),
+        agentId: uuid58("agent_id").references(() => agents.id),
+        issueId: uuid58("issue_id").references(() => issues.id),
+        projectId: uuid58("project_id").references(() => projects.id),
+        goalId: uuid58("goal_id").references(() => goals.id),
+        heartbeatRunId: uuid58("heartbeat_run_id").references(() => heartbeatRuns.id),
+        costEventId: uuid58("cost_event_id").references(() => costEvents.id),
+        billingCode: text61("billing_code"),
+        description: text61("description"),
+        eventKind: text61("event_kind").notNull(),
+        direction: text61("direction").notNull().default("debit"),
+        biller: text61("biller").notNull(),
+        provider: text61("provider"),
+        executionAgentRuntimeType: text61("execution_agent_runtime_type"),
+        pricingTier: text61("pricing_tier"),
+        region: text61("region"),
+        model: text61("model"),
+        quantity: integer20("quantity"),
+        unit: text61("unit"),
+        amountCents: integer20("amount_cents").notNull(),
+        currency: text61("currency").notNull().default("USD"),
         estimated: boolean11("estimated").notNull().default(false),
-        externalInvoiceId: text60("external_invoice_id"),
-        metadataJson: jsonb27("metadata_json").$type(),
-        occurredAt: timestamp59("occurred_at", { withTimezone: true }).notNull(),
-        createdAt: timestamp59("created_at", { withTimezone: true }).notNull().defaultNow()
+        externalInvoiceId: text61("external_invoice_id"),
+        metadataJson: jsonb28("metadata_json").$type(),
+        occurredAt: timestamp60("occurred_at", { withTimezone: true }).notNull(),
+        createdAt: timestamp60("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        companyOccurredIdx: index54("finance_events_company_occurred_idx").on(table.orgId, table.occurredAt),
-        companyBillerOccurredIdx: index54("finance_events_company_biller_occurred_idx").on(
+        companyOccurredIdx: index55("finance_events_company_occurred_idx").on(table.orgId, table.occurredAt),
+        companyBillerOccurredIdx: index55("finance_events_company_biller_occurred_idx").on(
           table.orgId,
           table.biller,
           table.occurredAt
         ),
-        companyKindOccurredIdx: index54("finance_events_company_kind_occurred_idx").on(
+        companyKindOccurredIdx: index55("finance_events_company_kind_occurred_idx").on(
           table.orgId,
           table.eventKind,
           table.occurredAt
         ),
-        companyDirectionOccurredIdx: index54("finance_events_company_direction_occurred_idx").on(
+        companyDirectionOccurredIdx: index55("finance_events_company_direction_occurred_idx").on(
           table.orgId,
           table.direction,
           table.occurredAt
         ),
-        companyHeartbeatRunIdx: index54("finance_events_company_heartbeat_run_idx").on(
+        companyHeartbeatRunIdx: index55("finance_events_company_heartbeat_run_idx").on(
           table.orgId,
           table.heartbeatRunId
         ),
-        companyCostEventIdx: index54("finance_events_company_cost_event_idx").on(
+        companyCostEventIdx: index55("finance_events_company_cost_event_idx").on(
           table.orgId,
           table.costEventId
         )
@@ -6120,7 +6197,7 @@ var init_finance_events = __esm({
 });
 
 // ../packages/db/src/schema/approval_comments.ts
-import { pgTable as pgTable60, uuid as uuid58, text as text61, timestamp as timestamp60, index as index55 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable61, uuid as uuid59, text as text62, timestamp as timestamp61, index as index56 } from "drizzle-orm/pg-core";
 var approvalComments;
 var init_approval_comments = __esm({
   "../packages/db/src/schema/approval_comments.ts"() {
@@ -6128,22 +6205,22 @@ var init_approval_comments = __esm({
     init_organizations();
     init_approvals();
     init_agents();
-    approvalComments = pgTable60(
+    approvalComments = pgTable61(
       "approval_comments",
       {
-        id: uuid58("id").primaryKey().defaultRandom(),
-        orgId: uuid58("org_id").notNull().references(() => organizations.id),
-        approvalId: uuid58("approval_id").notNull().references(() => approvals.id),
-        authorAgentId: uuid58("author_agent_id").references(() => agents.id),
-        authorUserId: text61("author_user_id"),
-        body: text61("body").notNull(),
-        createdAt: timestamp60("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp60("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid59("id").primaryKey().defaultRandom(),
+        orgId: uuid59("org_id").notNull().references(() => organizations.id),
+        approvalId: uuid59("approval_id").notNull().references(() => approvals.id),
+        authorAgentId: uuid59("author_agent_id").references(() => agents.id),
+        authorUserId: text62("author_user_id"),
+        body: text62("body").notNull(),
+        createdAt: timestamp61("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp61("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        orgIdx: index55("approval_comments_company_idx").on(table.orgId),
-        approvalIdx: index55("approval_comments_approval_idx").on(table.approvalId),
-        approvalCreatedIdx: index55("approval_comments_approval_created_idx").on(
+        orgIdx: index56("approval_comments_company_idx").on(table.orgId),
+        approvalIdx: index56("approval_comments_approval_idx").on(table.approvalId),
+        approvalCreatedIdx: index56("approval_comments_approval_created_idx").on(
           table.approvalId,
           table.createdAt
         )
@@ -6153,29 +6230,29 @@ var init_approval_comments = __esm({
 });
 
 // ../packages/db/src/schema/organization_secret_versions.ts
-import { pgTable as pgTable61, uuid as uuid59, text as text62, timestamp as timestamp61, integer as integer20, jsonb as jsonb28, index as index56, uniqueIndex as uniqueIndex32 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable62, uuid as uuid60, text as text63, timestamp as timestamp62, integer as integer21, jsonb as jsonb29, index as index57, uniqueIndex as uniqueIndex32 } from "drizzle-orm/pg-core";
 var organizationSecretVersions;
 var init_organization_secret_versions = __esm({
   "../packages/db/src/schema/organization_secret_versions.ts"() {
     "use strict";
     init_agents();
     init_organization_secrets();
-    organizationSecretVersions = pgTable61(
+    organizationSecretVersions = pgTable62(
       "organization_secret_versions",
       {
-        id: uuid59("id").primaryKey().defaultRandom(),
-        secretId: uuid59("secret_id").notNull().references(() => organizationSecrets.id, { onDelete: "cascade" }),
-        version: integer20("version").notNull(),
-        material: jsonb28("material").$type().notNull(),
-        valueSha256: text62("value_sha256").notNull(),
-        createdByAgentId: uuid59("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
-        createdByUserId: text62("created_by_user_id"),
-        createdAt: timestamp61("created_at", { withTimezone: true }).notNull().defaultNow(),
-        revokedAt: timestamp61("revoked_at", { withTimezone: true })
+        id: uuid60("id").primaryKey().defaultRandom(),
+        secretId: uuid60("secret_id").notNull().references(() => organizationSecrets.id, { onDelete: "cascade" }),
+        version: integer21("version").notNull(),
+        material: jsonb29("material").$type().notNull(),
+        valueSha256: text63("value_sha256").notNull(),
+        createdByAgentId: uuid60("created_by_agent_id").references(() => agents.id, { onDelete: "set null" }),
+        createdByUserId: text63("created_by_user_id"),
+        createdAt: timestamp62("created_at", { withTimezone: true }).notNull().defaultNow(),
+        revokedAt: timestamp62("revoked_at", { withTimezone: true })
       },
       (table) => ({
-        secretIdx: index56("organization_secret_versions_secret_idx").on(table.secretId, table.createdAt),
-        valueHashIdx: index56("organization_secret_versions_value_sha256_idx").on(table.valueSha256),
+        secretIdx: index57("organization_secret_versions_secret_idx").on(table.secretId, table.createdAt),
+        valueHashIdx: index57("organization_secret_versions_value_sha256_idx").on(table.valueSha256),
         secretVersionUq: uniqueIndex32("organization_secret_versions_secret_version_uq").on(table.secretId, table.version)
       })
     );
@@ -6184,12 +6261,12 @@ var init_organization_secret_versions = __esm({
 
 // ../packages/db/src/schema/organization_skills.ts
 import {
-  pgTable as pgTable62,
-  uuid as uuid60,
-  text as text63,
-  timestamp as timestamp62,
-  jsonb as jsonb29,
-  index as index57,
+  pgTable as pgTable63,
+  uuid as uuid61,
+  text as text64,
+  timestamp as timestamp63,
+  jsonb as jsonb30,
+  index as index58,
   uniqueIndex as uniqueIndex33
 } from "drizzle-orm/pg-core";
 var organizationSkills;
@@ -6197,29 +6274,29 @@ var init_organization_skills = __esm({
   "../packages/db/src/schema/organization_skills.ts"() {
     "use strict";
     init_organizations();
-    organizationSkills = pgTable62(
+    organizationSkills = pgTable63(
       "organization_skills",
       {
-        id: uuid60("id").primaryKey().defaultRandom(),
-        orgId: uuid60("org_id").notNull().references(() => organizations.id),
-        key: text63("key").notNull(),
-        slug: text63("slug").notNull(),
-        name: text63("name").notNull(),
-        description: text63("description"),
-        markdown: text63("markdown").notNull(),
-        sourceType: text63("source_type").notNull().default("local_path"),
-        sourceLocator: text63("source_locator"),
-        sourceRef: text63("source_ref"),
-        trustLevel: text63("trust_level").notNull().default("markdown_only"),
-        compatibility: text63("compatibility").notNull().default("compatible"),
-        fileInventory: jsonb29("file_inventory").$type().notNull().default([]),
-        metadata: jsonb29("metadata").$type(),
-        createdAt: timestamp62("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp62("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid61("id").primaryKey().defaultRandom(),
+        orgId: uuid61("org_id").notNull().references(() => organizations.id),
+        key: text64("key").notNull(),
+        slug: text64("slug").notNull(),
+        name: text64("name").notNull(),
+        description: text64("description"),
+        markdown: text64("markdown").notNull(),
+        sourceType: text64("source_type").notNull().default("local_path"),
+        sourceLocator: text64("source_locator"),
+        sourceRef: text64("source_ref"),
+        trustLevel: text64("trust_level").notNull().default("markdown_only"),
+        compatibility: text64("compatibility").notNull().default("compatible"),
+        fileInventory: jsonb30("file_inventory").$type().notNull().default([]),
+        metadata: jsonb30("metadata").$type(),
+        createdAt: timestamp63("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp63("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         organizationKeyUniqueIdx: uniqueIndex33("organization_skills_org_key_idx").on(table.orgId, table.key),
-        organizationNameIdx: index57("organization_skills_org_name_idx").on(table.orgId, table.name)
+        organizationNameIdx: index58("organization_skills_org_name_idx").on(table.orgId, table.name)
       })
     );
   }
@@ -6227,61 +6304,61 @@ var init_organization_skills = __esm({
 
 // ../packages/db/src/schema/plugins.ts
 import {
-  pgTable as pgTable63,
-  uuid as uuid61,
-  text as text64,
-  integer as integer21,
-  timestamp as timestamp63,
-  jsonb as jsonb30,
-  index as index58,
+  pgTable as pgTable64,
+  uuid as uuid62,
+  text as text65,
+  integer as integer22,
+  timestamp as timestamp64,
+  jsonb as jsonb31,
+  index as index59,
   uniqueIndex as uniqueIndex34
 } from "drizzle-orm/pg-core";
 var plugins;
 var init_plugins = __esm({
   "../packages/db/src/schema/plugins.ts"() {
     "use strict";
-    plugins = pgTable63(
+    plugins = pgTable64(
       "plugins",
       {
-        id: uuid61("id").primaryKey().defaultRandom(),
-        pluginKey: text64("plugin_key").notNull(),
-        packageName: text64("package_name").notNull(),
-        version: text64("version").notNull(),
-        apiVersion: integer21("api_version").notNull().default(1),
-        categories: jsonb30("categories").$type().notNull().default([]),
-        manifestJson: jsonb30("manifest_json").$type().notNull(),
-        status: text64("status").$type().notNull().default("installed"),
-        installOrder: integer21("install_order"),
+        id: uuid62("id").primaryKey().defaultRandom(),
+        pluginKey: text65("plugin_key").notNull(),
+        packageName: text65("package_name").notNull(),
+        version: text65("version").notNull(),
+        apiVersion: integer22("api_version").notNull().default(1),
+        categories: jsonb31("categories").$type().notNull().default([]),
+        manifestJson: jsonb31("manifest_json").$type().notNull(),
+        status: text65("status").$type().notNull().default("installed"),
+        installOrder: integer22("install_order"),
         /** Resolved package path for local-path installs; used to find worker entrypoint. */
-        packagePath: text64("package_path"),
-        lastError: text64("last_error"),
-        installedAt: timestamp63("installed_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp63("updated_at", { withTimezone: true }).notNull().defaultNow()
+        packagePath: text65("package_path"),
+        lastError: text65("last_error"),
+        installedAt: timestamp64("installed_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp64("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         pluginKeyIdx: uniqueIndex34("plugins_plugin_key_idx").on(table.pluginKey),
-        statusIdx: index58("plugins_status_idx").on(table.status)
+        statusIdx: index59("plugins_status_idx").on(table.status)
       })
     );
   }
 });
 
 // ../packages/db/src/schema/plugin_config.ts
-import { pgTable as pgTable64, uuid as uuid62, text as text65, timestamp as timestamp64, jsonb as jsonb31, uniqueIndex as uniqueIndex35 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable65, uuid as uuid63, text as text66, timestamp as timestamp65, jsonb as jsonb32, uniqueIndex as uniqueIndex35 } from "drizzle-orm/pg-core";
 var pluginConfig;
 var init_plugin_config = __esm({
   "../packages/db/src/schema/plugin_config.ts"() {
     "use strict";
     init_plugins();
-    pluginConfig = pgTable64(
+    pluginConfig = pgTable65(
       "plugin_config",
       {
-        id: uuid62("id").primaryKey().defaultRandom(),
-        pluginId: uuid62("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
-        configJson: jsonb31("config_json").$type().notNull().default({}),
-        lastError: text65("last_error"),
-        createdAt: timestamp64("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp64("updated_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid63("id").primaryKey().defaultRandom(),
+        pluginId: uuid63("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        configJson: jsonb32("config_json").$type().notNull().default({}),
+        lastError: text66("last_error"),
+        createdAt: timestamp65("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp65("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         pluginIdIdx: uniqueIndex35("plugin_config_plugin_id_idx").on(table.pluginId)
@@ -6291,28 +6368,28 @@ var init_plugin_config = __esm({
 });
 
 // ../packages/db/src/schema/plugin_organization_settings.ts
-import { pgTable as pgTable65, uuid as uuid63, text as text66, timestamp as timestamp65, jsonb as jsonb32, index as index59, uniqueIndex as uniqueIndex36, boolean as boolean12 } from "drizzle-orm/pg-core";
+import { pgTable as pgTable66, uuid as uuid64, text as text67, timestamp as timestamp66, jsonb as jsonb33, index as index60, uniqueIndex as uniqueIndex36, boolean as boolean12 } from "drizzle-orm/pg-core";
 var pluginOrganizationSettings;
 var init_plugin_organization_settings = __esm({
   "../packages/db/src/schema/plugin_organization_settings.ts"() {
     "use strict";
     init_organizations();
     init_plugins();
-    pluginOrganizationSettings = pgTable65(
+    pluginOrganizationSettings = pgTable66(
       "plugin_organization_settings",
       {
-        id: uuid63("id").primaryKey().defaultRandom(),
-        orgId: uuid63("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
-        pluginId: uuid63("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        id: uuid64("id").primaryKey().defaultRandom(),
+        orgId: uuid64("org_id").notNull().references(() => organizations.id, { onDelete: "cascade" }),
+        pluginId: uuid64("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
         enabled: boolean12("enabled").notNull().default(true),
-        settingsJson: jsonb32("settings_json").$type().notNull().default({}),
-        lastError: text66("last_error"),
-        createdAt: timestamp65("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp65("updated_at", { withTimezone: true }).notNull().defaultNow()
+        settingsJson: jsonb33("settings_json").$type().notNull().default({}),
+        lastError: text67("last_error"),
+        createdAt: timestamp66("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp66("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        organizationIdx: index59("plugin_organization_settings_org_idx").on(table.orgId),
-        pluginIdx: index59("plugin_organization_settings_plugin_idx").on(table.pluginId),
+        organizationIdx: index60("plugin_organization_settings_org_idx").on(table.orgId),
+        pluginIdx: index60("plugin_organization_settings_plugin_idx").on(table.pluginId),
         organizationPluginUq: uniqueIndex36("plugin_organization_settings_org_plugin_uq").on(
           table.orgId,
           table.pluginId
@@ -6324,12 +6401,12 @@ var init_plugin_organization_settings = __esm({
 
 // ../packages/db/src/schema/plugin_state.ts
 import {
-  pgTable as pgTable66,
-  uuid as uuid64,
-  text as text67,
-  timestamp as timestamp66,
-  jsonb as jsonb33,
-  index as index60,
+  pgTable as pgTable67,
+  uuid as uuid65,
+  text as text68,
+  timestamp as timestamp67,
+  jsonb as jsonb34,
+  index as index61,
   unique as unique2
 } from "drizzle-orm/pg-core";
 var pluginState;
@@ -6337,30 +6414,30 @@ var init_plugin_state = __esm({
   "../packages/db/src/schema/plugin_state.ts"() {
     "use strict";
     init_plugins();
-    pluginState = pgTable66(
+    pluginState = pgTable67(
       "plugin_state",
       {
-        id: uuid64("id").primaryKey().defaultRandom(),
+        id: uuid65("id").primaryKey().defaultRandom(),
         /** FK to the owning plugin. Cascades on delete. */
-        pluginId: uuid64("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        pluginId: uuid65("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
         /** Granularity of the scope (e.g. `"instance"`, `"project"`, `"issue"`). */
-        scopeKind: text67("scope_kind").$type().notNull(),
+        scopeKind: text68("scope_kind").$type().notNull(),
         /**
          * UUID or text identifier for the scoped object.
          * Null for `instance` scope (which has no associated entity).
          */
-        scopeId: text67("scope_id"),
+        scopeId: text68("scope_id"),
         /**
          * Sub-namespace to avoid key collisions within a scope.
          * Defaults to `"default"` if the plugin does not specify one.
          */
-        namespace: text67("namespace").notNull().default("default"),
+        namespace: text68("namespace").notNull().default("default"),
         /** The key identifying this state entry within the namespace. */
-        stateKey: text67("state_key").notNull(),
+        stateKey: text68("state_key").notNull(),
         /** JSON-serializable value stored by the plugin. */
-        valueJson: jsonb33("value_json").notNull(),
+        valueJson: jsonb34("value_json").notNull(),
         /** Timestamp of the most recent write. */
-        updatedAt: timestamp66("updated_at", { withTimezone: true }).notNull().defaultNow()
+        updatedAt: timestamp67("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
         /**
@@ -6382,7 +6459,7 @@ var init_plugin_state = __esm({
           table.stateKey
         ).nullsNotDistinct(),
         /** Speed up lookups by plugin + scope kind (most common access pattern). */
-        pluginScopeIdx: index60("plugin_state_plugin_scope_idx").on(
+        pluginScopeIdx: index61("plugin_state_plugin_scope_idx").on(
           table.pluginId,
           table.scopeKind
         )
@@ -6393,12 +6470,12 @@ var init_plugin_state = __esm({
 
 // ../packages/db/src/schema/plugin_entities.ts
 import {
-  pgTable as pgTable67,
-  uuid as uuid65,
-  text as text68,
-  timestamp as timestamp67,
-  jsonb as jsonb34,
-  index as index61,
+  pgTable as pgTable68,
+  uuid as uuid66,
+  text as text69,
+  timestamp as timestamp68,
+  jsonb as jsonb35,
+  index as index62,
   uniqueIndex as uniqueIndex37
 } from "drizzle-orm/pg-core";
 var pluginEntities;
@@ -6406,27 +6483,27 @@ var init_plugin_entities = __esm({
   "../packages/db/src/schema/plugin_entities.ts"() {
     "use strict";
     init_plugins();
-    pluginEntities = pgTable67(
+    pluginEntities = pgTable68(
       "plugin_entities",
       {
-        id: uuid65("id").primaryKey().defaultRandom(),
-        pluginId: uuid65("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
-        entityType: text68("entity_type").notNull(),
-        scopeKind: text68("scope_kind").$type().notNull(),
-        scopeId: text68("scope_id"),
+        id: uuid66("id").primaryKey().defaultRandom(),
+        pluginId: uuid66("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        entityType: text69("entity_type").notNull(),
+        scopeKind: text69("scope_kind").$type().notNull(),
+        scopeId: text69("scope_id"),
         // NULL for global scope (text to match plugin_state.scope_id)
-        externalId: text68("external_id"),
+        externalId: text69("external_id"),
         // ID in the external system
-        title: text68("title"),
-        status: text68("status"),
-        data: jsonb34("data").$type().notNull().default({}),
-        createdAt: timestamp67("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp67("updated_at", { withTimezone: true }).notNull().defaultNow()
+        title: text69("title"),
+        status: text69("status"),
+        data: jsonb35("data").$type().notNull().default({}),
+        createdAt: timestamp68("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp68("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        pluginIdx: index61("plugin_entities_plugin_idx").on(table.pluginId),
-        typeIdx: index61("plugin_entities_type_idx").on(table.entityType),
-        scopeIdx: index61("plugin_entities_scope_idx").on(table.scopeKind, table.scopeId),
+        pluginIdx: index62("plugin_entities_plugin_idx").on(table.pluginId),
+        typeIdx: index62("plugin_entities_type_idx").on(table.entityType),
+        scopeIdx: index62("plugin_entities_scope_idx").on(table.scopeKind, table.scopeId),
         externalIdx: uniqueIndex37("plugin_entities_external_idx").on(
           table.pluginId,
           table.entityType,
@@ -6439,13 +6516,13 @@ var init_plugin_entities = __esm({
 
 // ../packages/db/src/schema/plugin_jobs.ts
 import {
-  pgTable as pgTable68,
-  uuid as uuid66,
-  text as text69,
-  integer as integer22,
-  timestamp as timestamp68,
-  jsonb as jsonb35,
-  index as index62,
+  pgTable as pgTable69,
+  uuid as uuid67,
+  text as text70,
+  integer as integer23,
+  timestamp as timestamp69,
+  jsonb as jsonb36,
+  index as index63,
   uniqueIndex as uniqueIndex38
 } from "drizzle-orm/pg-core";
 var pluginJobs, pluginJobRuns;
@@ -6453,57 +6530,57 @@ var init_plugin_jobs = __esm({
   "../packages/db/src/schema/plugin_jobs.ts"() {
     "use strict";
     init_plugins();
-    pluginJobs = pgTable68(
+    pluginJobs = pgTable69(
       "plugin_jobs",
       {
-        id: uuid66("id").primaryKey().defaultRandom(),
+        id: uuid67("id").primaryKey().defaultRandom(),
         /** FK to the owning plugin. Cascades on delete. */
-        pluginId: uuid66("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        pluginId: uuid67("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
         /** Identifier matching the key in the plugin manifest's `jobs` array. */
-        jobKey: text69("job_key").notNull(),
+        jobKey: text70("job_key").notNull(),
         /** Cron expression (e.g. `"0 * * * *"`) or interval string. */
-        schedule: text69("schedule").notNull(),
+        schedule: text70("schedule").notNull(),
         /** Current scheduling state. */
-        status: text69("status").$type().notNull().default("active"),
+        status: text70("status").$type().notNull().default("active"),
         /** Timestamp of the most recent successful execution. */
-        lastRunAt: timestamp68("last_run_at", { withTimezone: true }),
+        lastRunAt: timestamp69("last_run_at", { withTimezone: true }),
         /** Pre-computed timestamp of the next scheduled execution. */
-        nextRunAt: timestamp68("next_run_at", { withTimezone: true }),
-        createdAt: timestamp68("created_at", { withTimezone: true }).notNull().defaultNow(),
-        updatedAt: timestamp68("updated_at", { withTimezone: true }).notNull().defaultNow()
+        nextRunAt: timestamp69("next_run_at", { withTimezone: true }),
+        createdAt: timestamp69("created_at", { withTimezone: true }).notNull().defaultNow(),
+        updatedAt: timestamp69("updated_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        pluginIdx: index62("plugin_jobs_plugin_idx").on(table.pluginId),
-        nextRunIdx: index62("plugin_jobs_next_run_idx").on(table.nextRunAt),
+        pluginIdx: index63("plugin_jobs_plugin_idx").on(table.pluginId),
+        nextRunIdx: index63("plugin_jobs_next_run_idx").on(table.nextRunAt),
         uniqueJobIdx: uniqueIndex38("plugin_jobs_unique_idx").on(table.pluginId, table.jobKey)
       })
     );
-    pluginJobRuns = pgTable68(
+    pluginJobRuns = pgTable69(
       "plugin_job_runs",
       {
-        id: uuid66("id").primaryKey().defaultRandom(),
+        id: uuid67("id").primaryKey().defaultRandom(),
         /** FK to the parent job definition. Cascades on delete. */
-        jobId: uuid66("job_id").notNull().references(() => pluginJobs.id, { onDelete: "cascade" }),
+        jobId: uuid67("job_id").notNull().references(() => pluginJobs.id, { onDelete: "cascade" }),
         /** Denormalized FK to the owning plugin for efficient querying. Cascades on delete. */
-        pluginId: uuid66("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        pluginId: uuid67("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
         /** What caused this run to start (`"scheduled"` or `"manual"`). */
-        trigger: text69("trigger").$type().notNull(),
+        trigger: text70("trigger").$type().notNull(),
         /** Current lifecycle state of this run. */
-        status: text69("status").$type().notNull().default("pending"),
+        status: text70("status").$type().notNull().default("pending"),
         /** Wall-clock duration in milliseconds. Null until the run finishes. */
-        durationMs: integer22("duration_ms"),
+        durationMs: integer23("duration_ms"),
         /** Error message if `status === "failed"`. */
-        error: text69("error"),
+        error: text70("error"),
         /** Ordered list of log lines emitted during this run. */
-        logs: jsonb35("logs").$type().notNull().default([]),
-        startedAt: timestamp68("started_at", { withTimezone: true }),
-        finishedAt: timestamp68("finished_at", { withTimezone: true }),
-        createdAt: timestamp68("created_at", { withTimezone: true }).notNull().defaultNow()
+        logs: jsonb36("logs").$type().notNull().default([]),
+        startedAt: timestamp69("started_at", { withTimezone: true }),
+        finishedAt: timestamp69("finished_at", { withTimezone: true }),
+        createdAt: timestamp69("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        jobIdx: index62("plugin_job_runs_job_idx").on(table.jobId),
-        pluginIdx: index62("plugin_job_runs_plugin_idx").on(table.pluginId),
-        statusIdx: index62("plugin_job_runs_status_idx").on(table.status)
+        jobIdx: index63("plugin_job_runs_job_idx").on(table.jobId),
+        pluginIdx: index63("plugin_job_runs_plugin_idx").on(table.pluginId),
+        statusIdx: index63("plugin_job_runs_status_idx").on(table.status)
       })
     );
   }
@@ -6511,47 +6588,47 @@ var init_plugin_jobs = __esm({
 
 // ../packages/db/src/schema/plugin_webhooks.ts
 import {
-  pgTable as pgTable69,
-  uuid as uuid67,
-  text as text70,
-  integer as integer23,
-  timestamp as timestamp69,
-  jsonb as jsonb36,
-  index as index63
+  pgTable as pgTable70,
+  uuid as uuid68,
+  text as text71,
+  integer as integer24,
+  timestamp as timestamp70,
+  jsonb as jsonb37,
+  index as index64
 } from "drizzle-orm/pg-core";
 var pluginWebhookDeliveries;
 var init_plugin_webhooks = __esm({
   "../packages/db/src/schema/plugin_webhooks.ts"() {
     "use strict";
     init_plugins();
-    pluginWebhookDeliveries = pgTable69(
+    pluginWebhookDeliveries = pgTable70(
       "plugin_webhook_deliveries",
       {
-        id: uuid67("id").primaryKey().defaultRandom(),
+        id: uuid68("id").primaryKey().defaultRandom(),
         /** FK to the owning plugin. Cascades on delete. */
-        pluginId: uuid67("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        pluginId: uuid68("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
         /** Identifier matching the key in the plugin manifest's `webhooks` array. */
-        webhookKey: text70("webhook_key").notNull(),
+        webhookKey: text71("webhook_key").notNull(),
         /** Optional de-duplication ID provided by the external system. */
-        externalId: text70("external_id"),
+        externalId: text71("external_id"),
         /** Current delivery state. */
-        status: text70("status").$type().notNull().default("pending"),
+        status: text71("status").$type().notNull().default("pending"),
         /** Wall-clock processing duration in milliseconds. Null until delivery finishes. */
-        durationMs: integer23("duration_ms"),
+        durationMs: integer24("duration_ms"),
         /** Error message if `status === "failed"`. */
-        error: text70("error"),
+        error: text71("error"),
         /** Raw JSON body of the inbound HTTP request. */
-        payload: jsonb36("payload").$type().notNull(),
+        payload: jsonb37("payload").$type().notNull(),
         /** Relevant HTTP headers from the inbound request (e.g. signature headers). */
-        headers: jsonb36("headers").$type().notNull().default({}),
-        startedAt: timestamp69("started_at", { withTimezone: true }),
-        finishedAt: timestamp69("finished_at", { withTimezone: true }),
-        createdAt: timestamp69("created_at", { withTimezone: true }).notNull().defaultNow()
+        headers: jsonb37("headers").$type().notNull().default({}),
+        startedAt: timestamp70("started_at", { withTimezone: true }),
+        finishedAt: timestamp70("finished_at", { withTimezone: true }),
+        createdAt: timestamp70("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        pluginIdx: index63("plugin_webhook_deliveries_plugin_idx").on(table.pluginId),
-        statusIdx: index63("plugin_webhook_deliveries_status_idx").on(table.status),
-        keyIdx: index63("plugin_webhook_deliveries_key_idx").on(table.webhookKey)
+        pluginIdx: index64("plugin_webhook_deliveries_plugin_idx").on(table.pluginId),
+        statusIdx: index64("plugin_webhook_deliveries_status_idx").on(table.status),
+        keyIdx: index64("plugin_webhook_deliveries_key_idx").on(table.webhookKey)
       })
     );
   }
@@ -6559,34 +6636,34 @@ var init_plugin_webhooks = __esm({
 
 // ../packages/db/src/schema/plugin_logs.ts
 import {
-  pgTable as pgTable70,
-  uuid as uuid68,
-  text as text71,
-  timestamp as timestamp70,
-  jsonb as jsonb37,
-  index as index64
+  pgTable as pgTable71,
+  uuid as uuid69,
+  text as text72,
+  timestamp as timestamp71,
+  jsonb as jsonb38,
+  index as index65
 } from "drizzle-orm/pg-core";
 var pluginLogs;
 var init_plugin_logs = __esm({
   "../packages/db/src/schema/plugin_logs.ts"() {
     "use strict";
     init_plugins();
-    pluginLogs = pgTable70(
+    pluginLogs = pgTable71(
       "plugin_logs",
       {
-        id: uuid68("id").primaryKey().defaultRandom(),
-        pluginId: uuid68("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
-        level: text71("level").notNull().default("info"),
-        message: text71("message").notNull(),
-        meta: jsonb37("meta").$type(),
-        createdAt: timestamp70("created_at", { withTimezone: true }).notNull().defaultNow()
+        id: uuid69("id").primaryKey().defaultRandom(),
+        pluginId: uuid69("plugin_id").notNull().references(() => plugins.id, { onDelete: "cascade" }),
+        level: text72("level").notNull().default("info"),
+        message: text72("message").notNull(),
+        meta: jsonb38("meta").$type(),
+        createdAt: timestamp71("created_at", { withTimezone: true }).notNull().defaultNow()
       },
       (table) => ({
-        pluginTimeIdx: index64("plugin_logs_plugin_time_idx").on(
+        pluginTimeIdx: index65("plugin_logs_plugin_time_idx").on(
           table.pluginId,
           table.createdAt
         ),
-        levelIdx: index64("plugin_logs_level_idx").on(table.level)
+        levelIdx: index65("plugin_logs_level_idx").on(table.level)
       })
     );
   }
@@ -6669,6 +6746,7 @@ __export(schema_exports, {
   projectResourceAttachments: () => projectResourceAttachments,
   projectWorkspaces: () => projectWorkspaces,
   projects: () => projects,
+  workspaceBackups: () => workspaceBackups,
   workspaceOperations: () => workspaceOperations,
   workspaceRuntimeServices: () => workspaceRuntimeServices
 });
@@ -6702,6 +6780,7 @@ var init_schema2 = __esm({
     init_project_workspaces();
     init_execution_workspaces();
     init_workspace_operations();
+    init_workspace_backups();
     init_workspace_runtime_services();
     init_project_goals();
     init_goals();
@@ -7578,7 +7657,7 @@ function sanitizeRestoreErrorMessage(error) {
   }
   return error instanceof Error ? error.message : String(error);
 }
-function timestamp71(date2 = /* @__PURE__ */ new Date()) {
+function timestamp72(date2 = /* @__PURE__ */ new Date()) {
   const pad = (n) => String(n).padStart(2, "0");
   return `${date2.getFullYear()}${pad(date2.getMonth() + 1)}${pad(date2.getDate())}-${pad(date2.getHours())}${pad(date2.getMinutes())}${pad(date2.getSeconds())}`;
 }
@@ -7902,8 +7981,8 @@ async function runDatabaseBackup(opts) {
       const rows = await sql4.unsafe(`SELECT * FROM ${qualifiedTableName}`).values();
       const nullifiedColumns = nullifiedColumnsByTable.get(tablename) ?? /* @__PURE__ */ new Set();
       for (const row of rows) {
-        const values = row.map((rawValue, index65) => {
-          const columnName = cols[index65]?.column_name;
+        const values = row.map((rawValue, index66) => {
+          const columnName = cols[index66]?.column_name;
           const val = columnName && nullifiedColumns.has(columnName) ? null : rawValue;
           if (val === null || val === void 0) return "NULL";
           if (typeof val === "boolean") return val ? "true" : "false";
@@ -7933,7 +8012,7 @@ async function runDatabaseBackup(opts) {
     emitStatement("COMMIT;");
     emit("");
     mkdirSync(opts.backupDir, { recursive: true });
-    const backupFile = resolve2(opts.backupDir, `${filenamePrefix}-${timestamp71()}.sql`);
+    const backupFile = resolve2(opts.backupDir, `${filenamePrefix}-${timestamp72()}.sql`);
     await writeFile(backupFile, lines.join("\n"), "utf8");
     const sizeBytes = statSync(backupFile).size;
     const prunedCount = pruneOldBackups(opts.backupDir, retentionDays, filenamePrefix);
@@ -8072,6 +8151,7 @@ __export(src_exports, {
   reconcilePendingMigrationHistory: () => reconcilePendingMigrationHistory,
   runDatabaseBackup: () => runDatabaseBackup,
   runDatabaseRestore: () => runDatabaseRestore,
+  workspaceBackups: () => workspaceBackups,
   workspaceOperations: () => workspaceOperations,
   workspaceRuntimeServices: () => workspaceRuntimeServices
 });
@@ -10432,8 +10512,8 @@ function compareStableSemver(a, b) {
   const aMatch = a.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/);
   const bMatch = b.match(/^([0-9]+)\.([0-9]+)\.([0-9]+)$/);
   if (!aMatch || !bMatch) return 0;
-  for (let index65 = 1; index65 <= 3; index65 += 1) {
-    const diff = Number(aMatch[index65]) - Number(bMatch[index65]);
+  for (let index66 = 1; index66 <= 3; index66 += 1) {
+    const diff = Number(aMatch[index66]) - Number(bMatch[index66]);
     if (diff !== 0) return diff;
   }
   return 0;
@@ -11143,8 +11223,8 @@ function printClaudeStreamEvent(raw, debug) {
       const block = blockRaw;
       const blockType = typeof block.type === "string" ? block.type : "";
       if (blockType === "text") {
-        const text72 = typeof block.text === "string" ? block.text : "";
-        if (text72) console.log(pc10.green(`assistant: ${text72}`));
+        const text73 = typeof block.text === "string" ? block.text : "";
+        if (text73) console.log(pc10.green(`assistant: ${text73}`));
       } else if (blockType === "tool_use") {
         const name = typeof block.name === "string" ? block.name : "unknown";
         console.log(pc10.yellow(`tool_call: ${name}`));
@@ -11236,13 +11316,13 @@ function printItemStarted(item) {
 function printItemCompleted(item) {
   const itemType = asString(item.type);
   if (itemType === "agent_message") {
-    const text72 = asString(item.text);
-    if (text72) console.log(pc11.green(`assistant: ${text72}`));
+    const text73 = asString(item.text);
+    if (text73) console.log(pc11.green(`assistant: ${text73}`));
     return true;
   }
   if (itemType === "reasoning") {
-    const text72 = asString(item.text);
-    if (text72) console.log(pc11.gray(`thinking: ${text72}`));
+    const text73 = asString(item.text);
+    if (text73) console.log(pc11.gray(`thinking: ${text73}`));
     return true;
   }
   if (itemType === "tool_use") {
@@ -11292,9 +11372,9 @@ function printItemCompleted(item) {
   }
   if (itemType === "tool_result") {
     const isError = item.is_error === true || asString(item.status) === "error";
-    const text72 = asString(item.content) || asString(item.result) || asString(item.output);
+    const text73 = asString(item.content) || asString(item.result) || asString(item.output);
     console.log((isError ? pc11.red : pc11.cyan)(`tool_result${isError ? " (error)" : ""}`));
-    if (text72) console.log((isError ? pc11.red : pc11.gray)(text72));
+    if (text73) console.log((isError ? pc11.red : pc11.gray)(text73));
     return true;
   }
   return false;
@@ -11413,8 +11493,8 @@ function stringifyUnknown(value) {
 }
 function printUserMessage(messageRaw) {
   if (typeof messageRaw === "string") {
-    const text72 = messageRaw.trim();
-    if (text72) console.log(pc12.gray(`user: ${text72}`));
+    const text73 = messageRaw.trim();
+    if (text73) console.log(pc12.gray(`user: ${text73}`));
     return;
   }
   const message = asRecord2(messageRaw);
@@ -11427,14 +11507,14 @@ function printUserMessage(messageRaw) {
     if (!part) continue;
     const type = asString2(part.type).trim();
     if (type !== "output_text" && type !== "text") continue;
-    const text72 = asString2(part.text).trim();
-    if (text72) console.log(pc12.gray(`user: ${text72}`));
+    const text73 = asString2(part.text).trim();
+    if (text73) console.log(pc12.gray(`user: ${text73}`));
   }
 }
 function printAssistantMessage(messageRaw) {
   if (typeof messageRaw === "string") {
-    const text72 = messageRaw.trim();
-    if (text72) console.log(pc12.green(`assistant: ${text72}`));
+    const text73 = messageRaw.trim();
+    if (text73) console.log(pc12.green(`assistant: ${text73}`));
     return;
   }
   const message = asRecord2(messageRaw);
@@ -11447,13 +11527,13 @@ function printAssistantMessage(messageRaw) {
     if (!part) continue;
     const type = asString2(part.type).trim();
     if (type === "output_text" || type === "text") {
-      const text72 = asString2(part.text).trim();
-      if (text72) console.log(pc12.green(`assistant: ${text72}`));
+      const text73 = asString2(part.text).trim();
+      if (text73) console.log(pc12.green(`assistant: ${text73}`));
       continue;
     }
     if (type === "thinking") {
-      const text72 = asString2(part.text).trim();
-      if (text72) console.log(pc12.gray(`thinking: ${text72}`));
+      const text73 = asString2(part.text).trim();
+      if (text73) console.log(pc12.gray(`thinking: ${text73}`));
       continue;
     }
     if (type === "tool_call") {
@@ -11573,8 +11653,8 @@ function printCursorStreamEvent(raw, _debug) {
     return;
   }
   if (type === "thinking") {
-    const text72 = asString2(parsed.text).trim() || asString2(asRecord2(parsed.delta)?.text).trim();
-    if (text72) console.log(pc12.gray(`thinking: ${text72}`));
+    const text73 = asString2(parsed.text).trim() || asString2(asRecord2(parsed.delta)?.text).trim();
+    if (text73) console.log(pc12.gray(`thinking: ${text73}`));
     return;
   }
   if (type === "tool_call") {
@@ -11612,8 +11692,8 @@ function printCursorStreamEvent(raw, _debug) {
   }
   if (type === "text") {
     const part = asRecord2(parsed.part);
-    const text72 = asString2(part?.text);
-    if (text72) console.log(pc12.green(`assistant: ${text72}`));
+    const text73 = asString2(part?.text);
+    if (text73) console.log(pc12.green(`assistant: ${text73}`));
     return;
   }
   if (type === "tool_use") {
@@ -11676,8 +11756,8 @@ function errorText2(value) {
 }
 function printTextMessage(prefix, colorize, messageRaw) {
   if (typeof messageRaw === "string") {
-    const text72 = messageRaw.trim();
-    if (text72) console.log(colorize(`${prefix}: ${text72}`));
+    const text73 = messageRaw.trim();
+    if (text73) console.log(colorize(`${prefix}: ${text73}`));
     return;
   }
   const message = asRecord3(messageRaw);
@@ -11690,13 +11770,13 @@ function printTextMessage(prefix, colorize, messageRaw) {
     if (!part) continue;
     const type = asString3(part.type).trim();
     if (type === "output_text" || type === "text" || type === "content") {
-      const text72 = asString3(part.text).trim() || asString3(part.content).trim();
-      if (text72) console.log(colorize(`${prefix}: ${text72}`));
+      const text73 = asString3(part.text).trim() || asString3(part.content).trim();
+      if (text73) console.log(colorize(`${prefix}: ${text73}`));
       continue;
     }
     if (type === "thinking") {
-      const text72 = asString3(part.text).trim();
-      if (text72) console.log(pc13.gray(`thinking: ${text72}`));
+      const text73 = asString3(part.text).trim();
+      if (text73) console.log(pc13.gray(`thinking: ${text73}`));
       continue;
     }
     if (type === "tool_call") {
@@ -11748,8 +11828,8 @@ function printGeminiStreamEvent(raw, _debug) {
       return;
     }
     if (subtype === "error") {
-      const text72 = errorText2(parsed.error ?? parsed.message ?? parsed.detail);
-      if (text72) console.log(pc13.red(`error: ${text72}`));
+      const text73 = errorText2(parsed.error ?? parsed.message ?? parsed.detail);
+      if (text73) console.log(pc13.red(`error: ${text73}`));
       return;
     }
     console.log(pc13.blue(`system: ${subtype || "event"}`));
@@ -11764,8 +11844,8 @@ function printGeminiStreamEvent(raw, _debug) {
     return;
   }
   if (type === "thinking") {
-    const text72 = asString3(parsed.text).trim() || asString3(asRecord3(parsed.delta)?.text).trim();
-    if (text72) console.log(pc13.gray(`thinking: ${text72}`));
+    const text73 = asString3(parsed.text).trim() || asString3(asRecord3(parsed.delta)?.text).trim();
+    if (text73) console.log(pc13.gray(`thinking: ${text73}`));
     return;
   }
   if (type === "tool_call") {
@@ -11801,8 +11881,8 @@ function printGeminiStreamEvent(raw, _debug) {
     return;
   }
   if (type === "error") {
-    const text72 = errorText2(parsed.error ?? parsed.message ?? parsed.detail);
-    if (text72) console.log(pc13.red(`error: ${text72}`));
+    const text73 = errorText2(parsed.error ?? parsed.message ?? parsed.detail);
+    if (text73) console.log(pc13.red(`error: ${text73}`));
     return;
   }
   console.log(line);
@@ -11810,9 +11890,9 @@ function printGeminiStreamEvent(raw, _debug) {
 
 // ../packages/agent-runtimes/opencode-local/src/cli/format-event.ts
 import pc14 from "picocolors";
-function safeJsonParse(text72) {
+function safeJsonParse(text73) {
   try {
-    return JSON.parse(text72);
+    return JSON.parse(text73);
   } catch {
     return null;
   }
@@ -11856,14 +11936,14 @@ function printOpenCodeStreamEvent(raw, _debug) {
   }
   if (type === "text") {
     const part = asRecord4(parsed.part);
-    const text72 = asString4(part?.text).trim();
-    if (text72) console.log(pc14.green(`assistant: ${text72}`));
+    const text73 = asString4(part?.text).trim();
+    if (text73) console.log(pc14.green(`assistant: ${text73}`));
     return;
   }
   if (type === "reasoning") {
     const part = asRecord4(parsed.part);
-    const text72 = asString4(part?.text).trim();
-    if (text72) console.log(pc14.gray(`thinking: ${text72}`));
+    const text73 = asString4(part?.text).trim();
+    if (text73) console.log(pc14.gray(`thinking: ${text73}`));
     return;
   }
   if (type === "tool_use") {
@@ -11911,9 +11991,9 @@ function printOpenCodeStreamEvent(raw, _debug) {
 
 // ../packages/agent-runtimes/pi-local/src/cli/format-event.ts
 import pc15 from "picocolors";
-function safeJsonParse2(text72) {
+function safeJsonParse2(text73) {
   try {
-    return JSON.parse(text72);
+    return JSON.parse(text73);
   } catch {
     return null;
   }
@@ -11955,9 +12035,9 @@ function printPiStreamEvent(raw, _debug) {
     const message = asRecord5(parsed.message);
     if (message) {
       const content = message.content;
-      const text72 = extractTextContent(content);
-      if (text72) {
-        console.log(pc15.green(`assistant: ${text72}`));
+      const text73 = extractTextContent(content);
+      if (text73) {
+        console.log(pc15.green(`assistant: ${text73}`));
       }
     }
     return;
@@ -12526,11 +12606,11 @@ var RudderApiClient = class {
     if (response.status === 204) {
       return null;
     }
-    const text72 = await response.text();
-    if (!text72.trim()) {
+    const text73 = await response.text();
+    if (!text73.trim()) {
       return null;
     }
-    return safeParseJson(text72);
+    return safeParseJson(text73);
   }
 };
 function shouldAttachRunId(method) {
@@ -12545,16 +12625,16 @@ function buildUrl(apiBase, path23) {
   if (query) url.search = query;
   return url.toString();
 }
-function safeParseJson(text72) {
+function safeParseJson(text73) {
   try {
-    return JSON.parse(text72);
+    return JSON.parse(text73);
   } catch {
-    return text72;
+    return text73;
   }
 }
 async function toApiError(response) {
-  const text72 = await response.text();
-  const parsed = safeParseJson(text72);
+  const text73 = await response.text();
+  const parsed = safeParseJson(text73);
   if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
     const body = parsed;
     const message = typeof body.error === "string" && body.error.trim() || typeof body.message === "string" && body.message.trim() || `Request failed with status ${response.status}`;
@@ -15197,8 +15277,8 @@ function filterIssueRows(rows, match) {
   if (!match?.trim()) return rows;
   const needle = match.trim().toLowerCase();
   return rows.filter((row) => {
-    const text72 = [row.identifier, row.title, row.description].filter((part) => Boolean(part)).join("\n").toLowerCase();
-    return text72.includes(needle);
+    const text73 = [row.identifier, row.title, row.description].filter((part) => Boolean(part)).join("\n").toLowerCase();
+    return text73.includes(needle);
   });
 }
 
@@ -15222,6 +15302,37 @@ function isMaintainerOnlySkillTarget(candidate) {
   const normalized = normalizePathSlashes(candidate);
   return normalized.includes("/server/resources/bundled-skills/") || normalized.includes("/.agents/skills/");
 }
+var RUDDER_AGENT_OPERATING_CONTRACT = [
+  "# Rudder Agent Operating Contract",
+  "",
+  "Your home directory is `$AGENT_HOME`. Everything personal to you -- life, memory, knowledge -- lives there. Other agents may have their own folders and you may update them when necessary.",
+  "",
+  "Use these paths consistently:",
+  "",
+  "- Personal instructions live under `$AGENT_HOME/instructions`.",
+  "- Personal memory lives under `$AGENT_HOME/memory`.",
+  "- Tacit memory instruction lives at `$AGENT_HOME/instructions/MEMORY.md` and is automatically loaded when present.",
+  "- Personal skills live under `$AGENT_HOME/skills`.",
+  "- Shared organization workspace root lives under `$RUDDER_ORG_WORKSPACE_ROOT`.",
+  "- Shared organization skills live under `$RUDDER_ORG_SKILLS_DIR`.",
+  "- Shared organization plans live under `$RUDDER_ORG_PLANS_DIR`.",
+  "- Durable shared work output should prefer these managed workspace paths instead of ad-hoc top-level `projects/` folders.",
+  "",
+  "When you write issue comments or chat replies, match the language of the user's or board's most recent substantive message unless they explicitly ask for a different language.",
+  "",
+  "## Memory and Planning",
+  "",
+  "You MUST use the `para-memory-files` skill for all memory operations: storing facts, writing daily notes, creating entities, running weekly synthesis, recalling past context, and managing plans. The skill defines your three-layer memory system (knowledge graph, daily notes, tacit knowledge), the PARA folder structure, atomic fact schemas, memory decay rules, and recall/planning conventions.",
+  "",
+  "Keep stable preferences and operating lessons in `$AGENT_HOME/instructions/MEMORY.md`. Use `$AGENT_HOME/memory/YYYY-MM-DD.md` for daily notes and `$AGENT_HOME/life/` for structured long-term memory; those files are not auto-loaded.",
+  "",
+  "Invoke it whenever you need to remember, retrieve, or organize anything.",
+  "",
+  "## Safety Considerations",
+  "",
+  "- Never exfiltrate secrets or private data.",
+  "- Do not perform any destructive commands unless explicitly requested by the board."
+].join("\n");
 async function resolveRudderSkillsDir(moduleDir, additionalCandidates = []) {
   const candidates = [
     ...RUDDER_SKILL_ROOT_RELATIVE_CANDIDATES.map((relativePath) => path16.resolve(moduleDir, relativePath)),
@@ -18854,9 +18965,9 @@ import { LangfuseClient } from "@langfuse/client";
 
 // ../packages/run-intelligence-core/src/trace.ts
 function truncate(value, maxLength = 180) {
-  const text72 = value.trim();
-  if (!text72) return "";
-  return text72.length > maxLength ? `${text72.slice(0, maxLength - 1)}\u2026` : text72;
+  const text73 = value.trim();
+  if (!text73) return "";
+  return text73.length > maxLength ? `${text73.slice(0, maxLength - 1)}\u2026` : text73;
 }
 function firstMeaningfulLine(value) {
   for (const line of value.split(/\r?\n/)) {
@@ -19660,9 +19771,9 @@ function extractPromptText(body) {
     const nested = asString6(prompt.prompt) ?? asString6(prompt.text);
     if (nested) return nested;
   }
-  const text72 = body.text;
-  if (text72 && typeof text72 === "object" && !Array.isArray(text72)) {
-    const nested = asString6(text72.content) ?? asString6(text72.text);
+  const text73 = body.text;
+  if (text73 && typeof text73 === "object" && !Array.isArray(text73)) {
+    const nested = asString6(text73.content) ?? asString6(text73.text);
     if (nested) return nested;
   }
   return null;