hankweave 0.5.7 → 0.6.2

package/dist/exports/schemas.js

@@ -0,0 +1,1019 @@
+// server/schemas/event-schemas.ts
+import { z } from "zod";
+
+// server/types/budget-types.ts
+var BUDGET_CURRENCIES = ["cost", "duration", "outputTokens", "contextTokens"];
+
+// server/schemas/event-schemas.ts
+var processExitSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("success") }),
+  z.object({ type: z.literal("error"), code: z.number() }),
+  z.object({ type: z.literal("killed"), signal: z.string() })
+]);
+var failureReasonSchema = z.object({
+  type: z.enum(["timeout", "rate-limit", "api-error", "sentinel-load-failure", "unknown"]),
+  retriable: z.boolean(),
+  message: z.string().optional(),
+  sentinelRefs: z.array(z.string()).optional()
+});
+var budgetExceededDataSchema = z.object({
+  currency: z.enum(BUDGET_CURRENCIES),
+  limit: z.number(),
+  used: z.number()
+});
+var tokenUsageSchema = z.object({
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  cacheCreationTokens: z.number(),
+  cacheReadTokens: z.number()
+});
+var fileNodeSchema = z.lazy(() => z.discriminatedUnion("isDirectory", [
+  z.object({
+    name: z.string(),
+    path: z.string(),
+    isDirectory: z.literal(true),
+    children: z.array(fileNodeSchema)
+  }),
+  z.object({
+    name: z.string(),
+    path: z.string(),
+    isDirectory: z.literal(false),
+    lastModified: z.string(),
+    children: z.array(fileNodeSchema)
+  })
+]));
+var codonExecutionSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string().optional(),
+  status: z.enum([
+    "preparing",
+    "starting",
+    "initializing",
+    "running",
+    "completing-sentinels",
+    "completed",
+    "failed",
+    "skipped"
+  ]),
+  startTime: z.string(),
+  endTime: z.string().optional(),
+  sessionId: z.string().optional(),
+  previousSessionId: z.string().optional(),
+  claudeSessionId: z.string().optional(),
+  tokenUsage: tokenUsageSchema.optional(),
+  cost: z.number().optional(),
+  duration: z.number().optional(),
+  exitStatus: processExitSchema.optional(),
+  failureReason: failureReasonSchema.optional(),
+  description: z.string().optional(),
+  finalCost: z.number().optional(),
+  partialCost: z.number().optional(),
+  currentCost: z.number().optional(),
+  completionCheckpoint: z.string().optional(),
+  rigSetupCheckpoint: z.string().optional(),
+  errorCheckpoint: z.string().optional(),
+  skipCheckpoint: z.string().optional()
+});
+var checkpointQueryInfoSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string(),
+  checkpointType: z.enum(["rig-setup", "completed", "error", "skipped"]),
+  sha: z.string(),
+  status: z.enum([
+    "preparing",
+    "starting",
+    "initializing",
+    "running",
+    "completing-sentinels",
+    "completed",
+    "failed",
+    "skipped"
+  ]),
+  timestamp: z.string()
+});
+var serverReadyEventDataSchema = z.object({
+  serverVersion: z.string(),
+  executionPath: z.string(),
+  agentRootPath: z.string(),
+  dataPath: z.string(),
+  port: z.number(),
+  proxyPort: z.number().optional(),
+  outputDirectory: z.string().optional()
+});
+var stateSnapshotEventDataSchema = z.object({
+  currentCodon: codonExecutionSchema.optional(),
+  completedCodons: z.array(codonExecutionSchema),
+  fileTree: z.array(fileNodeSchema),
+  totalCost: z.number(),
+  totalTime: z.number(),
+  recentFileAccess: z.object({
+    path: z.string(),
+    content: z.string(),
+    timestamp: z.date()
+  }).optional(),
+  isRollingBack: z.boolean()
+});
+var codonStartedEventDataSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string(),
+  codonDescription: z.string().optional(),
+  sessionId: z.string(),
+  previousSessionId: z.string().optional(),
+  startTime: z.string().datetime(),
+  promptMetadata: z.object({
+    name: z.string().optional(),
+    description: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    version: z.string().optional(),
+    author: z.string().optional()
+  }).optional()
+});
+var codonCompletedEventDataSchema = z.object({
+  codonId: z.string(),
+  success: z.boolean(),
+  cost: z.number(),
+  duration: z.number(),
+  exitStatus: processExitSchema,
+  failureReason: failureReasonSchema.optional(),
+  failureIgnored: z.boolean().optional(),
+  budgetExceeded: budgetExceededDataSchema.optional()
+});
+var codonExtendedEventDataSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string(),
+  extensionNumber: z.number().int().positive(),
+  exhaustWithPrompt: z.string(),
+  cumulativeTokens: tokenUsageSchema,
+  cumulativeCost: z.number()
+});
+var rigSetupCompletedEventDataSchema = z.object({
+  codonId: z.string(),
+  rigType: z.enum(["command", "commands"]),
+  commandCount: z.number().int().nonnegative(),
+  durationMs: z.number(),
+  createdCheckpoint: z.boolean()
+});
+var rigSetupFailedEventDataSchema = z.object({
+  codonId: z.string(),
+  failureType: z.enum(["command_failed", "timeout", "other"]),
+  exitCode: z.number().optional(),
+  commandIndex: z.number().int().nonnegative().optional(),
+  ignored: z.boolean()
+});
+var rigOutputEventDataSchema = z.object({
+  codonId: z.string(),
+  stream: z.enum(["stdout", "stderr"]),
+  line: z.string(),
+  commandIndex: z.number().int().nonnegative()
+});
+var loopIterationCompletedEventDataSchema = z.object({
+  loopId: z.string(),
+  iteration: z.number().int().nonnegative(),
+  durationMs: z.number(),
+  costUsd: z.number(),
+  tokensUsed: z.number(),
+  isFinal: z.boolean(),
+  terminationReason: z.enum(["iteration_limit", "context_exceeded", "sentinel_skip", "failure"]).optional()
+});
+var assistantActionEventDataSchema = z.object({
+  codonId: z.string(),
+  action: z.enum(["thinking", "message", "tool_use"]),
+  content: z.string(),
+  toolName: z.string().optional(),
+  toolInput: z.record(z.unknown()).optional()
+});
+var tokenUsageEventDataSchema = z.object({
+  codonId: z.string(),
+  inputTokens: z.number(),
+  outputTokens: z.number(),
+  cacheCreationTokens: z.number(),
+  cacheReadTokens: z.number(),
+  totalCost: z.number(),
+  modelId: z.string().optional(),
+  modelUsage: z.record(z.string(), z.object({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadInputTokens: z.number().optional(),
+    cacheCreationInputTokens: z.number().optional(),
+    costUSD: z.number()
+  })).optional()
+});
+var toolResultEventDataSchema = z.object({
+  codonId: z.string(),
+  toolUseId: z.string(),
+  toolName: z.string(),
+  result: z.string(),
+  truncated: z.boolean(),
+  originalLength: z.number(),
+  executionTimeMs: z.number(),
+  isError: z.boolean()
+});
+var fileUpdatedEventDataSchema = z.object({
+  path: z.string(),
+  filename: z.string(),
+  content: z.string(),
+  action: z.enum(["created", "modified", "deleted"])
+});
+var fileTreeUpdatedEventDataSchema = z.object({
+  tree: z.array(fileNodeSchema)
+});
+var errorEventDataSchema = z.object({
+  message: z.string(),
+  codon: z.string().optional(),
+  fatal: z.boolean(),
+  severity: z.enum(["fatal", "codon", "operation", "warning"]).optional(),
+  context: z.string().optional(),
+  code: z.string().optional()
+});
+var incompleteCodonEventDataSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string(),
+  message: z.string()
+});
+var infoEventDataSchema = z.object({
+  message: z.string()
+});
+var serverIdleEventDataSchema = z.object({
+  reason: z.enum(["startup", "codon-completed", "all-codons-completed", "rollback-completed"]),
+  message: z.string()
+});
+var checkpointListEventDataSchema = z.object({
+  runId: z.string(),
+  checkpoints: z.array(checkpointQueryInfoSchema),
+  currentBranch: z.string()
+});
+var rollbackStartedEventDataSchema = z.object({
+  fromRun: z.string(),
+  fromCodon: z.string(),
+  toCodon: z.string(),
+  toCheckpoint: z.string(),
+  checkpointType: z.string(),
+  codonsToProcess: z.array(z.string())
+});
+var rollbackCodonCheckpointEventDataSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string(),
+  checkpoint: z.string(),
+  checkpointType: z.string(),
+  message: z.string()
+});
+var rollbackRigCleanupEventDataSchema = z.object({
+  codonId: z.string(),
+  codonName: z.string(),
+  directories: z.array(z.string()),
+  status: z.enum(["started", "completed", "failed", "partial"]),
+  successfulCleanups: z.array(z.string()).optional(),
+  failedCleanups: z.array(z.object({
+    directory: z.string(),
+    error: z.string()
+  })).optional(),
+  error: z.string().optional()
+});
+var rollbackProgressEventDataSchema = z.object({
+  currentStep: z.number(),
+  totalSteps: z.number(),
+  message: z.string()
+});
+var rollbackCompletedEventDataSchema = z.object({
+  fromRun: z.string(),
+  toRun: z.string(),
+  checkpoint: z.string(),
+  codonId: z.string(),
+  codonName: z.string(),
+  checkpointType: z.string(),
+  autoRestart: z.boolean()
+});
+var archiveCompletedEventDataSchema = z.object({
+  codonId: z.string(),
+  archivedPaths: z.array(z.string())
+});
+var archivePartialEventDataSchema = z.object({
+  codonId: z.string(),
+  archivedPaths: z.array(z.string()),
+  failedPaths: z.array(z.object({
+    path: z.string(),
+    error: z.string()
+  }))
+});
+var rollbackArchiveRestoreEventDataSchema = z.object({
+  codonId: z.string(),
+  restoredPaths: z.array(z.string()),
+  failedPaths: z.array(z.object({
+    path: z.string(),
+    error: z.string()
+  })).optional(),
+  status: z.enum(["completed", "partial", "failed"])
+});
+var pongEventDataSchema = z.object({
+  message: z.string(),
+  timestamp: z.string(),
+  clientId: z.string().optional()
+});
+var historyBatchEventDataSchema = z.object({
+  events: z.array(z.any()),
+  hasMore: z.boolean()
+});
+var stateTransitionEventDataSchema = z.object({
+  transitionType: z.enum([
+    "RunStarted",
+    "RunCompleted",
+    "RunFailed",
+    "RunCrashed",
+    "CodonStarted",
+    "CodonTransitioned",
+    "CostsUpdated",
+    "CostsIncremented",
+    "AssistantMessageCountUpdated",
+    "ExtensionCountUpdated",
+    "CheckpointCreated",
+    "InitialCheckpointSet",
+    "CodonFinalCostSet",
+    "SentinelStatesUpdated"
+  ]),
+  runId: z.string().optional(),
+  codonId: z.string().optional(),
+  transition: z.object({
+    type: z.string(),
+    data: z.record(z.unknown())
+  }),
+  resultingState: z.object({
+    currentRunId: z.string().nullable(),
+    runCount: z.number(),
+    totalCost: z.number(),
+    currentRunCost: z.number()
+  })
+});
+var sentinelLoadedEventDataSchema = z.object({
+  sentinelId: z.string(),
+  codonId: z.string(),
+  model: z.string(),
+  triggerType: z.enum(["event", "sequence"]),
+  executionStrategy: z.enum(["immediate", "debounce", "count", "timeWindow"]),
+  conversational: z.boolean(),
+  source: z.enum(["file", "inline"]),
+  sourcePath: z.string().optional()
+});
+var sentinelUnloadedEventDataSchema = z.object({
+  sentinelId: z.string(),
+  codonId: z.string(),
+  reason: z.enum(["codon-complete", "fatal-error", "consecutive-failures", "shutdown"]),
+  errorType: z.enum(["template", "configuration", "corruption", "resource"]).optional(),
+  finalCost: z.number(),
+  llmCallCount: z.number()
+});
+var sentinelErrorEventDataSchema = z.object({
+  sentinelId: z.string(),
+  codonId: z.string(),
+  errorType: z.enum(["llm-call-failed", "template-render-failed", "file-write-failed"]),
+  message: z.string(),
+  retriable: z.boolean(),
+  consecutiveFailureCount: z.number()
+});
+var sentinelOutputEventDataSchema = z.object({
+  sentinelId: z.string(),
+  codonId: z.string(),
+  triggerNumber: z.number(),
+  outputType: z.enum(["text", "structured"]),
+  content: z.union([z.string(), z.record(z.unknown())]),
+  cost: z.number(),
+  tokens: z.object({
+    input: z.number(),
+    output: z.number()
+  }),
+  eventCount: z.number()
+});
+var sentinelTriggeredEventDataSchema = z.object({
+  sentinelId: z.string(),
+  codonId: z.string(),
+  triggerNumber: z.number(),
+  strategy: z.enum(["immediate", "debounce", "count", "timeWindow"]),
+  eventCount: z.number(),
+  queueSize: z.number()
+});
+var codonBudgetSummaryRowSchema = z.object({
+  codonId: z.string(),
+  loopContext: z.object({
+    loopId: z.string(),
+    iteration: z.number(),
+    codonIndexInLoop: z.number()
+  }).optional(),
+  status: z.enum(["completed", "failed", "skipped", "exceeded", "running"]),
+  budget: z.object({
+    maxDollars: z.number().optional(),
+    maxTimeSeconds: z.number().optional(),
+    maxOutputTokens: z.number().optional()
+  }),
+  actual: z.object({
+    dollars: z.number(),
+    timeSeconds: z.number(),
+    outputTokens: z.number()
+  })
+});
+var budgetSummaryEventDataSchema = z.object({
+  ceiling: z.object({
+    maxDollars: z.number().optional(),
+    maxTimeSeconds: z.number().optional()
+  }),
+  allocation: z.enum(["shared", "proportional", "proportional-strict"]),
+  rows: z.array(codonBudgetSummaryRowSchema),
+  totals: z.object({
+    budgetDollars: z.number().optional(),
+    actualDollars: z.number(),
+    actualTimeSeconds: z.number()
+  })
+});
+var baseEventSchema = z.object({
+  id: z.string(),
+  timestamp: z.string()
+});
+var serverReadyEventSchema = baseEventSchema.extend({
+  type: z.literal("server.ready"),
+  data: serverReadyEventDataSchema
+});
+var stateSnapshotEventSchema = baseEventSchema.extend({
+  type: z.literal("state.snapshot"),
+  data: stateSnapshotEventDataSchema
+});
+var codonStartedEventSchema = baseEventSchema.extend({
+  type: z.literal("codon.started"),
+  data: codonStartedEventDataSchema
+});
+var codonCompletedEventSchema = baseEventSchema.extend({
+  type: z.literal("codon.completed"),
+  data: codonCompletedEventDataSchema
+});
+var codonExtendedEventSchema = baseEventSchema.extend({
+  type: z.literal("codon.extended"),
+  data: codonExtendedEventDataSchema
+});
+var assistantActionEventSchema = baseEventSchema.extend({
+  type: z.literal("assistant.action"),
+  data: assistantActionEventDataSchema
+});
+var tokenUsageEventSchema = baseEventSchema.extend({
+  type: z.literal("token.usage"),
+  data: tokenUsageEventDataSchema
+});
+var toolResultEventSchema = baseEventSchema.extend({
+  type: z.literal("tool.result"),
+  data: toolResultEventDataSchema
+});
+var fileUpdatedEventSchema = baseEventSchema.extend({
+  type: z.literal("file.updated"),
+  data: fileUpdatedEventDataSchema
+});
+var fileTreeUpdatedEventSchema = baseEventSchema.extend({
+  type: z.literal("filetree.updated"),
+  data: fileTreeUpdatedEventDataSchema
+});
+var rigSetupCompletedEventSchema = baseEventSchema.extend({
+  type: z.literal("rig.setup.completed"),
+  data: rigSetupCompletedEventDataSchema
+});
+var rigSetupFailedEventSchema = baseEventSchema.extend({
+  type: z.literal("rig.setup.failed"),
+  data: rigSetupFailedEventDataSchema
+});
+var rigOutputEventSchema = baseEventSchema.extend({
+  type: z.literal("rig.output"),
+  data: rigOutputEventDataSchema
+});
+var loopIterationCompletedEventSchema = baseEventSchema.extend({
+  type: z.literal("loop.iteration.completed"),
+  data: loopIterationCompletedEventDataSchema
+});
+var errorEventSchema = baseEventSchema.extend({
+  type: z.literal("error"),
+  data: errorEventDataSchema
+});
+var incompleteCodonEventSchema = baseEventSchema.extend({
+  type: z.literal("incomplete.codon"),
+  data: incompleteCodonEventDataSchema
+});
+var infoEventSchema = baseEventSchema.extend({
+  type: z.literal("info"),
+  data: infoEventDataSchema
+});
+var serverIdleEventSchema = baseEventSchema.extend({
+  type: z.literal("server.idle"),
+  data: serverIdleEventDataSchema
+});
+var checkpointListEventSchema = baseEventSchema.extend({
+  type: z.literal("checkpoint.list"),
+  data: checkpointListEventDataSchema
+});
+var rollbackStartedEventSchema = baseEventSchema.extend({
+  type: z.literal("rollback.started"),
+  data: rollbackStartedEventDataSchema
+});
+var rollbackCodonCheckpointEventSchema = baseEventSchema.extend({
+  type: z.literal("rollback.codonCheckpoint"),
+  data: rollbackCodonCheckpointEventDataSchema
+});
+var rollbackRigCleanupEventSchema = baseEventSchema.extend({
+  type: z.literal("rollback.rigCleanup"),
+  data: rollbackRigCleanupEventDataSchema
+});
+var rollbackProgressEventSchema = baseEventSchema.extend({
+  type: z.literal("rollback.progress"),
+  data: rollbackProgressEventDataSchema
+});
+var rollbackCompletedEventSchema = baseEventSchema.extend({
+  type: z.literal("rollback.completed"),
+  data: rollbackCompletedEventDataSchema
+});
+var archiveCompletedEventSchema = baseEventSchema.extend({
+  type: z.literal("archive.completed"),
+  data: archiveCompletedEventDataSchema
+});
+var archivePartialEventSchema = baseEventSchema.extend({
+  type: z.literal("archive.partial"),
+  data: archivePartialEventDataSchema
+});
+var rollbackArchiveRestoreEventSchema = baseEventSchema.extend({
+  type: z.literal("rollback.archiveRestore"),
+  data: rollbackArchiveRestoreEventDataSchema
+});
+var pongEventSchema = baseEventSchema.extend({
+  type: z.literal("pong"),
+  data: pongEventDataSchema
+});
+var historyBatchEventSchema = baseEventSchema.extend({
+  type: z.literal("history.batch"),
+  data: historyBatchEventDataSchema
+});
+var stateTransitionEventSchema = baseEventSchema.extend({
+  type: z.literal("state.transition"),
+  data: stateTransitionEventDataSchema
+});
+var sentinelLoadedEventSchema = baseEventSchema.extend({
+  type: z.literal("sentinel.loaded"),
+  data: sentinelLoadedEventDataSchema
+});
+var sentinelUnloadedEventSchema = baseEventSchema.extend({
+  type: z.literal("sentinel.unloaded"),
+  data: sentinelUnloadedEventDataSchema
+});
+var sentinelErrorEventSchema = baseEventSchema.extend({
+  type: z.literal("sentinel.error"),
+  data: sentinelErrorEventDataSchema
+});
+var sentinelOutputEventSchema = baseEventSchema.extend({
+  type: z.literal("sentinel.output"),
+  data: sentinelOutputEventDataSchema
+});
+var sentinelTriggeredEventSchema = baseEventSchema.extend({
+  type: z.literal("sentinel.triggered"),
+  data: sentinelTriggeredEventDataSchema
+});
+var budgetSummaryEventSchema = baseEventSchema.extend({
+  type: z.literal("budget.summary"),
+  data: budgetSummaryEventDataSchema
+});
+var startCodonCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("codon.start"),
+  data: z.object({
+    codonId: z.string(),
+    skipPreCommands: z.boolean().optional()
+  })
+});
+var nextCodonCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("codon.next")
+});
+var skipCodonCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("codon.skip")
+});
+var redoCodonCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("codon.redo")
+});
+var shutdownCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("server.shutdown")
+});
+var forceStopCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("codon.forceStop"),
+  data: z.object({
+    reason: z.string().optional()
+  }).optional()
+});
+var listCheckpointsCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("checkpoint.list"),
+  data: z.object({
+    runId: z.string().optional()
+  }).optional()
+});
+var rollbackToCheckpointCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("rollback.toCheckpoint"),
+  data: z.object({
+    checkpointSha: z.string(),
+    autoRestart: z.boolean().optional()
+  })
+});
+var rollbackToCodonCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("rollback.toCodon"),
+  data: z.object({
+    codonId: z.string(),
+    checkpointType: z.enum(["start", "end", "rig-setup", "completed", "error", "skipped"]),
+    autoRestart: z.boolean().optional()
+  })
+});
+var rollbackToLastSuccessCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("rollback.toLastSuccess"),
+  data: z.object({
+    autoRestart: z.boolean().optional()
+  }).optional()
+});
+var pingCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("ping")
+});
+var pingBroadcastCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("ping.broadcast")
+});
+var historySyncCommandSchema = z.object({
+  id: z.string(),
+  type: z.literal("history.sync")
+});
+var clientCommandSchema = z.discriminatedUnion("type", [
+  startCodonCommandSchema,
+  nextCodonCommandSchema,
+  skipCodonCommandSchema,
+  redoCodonCommandSchema,
+  shutdownCommandSchema,
+  forceStopCommandSchema,
+  listCheckpointsCommandSchema,
+  rollbackToCheckpointCommandSchema,
+  rollbackToCodonCommandSchema,
+  rollbackToLastSuccessCommandSchema,
+  pingCommandSchema,
+  pingBroadcastCommandSchema,
+  historySyncCommandSchema
+]);
+var serverEventSchema = z.discriminatedUnion("type", [
+  serverReadyEventSchema,
+  stateSnapshotEventSchema,
+  codonStartedEventSchema,
+  codonCompletedEventSchema,
+  codonExtendedEventSchema,
+  assistantActionEventSchema,
+  tokenUsageEventSchema,
+  toolResultEventSchema,
+  fileUpdatedEventSchema,
+  fileTreeUpdatedEventSchema,
+  rigSetupCompletedEventSchema,
+  rigSetupFailedEventSchema,
+  rigOutputEventSchema,
+  loopIterationCompletedEventSchema,
+  errorEventSchema,
+  incompleteCodonEventSchema,
+  infoEventSchema,
+  serverIdleEventSchema,
+  checkpointListEventSchema,
+  rollbackStartedEventSchema,
+  rollbackCodonCheckpointEventSchema,
+  rollbackRigCleanupEventSchema,
+  rollbackProgressEventSchema,
+  rollbackCompletedEventSchema,
+  rollbackArchiveRestoreEventSchema,
+  archiveCompletedEventSchema,
+  archivePartialEventSchema,
+  pongEventSchema,
+  historyBatchEventSchema,
+  stateTransitionEventSchema,
+  sentinelLoadedEventSchema,
+  sentinelUnloadedEventSchema,
+  sentinelErrorEventSchema,
+  sentinelOutputEventSchema,
+  sentinelTriggeredEventSchema,
+  budgetSummaryEventSchema
+]);
+var SERVER_STATE_EVENT_TYPES_ARRAY = [
+  "codon.started",
+  "codon.completed",
+  "codon.extended",
+  "state.snapshot",
+  "server.idle",
+  "token.usage",
+  "info",
+  "error",
+  "checkpoint.list",
+  "rollback.started",
+  "rollback.progress",
+  "rollback.codonCheckpoint",
+  "rollback.completed",
+  "rollback.rigCleanup",
+  "rollback.archiveRestore",
+  "state.transition",
+  "loop.iteration.completed",
+  "archive.completed",
+  "archive.partial",
+  "budget.summary"
+];
+var AGENTIC_BACKBONE_EVENT_TYPES_ARRAY = [
+  "assistant.action",
+  "tool.result",
+  "file.updated",
+  "filetree.updated",
+  "rig.setup.completed",
+  "rig.setup.failed",
+  "rig.output"
+];
+var SENTINEL_EVENT_TYPES_ARRAY = [
+  "sentinel.loaded",
+  "sentinel.unloaded",
+  "sentinel.error",
+  "sentinel.output",
+  "sentinel.triggered"
+];
+var CONNECTION_STATE_EVENT_TYPES_ARRAY = [
+  "server.ready",
+  "pong",
+  "history.batch",
+  "incomplete.codon"
+];
+var SERVER_STATE_EVENT_TYPES = new Set(SERVER_STATE_EVENT_TYPES_ARRAY);
+var AGENTIC_BACKBONE_EVENT_TYPES = new Set(AGENTIC_BACKBONE_EVENT_TYPES_ARRAY);
+var SENTINEL_EVENT_TYPES = new Set(SENTINEL_EVENT_TYPES_ARRAY);
+var CONNECTION_STATE_EVENT_TYPES = new Set(CONNECTION_STATE_EVENT_TYPES_ARRAY);
+function isServerStateEvent(event) {
+  return SERVER_STATE_EVENT_TYPES.has(event.type);
+}
+function isAgenticBackboneEvent(event) {
+  return AGENTIC_BACKBONE_EVENT_TYPES.has(event.type);
+}
+function isSentinelEvent(event) {
+  return SENTINEL_EVENT_TYPES.has(event.type);
+}
+function isConnectionStateEvent(event) {
+  return CONNECTION_STATE_EVENT_TYPES.has(event.type);
+}
+var serverEventDataSchemas = {
+  "server.ready": serverReadyEventDataSchema,
+  "state.snapshot": stateSnapshotEventDataSchema,
+  "codon.started": codonStartedEventDataSchema,
+  "codon.completed": codonCompletedEventDataSchema,
+  "codon.extended": codonExtendedEventDataSchema,
+  "assistant.action": assistantActionEventDataSchema,
+  "token.usage": tokenUsageEventDataSchema,
+  "tool.result": toolResultEventDataSchema,
+  "file.updated": fileUpdatedEventDataSchema,
+  "filetree.updated": fileTreeUpdatedEventDataSchema,
+  "rig.setup.completed": rigSetupCompletedEventDataSchema,
+  "rig.setup.failed": rigSetupFailedEventDataSchema,
+  "rig.output": rigOutputEventDataSchema,
+  "loop.iteration.completed": loopIterationCompletedEventDataSchema,
+  error: errorEventDataSchema,
+  "incomplete.codon": incompleteCodonEventDataSchema,
+  info: infoEventDataSchema,
+  "server.idle": serverIdleEventDataSchema,
+  "checkpoint.list": checkpointListEventDataSchema,
+  "rollback.started": rollbackStartedEventDataSchema,
+  "rollback.codonCheckpoint": rollbackCodonCheckpointEventDataSchema,
+  "rollback.rigCleanup": rollbackRigCleanupEventDataSchema,
+  "rollback.progress": rollbackProgressEventDataSchema,
+  "rollback.completed": rollbackCompletedEventDataSchema,
+  "rollback.archiveRestore": rollbackArchiveRestoreEventDataSchema,
+  "archive.completed": archiveCompletedEventDataSchema,
+  "archive.partial": archivePartialEventDataSchema,
+  pong: pongEventDataSchema,
+  "history.batch": historyBatchEventDataSchema,
+  "state.transition": stateTransitionEventDataSchema,
+  "sentinel.loaded": sentinelLoadedEventDataSchema,
+  "sentinel.unloaded": sentinelUnloadedEventDataSchema,
+  "sentinel.error": sentinelErrorEventDataSchema,
+  "sentinel.output": sentinelOutputEventDataSchema,
+  "sentinel.triggered": sentinelTriggeredEventDataSchema,
+  "budget.summary": budgetSummaryEventDataSchema
+};
+var serverEventTypes = Object.keys(serverEventDataSchemas);
+// server/types/claude-session-schema.ts
+import { z as z2 } from "zod";
+var sessionIdSchema = z2.string();
+var uuidSchema = z2.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, "Must be a valid UUID v4");
+var toolNameSchema = z2.string();
+var modelSchema = z2.string().min(1, "Model identifier cannot be empty");
+var permissionModeSchema = z2.enum(["bypassPermissions", "requestPermissions"]);
+var apiKeySourceSchema = z2.string().min(1);
+var systemMessageSchema = z2.object({
+  type: z2.literal("system"),
+  subtype: z2.literal("init"),
+  cwd: z2.string().min(1, "Working directory cannot be empty"),
+  session_id: sessionIdSchema,
+  tools: z2.array(toolNameSchema).min(1, "Must have at least one tool"),
+  mcp_servers: z2.array(z2.unknown()).default([]),
+  model: modelSchema,
+  permissionMode: permissionModeSchema,
+  apiKeySource: apiKeySourceSchema
+}).passthrough();
+var toolUseContentSchema = z2.object({
+  type: z2.literal("tool_use"),
+  id: z2.string().regex(/^(toolu_[a-zA-Z0-9]+|call_[a-fA-F0-9]+)$/, "Invalid tool use ID format"),
+  name: toolNameSchema,
+  input: z2.record(z2.unknown()).optional()
+});
+var textContentSchema = z2.object({
+  type: z2.literal("text"),
+  text: z2.string()
+});
+var thinkingContentSchema = z2.object({
+  type: z2.literal("thinking"),
+  thinking: z2.string()
+});
+var toolResultContentSchema = z2.object({
+  type: z2.literal("tool_result"),
+  tool_use_id: z2.string().regex(/^(toolu_[a-zA-Z0-9]+|call_[a-fA-F0-9]+)$/, "Invalid tool use ID format"),
+  content: z2.union([
+    z2.string(),
+    z2.record(z2.unknown()),
+    z2.array(z2.object({
+      type: z2.literal("text"),
+      text: z2.string()
+    }))
+  ])
+});
+var messageContentSchema = z2.union([
+  toolUseContentSchema,
+  textContentSchema,
+  thinkingContentSchema,
+  toolResultContentSchema
+]);
+var assistantMessageSchema = z2.object({
+  type: z2.literal("assistant"),
+  message: z2.object({
+    id: z2.string().regex(/^(msg_[a-zA-Z0-9]+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i, "Invalid message ID format"),
+    type: z2.literal("message"),
+    role: z2.literal("assistant"),
+    model: modelSchema,
+    content: z2.union([
+      z2.array(messageContentSchema),
+      z2.string()
+    ]),
+    usage: z2.object({
+      input_tokens: z2.number().int().nonnegative(),
+      output_tokens: z2.number().int().nonnegative(),
+      cache_creation_input_tokens: z2.number().int().nonnegative().optional(),
+      cache_read_input_tokens: z2.number().int().nonnegative().optional()
+    }).passthrough().optional(),
+    stop_reason: z2.enum(["end_turn", "max_tokens", "stop_sequence", "tool_use"]).nullable().optional(),
+    stop_sequence: z2.string().nullable().optional()
+  })
+});
+var userMessageSchema = z2.object({
+  type: z2.literal("user"),
+  message: z2.object({
+    role: z2.literal("user"),
+    content: z2.union([
+      z2.array(messageContentSchema),
+      z2.string()
+    ])
+  })
+});
+var resultMessageSchema = z2.object({
+  type: z2.literal("result"),
+  subtype: z2.enum(["success", "error", "error_during_execution"]),
+  is_error: z2.boolean(),
+  duration_ms: z2.number().int().nonnegative(),
+  duration_api_ms: z2.number().int().nonnegative(),
+  num_turns: z2.number().int().nonnegative(),
+  result: z2.string(),
+  session_id: z2.string().optional(),
+  total_cost_usd: z2.number().optional(),
+  usage: z2.object({
+    input_tokens: z2.number().int().nonnegative().optional(),
+    output_tokens: z2.number().int().nonnegative().optional(),
+    cache_creation_input_tokens: z2.number().int().nonnegative().optional(),
+    cache_read_input_tokens: z2.number().int().nonnegative().optional(),
+    server_tool_use: z2.object({
+      web_search_requests: z2.number().int().nonnegative().optional()
+    }).passthrough().optional()
+  }).passthrough().optional()
+}).passthrough();
+var logMessageSchema = z2.union([
+  systemMessageSchema,
+  assistantMessageSchema,
+  userMessageSchema,
+  resultMessageSchema
+]);
+var sessionLogSchema = z2.array(logMessageSchema).min(1, "Session must contain at least one message");
+var sessionMetadataSchema = z2.object({
+  filename: z2.string(),
+  session_id: uuidSchema,
+  total_messages: z2.number().int().nonnegative(),
+  message_type_counts: z2.record(z2.number().int().nonnegative()),
+  tools_used: z2.array(toolNameSchema),
+  tool_use_count: z2.number().int().nonnegative(),
+  duration_ms: z2.number().int().nonnegative().optional(),
+  duration_api_ms: z2.number().int().nonnegative().optional(),
+  num_turns: z2.number().int().nonnegative().optional(),
+  success: z2.boolean().optional(),
+  cwd: z2.string(),
+  model: modelSchema
+});
+var cacheControlSchema = z2.object({
+  type: z2.literal("ephemeral")
+});
+var apiMessageContentSchema = z2.union([
+  z2.object({
+    type: z2.literal("text"),
+    text: z2.string(),
+    cache_control: cacheControlSchema.optional()
+  }),
+  z2.object({
+    type: z2.literal("tool_use"),
+    id: z2.string(),
+    name: toolNameSchema,
+    input: z2.record(z2.unknown()).optional(),
+    cache_control: cacheControlSchema.optional()
+  }),
+  z2.object({
+    type: z2.literal("tool_result"),
+    tool_use_id: z2.string(),
+    content: z2.union([z2.string(), z2.record(z2.unknown())]),
+    cache_control: cacheControlSchema.optional()
+  })
+]);
+var apiMessageSchema = z2.object({
+  role: z2.enum(["user", "assistant", "system"]),
+  content: z2.union([z2.string(), z2.array(apiMessageContentSchema)])
+});
+var apiSystemMessageSchema = z2.object({
+  type: z2.literal("text"),
+  text: z2.string(),
+  cache_control: cacheControlSchema.optional()
+});
+var apiToolSchema = z2.object({
+  name: toolNameSchema,
+  description: z2.string(),
+  input_schema: z2.record(z2.unknown())
+});
+var apiMetadataSchema = z2.object({
+  user_id: z2.string()
+}).passthrough();
+var claudeApiRequestSchema = z2.object({
+  model: modelSchema,
+  messages: z2.array(apiMessageSchema),
+  temperature: z2.number().min(0).max(2).optional(),
+  system: z2.array(apiSystemMessageSchema).optional(),
+  tools: z2.array(apiToolSchema).optional(),
+  metadata: apiMetadataSchema.optional(),
+  max_tokens: z2.number().int().positive().optional(),
+  stream: z2.boolean().optional()
+});
+export {
+  userMessageSchema,
+  toolUseContentSchema,
+  toolResultEventSchema,
+  toolResultEventDataSchema,
+  toolResultContentSchema,
+  tokenUsageEventSchema,
+  tokenUsageEventDataSchema,
+  thinkingContentSchema,
+  textContentSchema,
+  systemMessageSchema,
+  serverReadyEventSchema,
+  serverEventSchema,
+  sentinelUnloadedEventSchema,
+  sentinelUnloadedEventDataSchema,
+  sentinelTriggeredEventSchema,
+  sentinelOutputEventSchema,
+  sentinelOutputEventDataSchema,
+  sentinelLoadedEventSchema,
+  sentinelLoadedEventDataSchema,
+  sentinelErrorEventSchema,
+  rigSetupFailedEventSchema,
+  rigSetupFailedEventDataSchema,
+  rigSetupCompletedEventSchema,
+  rigSetupCompletedEventDataSchema,
+  rigOutputEventSchema,
+  resultMessageSchema,
+  messageContentSchema,
+  loopIterationCompletedEventSchema,
+  loopIterationCompletedEventDataSchema,
+  logMessageSchema,
+  isServerStateEvent,
+  isSentinelEvent,
+  isConnectionStateEvent,
+  isAgenticBackboneEvent,
+  infoEventSchema,
+  fileUpdatedEventSchema,
+  errorEventSchema,
+  codonStartedEventSchema,
+  codonStartedEventDataSchema,
+  codonExtendedEventSchema,
+  codonCompletedEventSchema,
+  codonCompletedEventDataSchema,
+  budgetSummaryEventSchema,
+  assistantMessageSchema,
+  assistantActionEventSchema,
+  assistantActionEventDataSchema
+};